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

import { createPipelineOperations } from "@reaatech/media-pipeline-mcp-pipeline";
import { ArtifactRegistry } from "@reaatech/media-pipeline-mcp-core";
 
const registry = new ArtifactRegistry();
const ops = createPipelineOperations(registry);
 
// List available templates
const templates = ops.listTemplates();
// [{ id: "product-photo", name: "Product Photo Pipeline", ... }, ...]
 
// Instantiate a template with variables
const pipeline = ops.interpolateVariables(
  ops.getTemplate("product-photo")!,
  { prompt: "Professional product photo of a running shoe", dimensions: "1080x1080" },
);
 
// Validate and execute
const validation = ops.validatePipeline({ id: "my-run", steps: pipeline });
if (validation.valid) {
  const result = await ops.executePipeline({ id: "my-run", steps: pipeline });
  console.log(result.status); // "completed"
  result.artifacts.forEach(a => console.log(a.id, a.type));
}

class PipelineOperations {
  constructor(artifactRegistry: ArtifactRegistry, options?: PipelineOperationsOptions);
 
  // Template management
  listTemplates(): PipelineTemplate[];
  getTemplate(templateId: string): PipelineTemplate | undefined;
  interpolateVariables(template: PipelineTemplate, variables: Record<string, string>): PipelineStep[];
 
  // Validation & execution
  validatePipeline(pipeline: { id?: string; steps: Array<{ id: string; inputs: Record<string, unknown> }> }): { valid: boolean; errors: string[] };
  executePipeline(pipeline: { id?: string; steps: Array<{ id: string; operation: string; inputs: Record<string, unknown>; config?: Record<string, unknown> }> }): Promise<{ status: PipelineStatus; artifacts: Artifact[]; cost_usd: number; duration_ms: number; error?: string }>;
 
  // Advanced features
  resumePipeline(runId: string, fromStepId?: string): Promise<Pipeline>;
  estimatePipeline(pipeline: PipelineDefinition): Promise<PipelineEstimate>;
  executeVariants(step: PipelineStep, variantsConfig: VariantsConfig, context: VariantsExecutorContext): Promise<VariantsStepOutput>;
}

interface PipelineTemplate {
  id: string;
  name: string;
  description: string;
  steps: Omit<PipelineStep, "id">[];
}

class VariantsExecutor {
  executeVariants(step: PipelineStep, config: VariantsConfig, context: VariantsExecutorContext): Promise<VariantsStepOutput>;
}

interface VariantResult {
  variantIndex: number;
  artifactId?: string;
  costUsd: number;
  judgeScore?: number;
  judgeRationale?: string;
  winner: boolean;
  rejected?: "safety" | "judge-low" | "gate-fail" | "generation-error";
  generationError?: { code: string; message: string };
}

class BatchExecutor {
  setRowExecutor(fn: (pipeline: unknown, row: Record<string, unknown>, batchId: string) => Promise<RowExecutorResult>): void;
  setReportPersister(fn: (batchId: string, rows: BatchReportRow[]) => Promise<string>): void;
  start(request: BatchRequest): Promise<{ batchId: string; status: string }>;
  getStatus(batchId: string): Promise<BatchStatus | null>;
  cancel(batchId: string): Promise<boolean>;
  retry(request: BatchRetryRequest): Promise<{ batchId: string; status: string }>;
}

type BatchSource =
  | { type: "csv"; uri?: string; columnMap?: Record<string, string>; delimiter?: "," | ";" | "\t"; hasHeader?: boolean; rows?: string }
  | { type: "jsonl"; uri?: string; rows?: string }
  | { type: "inline"; rows: Record<string, unknown>[] };

interface BatchStatus {
  batchId: string;
  status: "pending" | "running" | "completed" | "failed" | "cancelled" | "partial";
  totalRows: number;
  completed: number;
  failed: number;
  inFlight: number;
  costUsd: number;
  startedAt: string;
  completedAt?: string;
  reportArtifactId?: string;
}

class RatioFanOutExecutor {
  executeFanOut(operation: string, inputs: Record<string, unknown>, config: RatioFanOutConfig, providerContext: ProviderContext): Promise<RatioFanOutOutput>;
 
  // Utility: find the closest matching native ratio from an available set
  findBestNativeRatio(target: AspectRatio, available: AspectRatio[]): string | undefined;
}

