@hadialmarzooq/agent-media-mcp 0.2.0 → 0.4.0

package/dist/index.js

@@ -11,17 +11,24 @@ import {
   parsePlan,
   planMedia,
   validatePlan,
-  verifyMedia
+  verifyMedia,
+  inspectPlanIssues,
+  repairPlan,
+  parseReceipt,
+  mediaPlanSchemaId,
+  mediaPlanSchemaVersion
 } from "@hadialmarzooq/agent-media-core";
 import {
   concatenate,
   executePlan,
   extractAudio,
+  resumeFromReceipt,
   extractFrame,
   getCapabilities,
   inspectMedia,
   makeVertical,
   normalize,
+  operatorLimits,
   optimizeForWeb
 } from "@hadialmarzooq/agent-media-ffmpeg";
 import { z } from "zod";
@@ -54,24 +61,121 @@ function validateGoalSchema(goals) {
   }
   return goals;
 }
-var planRefSchema = z.object({ irVersion: z.literal("1"), source: z.object({ path: z.string() }) }).passthrough();
+var planRefSchema = z.object({ irVersion: z.string().min(1), source: z.object({ path: z.string() }) }).passthrough();
+var videoStreamSchema = z.object({
+  width: z.number(),
+  height: z.number(),
+  aspectRatio: z.string(),
+  fps: z.number().optional(),
+  codec: z.string().optional(),
+  pixelFormat: z.string().optional(),
+  rotationDegrees: z.number().optional()
+});
+var mediaMetadataShape = {
+  path: z.string(),
+  kind: z.enum(["video", "audio", "image", "unknown"]),
+  durationSeconds: z.number().optional(),
+  container: z.string().optional(),
+  sizeBytes: z.number(),
+  video: videoStreamSchema.optional(),
+  audio: z.object({
+    present: z.boolean(),
+    codec: z.string().optional(),
+    sampleRate: z.number().optional(),
+    channels: z.number().optional()
+  })
+};
+var mediaMetadataSchema = z.object(mediaMetadataShape);
+var verificationShape = {
+  passed: z.boolean(),
+  checks: z.record(
+    z.string(),
+    z.object({
+      passed: z.boolean(),
+      expected: z.unknown(),
+      actual: z.unknown(),
+      message: z.string()
+    })
+  ),
+  failures: z.array(z.string()),
+  warnings: z.array(z.string())
+};
+var verificationSchema = z.object(verificationShape);
+var planSchema = z.object({
+  irVersion: z.literal("1"),
+  source: z.object({ path: z.string() }),
+  constraints: z.record(z.string(), z.unknown()),
+  steps: z.array(z.record(z.string(), z.unknown())),
+  expectations: z.record(z.string(), z.unknown())
+});
+var echoedObject = z.looseObject({});
+var receiptSchema = z.looseObject({ receiptVersion: z.string(), planFingerprint: z.string() });
+var workflowResultShape = {
+  source: echoedObject,
+  plan: echoedObject,
+  output: mediaMetadataSchema,
+  verification: verificationSchema,
+  resumed: z.boolean().optional(),
+  receipt: receiptSchema.optional()
+};
+var contentChecksSchema = z.object({
+  blackFrames: z.union([z.boolean(), z.object({ minDurationSeconds: z.number().positive() })]).optional(),
+  silence: z.union([
+    z.boolean(),
+    z.object({
+      thresholdDb: z.number().optional(),
+      minDurationSeconds: z.number().positive().optional()
+    })
+  ]).optional(),
+  freeze: z.union([z.boolean(), z.object({ minDurationSeconds: z.number().positive() })]).optional(),
+  completeness: z.boolean().optional()
+}).strict();
+var contentCheckInputs = {
+  contentChecks: contentChecksSchema.optional().describe("Decode the output once and check what it contains, not just its shape."),
+  warnOnly: z.array(z.string().min(1)).optional().describe("Check names that warn instead of failing the call.")
+};
+function contentCheckOptions(value) {
+  return value === void 0 ? {} : { contentChecks: value };
+}
 var readOnlyHint = { readOnlyHint: true };
 var destructiveHint = { destructiveHint: true };
 function createMcpServer() {
   const server = new McpServer({ name: "agent-media", version: packageVersion });
+  const limits = operatorLimits();
+  const probeOptions = {
+    ...limits.ffprobePath === void 0 ? {} : { ffprobePath: limits.ffprobePath },
+    ...limits.timeoutMs === void 0 ? {} : { timeoutMs: limits.timeoutMs }
+  };
   server.registerTool(
     "inspect_media",
     {
       description: "Inspect normalized media metadata. Paths resolve against the server working directory; absolute paths are recommended.",
       inputSchema: { input: z.string().min(1) },
+      outputSchema: mediaMetadataShape,
       annotations: readOnlyHint
     },
-    async ({ input }) => safely(async () => inspectMedia(input))
+    async ({ input }) => safely(async () => inspectMedia(input, probeOptions))
   );
   server.registerTool(
     "get_media_capabilities",
     {
       description: "Detect local FFmpeg capabilities.",
+      outputSchema: {
+        ffmpegVersion: z.string(),
+        encoders: z.object({
+          h264: z.boolean(),
+          hevc: z.boolean(),
+          av1: z.boolean(),
+          aac: z.boolean()
+        }),
+        hardwareAcceleration: z.array(z.string()),
+        filters: z.object({
+          scale: z.boolean(),
+          crop: z.boolean(),
+          concat: z.boolean(),
+          subtitles: z.boolean()
+        })
+      },
       annotations: readOnlyHint
     },
     async () => safely(getCapabilities)
@@ -79,18 +183,96 @@ function createMcpServer() {
   server.registerTool(
     "plan_media",
     {
-      description: "Create an inspectable versioned semantic Media IR plan from semantic goals. All goals in the MediaGoals type are accepted.",
+      description: `Create an inspectable versioned semantic Media IR plan from semantic goals. All goals in the MediaGoals type are accepted. Plans conform to the canonical Media IR v${mediaPlanSchemaVersion} JSON Schema at ${mediaPlanSchemaId}, also returned by get_media_plan_schema.`,
       inputSchema: { input: z.string().min(1), goals: goalSchema },
+      outputSchema: { plan: planSchema },
       annotations: readOnlyHint
     },
     async ({ input, goals }) => safely(async () => ({
       plan: planMedia({
-        source: await inspectMedia(input),
+        source: await inspectMedia(input, probeOptions),
         goals: cleanGoals(validateGoalSchema(goals)),
-        capabilities: await getCapabilities()
+        capabilities: await getCapabilities(probeOptions)
       })
     }))
   );
+  server.registerTool(
+    "validate_plan",
+    {
+      description: `Detect mechanical plan issues (impossible trims, dimension conflicts, out-of-range timestamps, concatenation stream conflicts) against a real source without executing. Plans conform to the canonical Media IR v${mediaPlanSchemaVersion} JSON Schema at ${mediaPlanSchemaId}. Read-only.`,
+      inputSchema: {
+        plan: z.union([z.string().min(1), planRefSchema])
+      },
+      outputSchema: {
+        issues: z.array(
+          z.object({
+            field: z.string(),
+            message: z.string(),
+            repairable: z.boolean(),
+            normalization: z.array(
+              z.object({
+                input: z.string(),
+                differences: z.array(z.string()),
+                plan: planSchema
+              })
+            ).optional()
+          })
+        )
+      },
+      annotations: readOnlyHint
+    },
+    async ({ plan: input }) => safely(async () => {
+      const plan = normalizePlan(input);
+      const source = await inspectMedia(plan.source.path, probeOptions);
+      const concatenationSources = await inspectConcatenationSources(plan, source, probeOptions);
+      return {
+        issues: inspectPlanIssues(plan, source, {
+          ...concatenationSources === void 0 ? {} : { concatenationSources }
+        })
+      };
+    })
+  );
+  server.registerTool(
+    "repair_plan",
+    {
+      description: `Repair mechanical plan issues (clamp trims and timestamps into source duration, reconcile resize with aspect ratio) and return the repaired plan with a structured repair report. Plans conform to the canonical Media IR v${mediaPlanSchemaVersion} JSON Schema at ${mediaPlanSchemaId}.`,
+      inputSchema: {
+        plan: z.union([z.string().min(1), planRefSchema])
+      },
+      outputSchema: {
+        repairs: z.array(
+          z.object({
+            field: z.string(),
+            action: z.string(),
+            from: z.unknown(),
+            to: z.unknown()
+          })
+        ),
+        repairedPlan: planSchema
+      },
+      annotations: readOnlyHint
+    },
+    async ({ plan: input }) => safely(async () => {
+      const plan = normalizePlan(input);
+      const { plan: repaired, repairs } = repairPlan(
+        plan,
+        await inspectMedia(plan.source.path, probeOptions)
+      );
+      return { repairs, repairedPlan: repaired };
+    })
+  );
+  server.registerTool(
+    "get_media_plan_schema",
+    {
+      description: `Return the canonical Media Plan JSON Schema (Media IR v${mediaPlanSchemaVersion}, ${mediaPlanSchemaId}) generated from the runtime models, so agent tooling cannot drift.`,
+      outputSchema: { $id: z.string(), schema: z.record(z.string(), z.unknown()) },
+      annotations: readOnlyHint
+    },
+    async () => safely(async () => {
+      const { mediaPlanJsonSchema } = await import("@hadialmarzooq/agent-media-core");
+      return { $id: mediaPlanSchemaId, schema: mediaPlanJsonSchema };
+    })
+  );
   server.registerTool(
     "make_vertical",
     {
@@ -104,26 +286,33 @@ function createMcpServer() {
         durationSeconds: z.number().positive().optional(),
         maxSizeMB: z.number().positive().optional(),
         audio: z.enum(["preserve", "remove"]).optional(),
-        overwrite: z.boolean().optional()
+        overwrite: z.boolean().optional(),
+        ...contentCheckInputs
       },
+      outputSchema: workflowResultShape,
       annotations: destructiveHint
     },
     async (options, extra) => {
       const notifications = mcpProgress(extra);
       const response = await safely(
-        async () => makeVertical({
-          input: options.input,
-          output: options.output,
-          ...options.width === void 0 ? {} : { width: options.width },
-          ...options.height === void 0 ? {} : { height: options.height },
-          ...options.trimStartSeconds === void 0 ? {} : { trimStartSeconds: options.trimStartSeconds },
-          ...options.durationSeconds === void 0 ? {} : { durationSeconds: options.durationSeconds },
-          ...options.maxSizeMB === void 0 ? {} : { maxSizeMB: options.maxSizeMB },
-          ...options.audio === void 0 ? {} : { audio: options.audio },
-          ...options.overwrite === void 0 ? {} : { overwrite: options.overwrite },
-          signal: extra.signal,
-          onProgress: notifications.notify
-        })
+        async () => workflowResponse(
+          await makeVertical({
+            input: options.input,
+            output: options.output,
+            ...options.width === void 0 ? {} : { width: options.width },
+            ...options.height === void 0 ? {} : { height: options.height },
+            ...options.trimStartSeconds === void 0 ? {} : { trimStartSeconds: options.trimStartSeconds },
+            ...options.durationSeconds === void 0 ? {} : { durationSeconds: options.durationSeconds },
+            ...options.maxSizeMB === void 0 ? {} : { maxSizeMB: options.maxSizeMB },
+            ...options.audio === void 0 ? {} : { audio: options.audio },
+            ...options.overwrite === void 0 ? {} : { overwrite: options.overwrite },
+            ...contentCheckOptions(options.contentChecks),
+            ...options.warnOnly === void 0 ? {} : { warnOnly: options.warnOnly },
+            ...limits,
+            signal: extra.signal,
+            onProgress: notifications.notify
+          })
+        )
       );
       await notifications.drain();
       return response;
@@ -141,25 +330,32 @@ function createMcpServer() {
         maxSizeMB: z.number().positive().optional(),
         quality: z.enum(["high", "balanced", "small"]).optional(),
         audio: z.enum(["preserve", "remove"]).optional(),
-        overwrite: z.boolean().optional()
+        overwrite: z.boolean().optional(),
+        ...contentCheckInputs
       },
+      outputSchema: workflowResultShape,
       annotations: destructiveHint
     },
     async (options, extra) => {
       const notifications = mcpProgress(extra);
       const response = await safely(
-        async () => optimizeForWeb({
-          input: options.input,
-          output: options.output,
-          ...options.trimStartSeconds === void 0 ? {} : { trimStartSeconds: options.trimStartSeconds },
-          ...options.durationSeconds === void 0 ? {} : { durationSeconds: options.durationSeconds },
-          ...options.maxSizeMB === void 0 ? {} : { maxSizeMB: options.maxSizeMB },
-          ...options.quality === void 0 ? {} : { quality: options.quality },
-          ...options.audio === void 0 ? {} : { audio: options.audio },
-          ...options.overwrite === void 0 ? {} : { overwrite: options.overwrite },
-          signal: extra.signal,
-          onProgress: notifications.notify
-        })
+        async () => workflowResponse(
+          await optimizeForWeb({
+            input: options.input,
+            output: options.output,
+            ...options.trimStartSeconds === void 0 ? {} : { trimStartSeconds: options.trimStartSeconds },
+            ...options.durationSeconds === void 0 ? {} : { durationSeconds: options.durationSeconds },
+            ...options.maxSizeMB === void 0 ? {} : { maxSizeMB: options.maxSizeMB },
+            ...options.quality === void 0 ? {} : { quality: options.quality },
+            ...options.audio === void 0 ? {} : { audio: options.audio },
+            ...options.overwrite === void 0 ? {} : { overwrite: options.overwrite },
+            ...contentCheckOptions(options.contentChecks),
+            ...options.warnOnly === void 0 ? {} : { warnOnly: options.warnOnly },
+            ...limits,
+            signal: extra.signal,
+            onProgress: notifications.notify
+          })
+        )
       );
       await notifications.drain();
       return response;
@@ -175,23 +371,30 @@ function createMcpServer() {
         trimStartSeconds: z.number().nonnegative().optional(),
         durationSeconds: z.number().positive().optional(),
         audio: z.enum(["preserve", "remove"]).optional(),
-        overwrite: z.boolean().optional()
+        overwrite: z.boolean().optional(),
+        ...contentCheckInputs
       },
+      outputSchema: workflowResultShape,
       annotations: destructiveHint
     },
     async (options, extra) => {
       const notifications = mcpProgress(extra);
       const response = await safely(
-        async () => normalize({
-          input: options.input,
-          output: options.output,
-          ...options.trimStartSeconds === void 0 ? {} : { trimStartSeconds: options.trimStartSeconds },
-          ...options.durationSeconds === void 0 ? {} : { durationSeconds: options.durationSeconds },
-          ...options.audio === void 0 ? {} : { audio: options.audio },
-          ...options.overwrite === void 0 ? {} : { overwrite: options.overwrite },
-          signal: extra.signal,
-          onProgress: notifications.notify
-        })
+        async () => workflowResponse(
+          await normalize({
+            input: options.input,
+            output: options.output,
+            ...options.trimStartSeconds === void 0 ? {} : { trimStartSeconds: options.trimStartSeconds },
+            ...options.durationSeconds === void 0 ? {} : { durationSeconds: options.durationSeconds },
+            ...options.audio === void 0 ? {} : { audio: options.audio },
+            ...options.overwrite === void 0 ? {} : { overwrite: options.overwrite },
+            ...contentCheckOptions(options.contentChecks),
+            ...options.warnOnly === void 0 ? {} : { warnOnly: options.warnOnly },
+            ...limits,
+            signal: extra.signal,
+            onProgress: notifications.notify
+          })
+        )
       );
       await notifications.drain();
       return response;
@@ -207,23 +410,30 @@ function createMcpServer() {
         format: z.enum(["m4a", "mp3", "wav"]).optional(),
         trimStartSeconds: z.number().nonnegative().optional(),
         durationSeconds: z.number().positive().optional(),
-        overwrite: z.boolean().optional()
+        overwrite: z.boolean().optional(),
+        ...contentCheckInputs
       },
+      outputSchema: workflowResultShape,
       annotations: destructiveHint
     },
     async (options, extra) => {
       const notifications = mcpProgress(extra);
       const response = await safely(
-        async () => extractAudio({
-          input: options.input,
-          output: options.output,
-          ...options.format === void 0 ? {} : { format: options.format },
-          ...options.trimStartSeconds === void 0 ? {} : { trimStartSeconds: options.trimStartSeconds },
-          ...options.durationSeconds === void 0 ? {} : { durationSeconds: options.durationSeconds },
-          ...options.overwrite === void 0 ? {} : { overwrite: options.overwrite },
-          signal: extra.signal,
-          onProgress: notifications.notify
-        })
+        async () => workflowResponse(
+          await extractAudio({
+            input: options.input,
+            output: options.output,
+            ...options.format === void 0 ? {} : { format: options.format },
+            ...options.trimStartSeconds === void 0 ? {} : { trimStartSeconds: options.trimStartSeconds },
+            ...options.durationSeconds === void 0 ? {} : { durationSeconds: options.durationSeconds },
+            ...options.overwrite === void 0 ? {} : { overwrite: options.overwrite },
+            ...contentCheckOptions(options.contentChecks),
+            ...options.warnOnly === void 0 ? {} : { warnOnly: options.warnOnly },
+            ...limits,
+            signal: extra.signal,
+            onProgress: notifications.notify
+          })
+        )
       );
       await notifications.drain();
       return response;
@@ -238,22 +448,29 @@ function createMcpServer() {
         output: z.string().min(1),
         atSeconds: z.number().nonnegative().optional(),
         format: z.enum(["jpg", "png"]).optional(),
-        overwrite: z.boolean().optional()
+        overwrite: z.boolean().optional(),
+        ...contentCheckInputs
       },
+      outputSchema: workflowResultShape,
       annotations: destructiveHint
     },
     async (options, extra) => {
       const notifications = mcpProgress(extra);
       const response = await safely(
-        async () => extractFrame({
-          input: options.input,
-          output: options.output,
-          ...options.atSeconds === void 0 ? {} : { atSeconds: options.atSeconds },
-          ...options.format === void 0 ? {} : { format: options.format },
-          ...options.overwrite === void 0 ? {} : { overwrite: options.overwrite },
-          signal: extra.signal,
-          onProgress: notifications.notify
-        })
+        async () => workflowResponse(
+          await extractFrame({
+            input: options.input,
+            output: options.output,
+            ...options.atSeconds === void 0 ? {} : { atSeconds: options.atSeconds },
+            ...options.format === void 0 ? {} : { format: options.format },
+            ...options.overwrite === void 0 ? {} : { overwrite: options.overwrite },
+            ...contentCheckOptions(options.contentChecks),
+            ...options.warnOnly === void 0 ? {} : { warnOnly: options.warnOnly },
+            ...limits,
+            signal: extra.signal,
+            onProgress: notifications.notify
+          })
+        )
       );
       await notifications.drain();
       return response;
@@ -262,26 +479,31 @@ function createMcpServer() {
   server.registerTool(
     "concatenate_media",
     {
-      description: "Concatenate multiple media sources into a single verified output. All inputs must have compatible stream layouts. Reports MCP progress when requested. Overwrite is destructive.",
+      description: "Concatenate two or more media sources into a single verified output. Pass every clip in `inputs`, in playback order. All inputs must have compatible stream layouts. Reports MCP progress when requested. Overwrite is destructive.",
       inputSchema: {
-        input: z.string().min(1),
-        inputs: z.array(z.string().min(1)).min(1),
+        inputs: z.array(z.string().min(1)).min(2).describe("Every clip to join, in playback order. The first entry leads the output."),
         output: z.string().min(1),
-        overwrite: z.boolean().optional()
+        overwrite: z.boolean().optional(),
+        ...contentCheckInputs
       },
+      outputSchema: workflowResultShape,
       annotations: destructiveHint
     },
     async (options, extra) => {
       const notifications = mcpProgress(extra);
       const response = await safely(
-        async () => concatenate({
-          input: options.input,
-          inputs: options.inputs,
-          output: options.output,
-          ...options.overwrite === void 0 ? {} : { overwrite: options.overwrite },
-          signal: extra.signal,
-          onProgress: notifications.notify
-        })
+        async () => workflowResponse(
+          await concatenate({
+            inputs: options.inputs,
+            output: options.output,
+            ...options.overwrite === void 0 ? {} : { overwrite: options.overwrite },
+            ...contentCheckOptions(options.contentChecks),
+            ...options.warnOnly === void 0 ? {} : { warnOnly: options.warnOnly },
+            ...limits,
+            signal: extra.signal,
+            onProgress: notifications.notify
+          })
+        )
       );
       await notifications.drain();
       return response;
@@ -290,33 +512,104 @@ function createMcpServer() {
   server.registerTool(
     "execute_media_plan",
     {
-      description: "Execute a serialized semantic Media IR plan. Accepts a plan object or JSON string. Overwrite is destructive.",
+      description: `Execute a serialized semantic Media IR plan conforming to the canonical Media IR v${mediaPlanSchemaVersion} JSON Schema at ${mediaPlanSchemaId}. Accepts a plan object or JSON string. Fails with VERIFICATION_FAILED when the output does not satisfy the plan. Overwrite is destructive. Set writeReceipt to emit a durable receipt, or resume to skip execution when a passing receipt already matches the plan and source.`,
       inputSchema: {
         plan: z.union([z.string().min(1), planRefSchema]),
         output: z.string().min(1),
-        overwrite: z.boolean().optional()
+        overwrite: z.boolean().optional(),
+        writeReceipt: z.boolean().optional(),
+        resume: z.boolean().optional(),
+        ...contentCheckInputs
+      },
+      outputSchema: {
+        output: z.string(),
+        resumed: z.boolean().optional(),
+        receipt: receiptSchema.optional(),
+        verification: verificationSchema
       },
       annotations: destructiveHint
     },
-    async ({ plan: input, output, overwrite }, extra) => {
+    async ({ plan: input, output, overwrite, writeReceipt, resume, contentChecks, warnOnly }, extra) => {
       const notifications = mcpProgress(extra);
       const response = await safely(async () => {
         const plan = normalizePlan(input);
         const execution = await executePlan(plan, {
+          ...limits,
           output,
           ...overwrite === void 0 ? {} : { overwrite },
+          ...writeReceipt === void 0 ? {} : { writeReceipt },
+          ...resume === void 0 ? {} : { resume },
+          ...contentCheckOptions(contentChecks),
+          ...warnOnly === void 0 ? {} : { warnOnly },
+          signal: extra.signal,
+          onProgress: notifications.notify
+        });
+        const verification = execution.verification ?? execution.receipt?.verification ?? verifyMedia(await inspectMedia(execution.output, probeOptions), plan.expectations);
+        if (!verification.passed) {
+          throw new MediaError({
+            code: "VERIFICATION_FAILED",
+            message: "The plan executed, but the output did not satisfy its expectations.",
+            context: { output: execution.output, verification },
+            suggestedActions: ["Inspect the failed checks, adjust the plan, and retry."]
+          });
+        }
+        return {
+          output: execution.output,
+          ...execution.resumed === void 0 ? {} : { resumed: execution.resumed },
+          ...execution.receipt === void 0 ? {} : { receipt: execution.receipt },
+          verification
+        };
+      });
+      await notifications.drain();
+      return response;
+    }
+  );
+  server.registerTool(
+    "resume_execution",
+    {
+      description: "Continue from a saved execution receipt: skip the work when the recorded output still satisfies the same plan against an unchanged source, and re-execute the plan when it does not. Overwrite is destructive.",
+      inputSchema: {
+        receipt: z.string().min(1),
+        output: z.string().min(1).optional(),
+        overwrite: z.boolean().optional()
+      },
+      outputSchema: {
+        output: z.string(),
+        resumed: z.boolean(),
+        receipt: receiptSchema.optional()
+      },
+      annotations: destructiveHint
+    },
+    async ({ receipt, output, overwrite }, extra) => {
+      const notifications = mcpProgress(extra);
+      const response = await safely(async () => {
+        const execution = await resumeFromReceipt(parseReceipt(receipt), {
+          ...limits,
+          ...output === void 0 ? {} : { output },
+          ...overwrite === void 0 ? {} : { overwrite },
           signal: extra.signal,
           onProgress: notifications.notify
         });
         return {
           output: execution.output,
-          verification: verifyMedia(await inspectMedia(execution.output), plan.expectations)
+          resumed: execution.resumed === true,
+          ...execution.receipt === void 0 ? {} : { receipt: execution.receipt }
         };
       });
       await notifications.drain();
       return response;
     }
   );
+  server.registerTool(
+    "inspect_receipt",
+    {
+      description: "Validate and inspect a saved execution receipt (durable record of plan, source fingerprint, output, and verification).",
+      inputSchema: { receipt: z.string().min(1) },
+      outputSchema: { receipt: receiptSchema },
+      annotations: readOnlyHint
+    },
+    async ({ receipt }) => safely(async () => ({ receipt: parseReceipt(receipt) }))
+  );
   server.registerTool(
     "verify_media",
     {
@@ -325,17 +618,27 @@ function createMcpServer() {
         output: z.string().min(1),
         plan: z.union([z.string().min(1), planRefSchema])
       },
+      outputSchema: verificationShape,
       annotations: readOnlyHint
     },
     async ({ output, plan: input }) => safely(async () => {
       const plan = normalizePlan(input);
-      return verifyMedia(await inspectMedia(output), plan.expectations);
+      return verifyMedia(await inspectMedia(output, probeOptions), plan.expectations);
     })
   );
   return server;
 }
+function workflowResponse(result2) {
+  const rest = { ...result2 };
+  delete rest.serializedPlan;
+  return rest;
+}
 function result(value) {
-  return { content: [{ type: "text", text: JSON.stringify(value) }] };
+  const content = [{ type: "text", text: JSON.stringify(value) }];
+  return isPlainObject(value) ? { content, structuredContent: value } : { content };
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 async function safely(operation) {
   try {
@@ -345,8 +648,20 @@ async function safely(operation) {
       code: "UNEXPECTED_ERROR",
       message: error instanceof Error ? error.message : String(error)
     };
-    return { ...result(structured), isError: true };
+    return {
+      content: [{ type: "text", text: JSON.stringify(structured) }],
+      isError: true
+    };
+  }
+}
+async function inspectConcatenationSources(plan, source, probeOptions) {
+  const concatenate2 = plan.steps.find((step) => step.operation === "concatenate");
+  if (concatenate2?.operation !== "concatenate") return void 0;
+  const sources = [];
+  for (const [index, input] of concatenate2.inputs.entries()) {
+    sources.push(index === 0 ? source : await inspectMedia(input, probeOptions));
   }
+  return sources;
 }
 function normalizePlan(input) {
   return typeof input === "string" ? parsePlan(input) : validatePlan(input);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hadialmarzooq/agent-media-mcp",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "MCP server for semantic, replayable, and verified media transformations.",
   "keywords": [
     "media",
@@ -39,8 +39,8 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.30.0",
     "zod": "^4.5.4",
-    "@hadialmarzooq/agent-media-core": "0.2.0",
-    "@hadialmarzooq/agent-media-ffmpeg": "0.2.0"
+    "@hadialmarzooq/agent-media-core": "0.3.0",
+    "@hadialmarzooq/agent-media-ffmpeg": "0.4.0"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm --dts",