npm install @reaatech/media-pipeline-mcp-core
# or
pnpm add @reaatech/media-pipeline-mcp-core

import {
  PipelineExecutor,
  PipelineValidator,
  ArtifactRegistry,
  MockProvider,
} from "@reaatech/media-pipeline-mcp-core";
 
const executor = new PipelineExecutor({
  providers: [new MockProvider()],
  defaultStepTimeoutMs: 60000,
});
 
const result = await executor.execute({
  id: "product-photo",
  steps: [
    {
      id: "generate",
      operation: "mock.generate",
      inputs: { prompt: "A sunset over mountains" },
      config: { dimensions: "1024x1024" },
      qualityGate: {
        type: "threshold",
        config: { checks: [{ field: "metadata.width", operator: ">=", value: 1024 }] },
        action: "retry",
        maxRetries: 2,
      },
    },
    {
      id: "upscale",
      operation: "mock.transform",
      inputs: { artifact_id: "{{generate.output}}" },
      config: { scale: "4x" },
    },
  ],
  budget: {
    maxUsd: 1.0,
    onExceed: "abort",
    warnAtPct: 0.8,
  },
});
 
console.log(result.status); // "completed"
console.log(result.artifacts.size); // 2

class PipelineExecutor {
  constructor(options: PipelineExecutorOptions);
  execute(definition: PipelineDefinition, options?: { runId?: string }): Promise<Pipeline>;
  resume(runId: string, fromStepId?: string): Promise<Pipeline>;
  resume(pipeline: Pipeline, action: 'retry' | 'skip' | 'abort'): Promise<Pipeline>;
  estimate(definition: PipelineDefinition): Promise<PipelineEstimate>;
  getRegistry(): ArtifactRegistry;
}

interface Provider {
  readonly name: string;
  readonly supportedOperations: string[];
  execute(operation: string, inputs: Record<string, unknown>, config: Record<string, unknown>): Promise<{
    data?: Buffer | NodeJS.ReadableStream;
    artifact: Omit<Artifact, 'id' | 'createdAt'>;
    cost_usd?: number;
    duration_ms?: number;
  }>;
  healthCheck(): Promise<boolean>;
  estimateCost?(input: { operation: string; params: Record<string, unknown>; config: Record<string, unknown> }): Promise<{ costUsd: number; estimatedDurationMs?: number }>;
}

class PipelineValidator {
  constructor(providerAvailability: ProviderAvailability);
  validate(definition: PipelineDefinition): ValidationResult;
}

class PipelineEstimator {
  constructor(options?: PipelineEstimatorOptions);
  estimate(pipeline: PipelineDefinition): Promise<PipelineEstimate>;
}
 
interface PipelineEstimate {
  totalUsdLow: number;
  totalUsdHigh: number;
  perStep: StepEstimate[];
  warnings: EstimateWarning[];
}

class ArtifactRegistry {
  register(artifact: Omit<Artifact, 'id'>): Artifact;
  registerWithId(id: string, artifact: Omit<Artifact, 'id'>): Artifact;
  get(id: string): Artifact | undefined;
  delete(id: string): boolean;
  list(): Artifact[];
  findBySourceStep(stepId: string): Artifact | undefined;
  deleteBySourceStep(stepId: string): number;
  clear(): void;
  size(): number;
}

import {
  createQualityGateEvaluator,
  ThresholdEvaluator,
  DimensionCheckEvaluator,
  LLMJudgeEvaluator,
  CustomEvaluator,
} from "@reaatech/media-pipeline-mcp-core";
 
const evaluator = createQualityGateEvaluator(
  { type: "threshold", config: { checks: [{ field: "metadata.width", operator: ">=", value: 1024 }] }, action: "fail" },
  llmJudgeFn,   // required for llm-judge type
  customCheckFn // required for custom type
);
 
const result = await evaluator.evaluate(gate, artifact);
// { passed: boolean, reasoning: string, score?: number, action: 'fail' | 'retry' | 'warn' }

class MockProvider implements Provider {
  readonly name: string;
  readonly supportedOperations: string[];
 
  constructor(config?: {
    name?: string;                         // default: "mock"
    operations?: string[];                 // default: ["mock.generate", "mock.transform", "mock.extract"]
    delay?: number;                        // Simulated latency in ms (default: 100)
    failureRate?: number;                  // 0-1 probability of failure (default: 0)
    baseCost?: number;                     // Cost per operation (default: 0.001)
    alwaysPass?: boolean;                  // Generate high-quality (0.99) metadata (default: false)
  });
}

import { createEventBus } from "@reaatech/media-pipeline-mcp-core";
 
const bus = createEventBus<{ kind: "step:complete"; stepId: string; artifactId: string }>();
 
const dispose = bus.on("step:complete", (event) => {
  console.log(`Step ${event.stepId} completed: ${event.artifactId}`);
});
 
bus.emit({ kind: "step:complete", stepId: "generate", artifactId: "artifact-123" });
 
// Promise-based await with optional predicate and timeout
const event = await bus.await("step:complete", (e) => e.stepId === "generate", 5000);
 
dispose(); // Unsubscribe

const executor = new PipelineExecutor({
  providers: [new MockProvider()],
  persistence: stateStore,     // PipelineStateStore for durability
  ledger: costLedger,          // CostLedger for cost tracking
  onEvent: (event) => console.log(event.type, event.pipelineId),
  onCost: (record) => console.log(`Cost: $${record.cost_usd}`),
});
 
// Execute with a specific runId for idempotency
const result = await executor.execute(definition, { runId: "run-001" });
 
// Resume from persistence
const resumed = await executor.resume("run-001");
// Or resume from a specific step
const resumedFrom = await executor.resume("run-001", "upscale");

const estimator = new PipelineEstimator({
  estimateOperation: async (operation, config) => {
    return { usdLow: 0.001, usdHigh: 0.01 };
  },
  ledger: costLedger,
});
 
const estimate = await estimator.estimate(definition);
console.log(`Cost range: $${estimate.totalUsdLow} - $${estimate.totalUsdHigh}`);

const validator = new PipelineValidator({
  isAvailable: (op) => providers.has(op),
  getEstimatedCost: (op) => 0.01,
  getEstimatedDuration: (op) => 5000,
});
 
const result = validator.validate(definition);
if (!result.valid) {
  result.errors.forEach(e => console.error(e));
}
result.warnings.forEach(w => console.warn(w));

const executor = new PipelineExecutor({
  providers: [new MockProvider()],
  llmJudgeFn: async (prompt, artifact) => {
    const response = await callLLM(prompt, artifact.uri);
    return { pass: response.score >= 7, reasoning: response.explanation, score: response.score };
  },
});
 
// Step with llm-judge:
{
  id: "generate",
  operation: "image.generate",
  inputs: { prompt: "..." },
  config: {},
  qualityGate: {
    type: "llm-judge",
    config: { prompt: "Rate image quality from 1-10", timeout: 30000 },
    action: "retry",
    maxRetries: 2,
  },
}

const bus = createEventBus<{ kind: "pipeline:complete"; pipelineId: string; artifacts: string[] }>();
 
bus.on("pipeline:complete", (event) => {
  console.log(`Pipeline ${event.pipelineId} done with ${event.artifacts.length} artifacts`);
});
 
// Await an event
const completed = await bus.await("pipeline:complete", (e) => e.pipelineId === "my-pipeline", 60000);