class ContextResolver {
  resolve(context: RunContext, ref: ContextRef, provider: string): unknown;
  resolveInputs(inputs: Record<string, unknown>, context: RunContext, provider: string, operation?: string): Record<string, unknown>;
}

class LoudnessGateEvaluator {
  evaluate(artifactPath: string, gate: LoudnessGate): Promise<LoudnessVerdict>;
}

class SafetyGateEvaluator {
  constructor(config?: SafetyGateEvaluatorConfig);
  registerClassifier(provider: string, classifier: SafetyClassifier): void;
  evaluate(artifact: SafetyArtifact, gate: SafetyGate): Promise<SafetyVerdict>;
}

new OpenAIModerationClassifier({ apiKey: "sk-..." });

new ReplicateNsfwClassifier({ apiKey: "r8-..." });

interface SafetyVerdict {
  blocked: boolean;
  category?: SafetyCategory;
  score?: number;
  perCategoryScores: Partial<Record<SafetyCategory, number>>;
  provider: string;
  model: string;
  action: "fail" | "warn" | "redact";
  costUsd: number;
  redactedArtifactId?: string;
}

const variantsExecutor = new VariantsExecutor();
const result = await variantsExecutor.executeVariants(
  step,
  {
    n: 4,
    seedStrategy: "sequential",
    judge: { type: "llm-judge", criteria: "Which image looks most professional?" },
    minScore: 0.7,
    loserAction: "archive",
  },
  {
    executeOperation: async (op, inputs, config) => ({
      artifact: { id: "art-1", type: "image", uri: "...", mimeType: "image/png", metadata: {} },
      costUsd: 0.007,
    }),
    llmJudgeFn: async (criteria, artifact, rubric) => ({
      score: 0.85,
      rationale: "Clean composition and lighting",
    }),
  },
);
console.log(result.winner?.judgeScore); // 0.85
console.log(result.losers.length);      // 3

const batch = new BatchExecutor();
batch.setRowExecutor(async (pipeline, row, batchId) => ({
  artifactIds: ["art-1"],
  costUsd: 0.01,
}));
 
const { batchId } = await batch.start({
  pipeline: {
    id: "batch-product",
    steps: [{
      id: "step1",
      operation: "image.generate",
      inputs: { prompt: "{{headline}} product" },
      config: {},
    }],
  },
  source: {
    type: "csv",
    rows: "headline,pricing\nNew Arrival,$99\nLimited Edition,$149",
    columnMap: { headline: "headline" },
  },
  concurrency: 3,
  onRowFailure: "retry-once",
});
 
// Poll status
let status = await batch.getStatus(batchId);
while (status?.status === "running" || status?.status === "pending") {
  await sleep(1000);
  status = await batch.getStatus(batchId);
}
console.log(status); // { status: "completed", completed: 2, failed: 0, costUsd: 0.02 }

const ratioExecutor = createRatioFanOutExecutor();
const output = await ratioExecutor.executeFanOut(
  "image.generate",
  { prompt: "A modern logo", dimensions: "1024x1024" },
  {
    ratios: ["1:1", "16:9", "4:5"],
    fallback: "smart-crop",
    faceAware: true,
  },
  {
    provider: myImageProvider,
    storage: storageBackend,
    operation: "image.generate",
  },
);
 
for (const variant of output.variants) {
  console.log(variant.ratio, variant.source, variant.width, variant.height);
}

const loudnessGate = createLoudnessGateEvaluator();
const verdict = await loudnessGate.evaluate(
  "/path/to/audio.wav",
  {
    type: "loudness",
    preset: "podcast",
    toleranceLu: 0.5,
    action: "normalize",
    inPlace: true,
  },
);
 
console.log(verdict.status);     // "out-of-tolerance" → normalize applied
console.log(verdict.measured);   // { iLufs: -18.5, lra: 8, tpDb: -0.5 }
console.log(verdict.target);     // { iLufs: -16, lra: 10, tpDb: -1.0 }

const safetyGate = new SafetyGateEvaluator();
safetyGate.registerClassifier("openai", new OpenAIModerationClassifier({ apiKey: "sk-..." }));
 
const verdict = await safetyGate.evaluate(
  { id: "art-123", type: "text", text: "User-generated caption" },
  {
    type: "safety",
    provider: "openai",
    block: ["sexual", "hate", "violence"],
    action: "fail",
  },
);
 
if (verdict.blocked) {
  console.error(`Blocked: ${verdict.category} (score: ${verdict.score})`);
}