@akira-tl/forgerelay 1.0.1 → 1.1.1

package/dist/mcp/server/core/capabilities.js

@@ -40,6 +40,12 @@ const CAPABILITY_GUIDE_DEFINITIONS = [
         description: "Read-only semantic code navigation backed by external Language servers.",
         whenToRead: "Read before using code.intelligence or configuring Language servers.",
     },
+    {
+        name: "external-mcp",
+        directory: "host-integration/external-mcp",
+        description: "User-configured external MCP tool discovery and explicit forwarding through capability.",
+        whenToRead: "Read before discovering or calling a configured external MCP server.",
+    },
     {
         name: "workspace-tasks",
         directory: "workspace/workspace-tasks",
@@ -110,6 +116,7 @@ export function buildCapabilityFingerprint(config, version, context = {}) {
     if (config.subagents) {
         capabilities.push("subagent.session");
     }
+    capabilities.push("mcp.external");
     if (config.artifactsEnabled && context.artifactDownloadSupported) {
         capabilities.push("artifact.native-download");
     }

package/dist/mcp/server/core/capability-registry.js

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { MAX_CODE_INTELLIGENCE_RESULT_LIMIT, } from "../../../lsp/code-intelligence-types.js";
 import { batchExecuteInputSchema, } from "../../operations/batch/types.js";
 import { workspaceCheckpointInputSchema, } from "./capabilities/workspace-checkpoint.js";
+import { externalMcpCapabilityDefinitions, } from "./capabilities/external-mcp.js";
 export class CapabilityError extends Error {
     code;
     constructor(code, message) {
@@ -332,6 +333,7 @@ export function createCapabilityRegistry(dependencies) {
                     run: async (input, context, options) => dependencies.workspaceTasks.run(input, context, options),
                 }]
             : []),
+        ...externalMcpCapabilityDefinitions(dependencies.externalMcp),
         ...(dependencies.subagentSession
             ? [{
                     name: "subagent.session",

package/dist/mcp/server/core/tool-support.js

@@ -52,6 +52,35 @@ export function contentText(content) {
         .map((item) => item.text)
         .join("\n");
 }
+export function imageContentMetadata(content) {
+    const image = content.find((item) => item.type === "image");
+    return image
+        ? {
+            type: "image",
+            mimeType: image.mimeType,
+            bytes: Buffer.byteLength(image.data, "base64"),
+        }
+        : undefined;
+}
+export function metadataSafeContent(content) {
+    return content.filter((item) => item.type === "text");
+}
+export function auditToolResultWithoutImageData(result) {
+    if (typeof result !== "object" || result === null)
+        return result;
+    const record = result;
+    const content = Array.isArray(record.content) ? record.content : undefined;
+    if (!content)
+        return result;
+    const media = imageContentMetadata(content);
+    if (!media)
+        return result;
+    return {
+        ...record,
+        content: metadataSafeContent(content),
+        media,
+    };
+}
 export function toolErrorPreview(content) {
     const text = contentText(content).replace(/\s+/g, " ").trim();
     if (!text)

package/dist/mcp/server/operations/runtime/filesystem-tools.js

@@ -3,15 +3,17 @@ import { tmpdir } from "node:os";
 import { isAbsolute } from "node:path";
 import { registerAppTool } from "@modelcontextprotocol/ext-apps/server";
 import * as z from "zod/v4";
+import { mcpHandlerRequestContext } from "../../../request-context.js";
 import { applyPatch } from "../../../filesystem/apply-patch.js";
 import { readFileTool } from "../../../filesystem/filesystem-tools.js";
+import { createMediaBudget } from "../../../operations/media-content.js";
 import { toolNames } from "../../../server-instructions.js";
 import { executeBulkRead } from "../../../operations/bulk-read.js";
 import { formatPathForPrompt } from "../../../../workspaces/resources/skills.js";
 import { activityRelationFor, activityRequestFor, runActivityTool, runActivityToolWithHooks, } from "../../core/activity-support.js";
 import { workspaceHookInvocation } from "../../core/capability-support.js";
 import { resultOutputSchema, workspaceAgentsFileOutputSchema } from "../../core/schemas.js";
-import { contentText, logToolCall, textBlock, toolResultAgentsFiles, toolResultContent, toolResultIsError, toolResultText, workspaceLogContext, } from "../../core/tool-support.js";
+import { contentText, imageContentMetadata, logToolCall, textBlock, toolResultAgentsFiles, toolResultContent, toolResultIsError, toolResultText, workspaceLogContext, } from "../../core/tool-support.js";
 import { appendAutomaticMutationDiagnostics } from "./mutation-diagnostics.js";
 const WRITE_TOOL_ANNOTATIONS = {
     readOnlyHint: false,
@@ -25,6 +27,11 @@ const EDIT_TOOL_ANNOTATIONS = {
     idempotentHint: false,
     openWorldHint: false,
 };
+const MEDIA_METADATA_OUTPUT_SCHEMA = z.object({
+    type: z.literal("image"),
+    mimeType: z.string(),
+    bytes: z.number().int().nonnegative(),
+});
 export function registerFilesystemTools(options) {
     const { server, config, workspaces, compositeWorkspaces, compositeTaskGuides, remoteWorkspaces, coreOperations, nativeBulkMutations, activityLifecycle, codeIntelligence, hooks, toolDescriptions, resolveExecutionTarget, prepareExecutionContext, presentSemanticWorkResult, hostScopeIdFor, } = options;
     registerAppTool(server, toolNames.read, {
@@ -66,10 +73,12 @@ export function registerFilesystemTools(options) {
         },
         outputSchema: resultOutputSchema({
             agentsFiles: z.array(workspaceAgentsFileOutputSchema).optional(),
+            media: MEDIA_METADATA_OUTPUT_SCHEMA.optional(),
             results: z.array(z.object({
                 path: z.string(),
                 status: z.enum(["done", "error"]),
                 result: z.string(),
+                media: MEDIA_METADATA_OUTPUT_SCHEMA.optional(),
             })).optional(),
             files: z.number().int().nonnegative().optional(),
             failed: z.number().int().nonnegative().optional(),
@@ -77,6 +86,7 @@ export function registerFilesystemTools(options) {
         _meta: {},
         annotations: { readOnlyHint: true },
     }, async ({ workspaceId, member, path, paths, offset, limit }, extra) => {
+        const requestContext = mcpHandlerRequestContext(extra);
         if ((path === undefined) === (paths === undefined)) {
             throw new Error("read requires exactly one of path or paths.");
         }
@@ -90,23 +100,32 @@ export function registerFilesystemTools(options) {
                 }
             }
             const startedAt = performance.now();
-            const children = await Promise.all(requestedPaths.map(async (requestedPath) => {
-                const response = await readFileTool({ path: requestedPath, offset, limit }, {
+            const mediaBudget = createMediaBudget(config.mediaMaxBytes);
+            const execution = await executeBulkRead({
+                paths: requestedPaths,
+                signal: requestContext.signal,
+                run: (requestedPath) => readFileTool({ path: requestedPath, offset, limit }, {
                     cwd: process.cwd(),
                     root: config.allowedRoots[0] ?? process.cwd(),
                     readRoots: config.allowedRoots,
-                });
-                return {
-                    path: requestedPath,
-                    status: response.isError ? "error" : "done",
-                    response,
-                    result: contentText(response.content),
-                };
-            }));
-            const failed = children.filter((child) => child.status === "error").length;
-            const content = children.flatMap((child) => requestedPaths.length === 1
-                ? child.response.content
-                : [textBlock(`--- ${child.path} · ${child.status} ---`), ...child.response.content]);
+                    mediaBudget,
+                }),
+                isError: (response) => response.isError === true,
+                resultText: (response) => contentText(response.content),
+            });
+            const children = execution.children;
+            const failed = execution.failed;
+            const content = children.flatMap((child) => {
+                const childContent = child.response
+                    ? child.response.content
+                    : [textBlock(child.result)];
+                return requestedPaths.length === 1
+                    ? childContent
+                    : [textBlock(`--- ${child.path} · ${child.status} ---`), ...childContent];
+            });
+            const singleMedia = requestedPaths.length === 1 && children[0]?.response
+                ? imageContentMetadata(children[0].response.content)
+                : undefined;
             logToolCall(config, {
                 tool: toolNames.read,
                 path: requestedPaths.length === 1 ? requestedPaths[0] : `${requestedPaths.length} unscoped files`,
@@ -118,9 +137,20 @@ export function registerFilesystemTools(options) {
                 ...(failed > 0 ? { isError: true } : {}),
                 structuredContent: {
                     result: contentText(content),
+                    ...(singleMedia ? { media: singleMedia } : {}),
                     ...(requestedPaths.length > 1
                         ? {
-                            results: children.map(({ path: childPath, status, result }) => ({ path: childPath, status, result })),
+                            results: children.map(({ path: childPath, status, result, response }) => {
+                                const media = response
+                                    ? imageContentMetadata(response.content)
+                                    : undefined;
+                                return {
+                                    path: childPath,
+                                    status,
+                                    result,
+                                    ...(media ? { media } : {}),
+                                };
+                            }),
                             files: children.length,
                             failed,
                         }
@@ -153,23 +183,25 @@ export function registerFilesystemTools(options) {
         }
         const target = resolveExecutionTarget(workspaceId, member);
         const executionWorkspaceId = target.executionWorkspaceId;
-        const executionContext = await prepareExecutionContext(target, extra._meta, extra.signal, extra.sessionId);
+        const executionContext = await prepareExecutionContext(target, requestContext);
         if (remoteWorkspaces.has(executionWorkspaceId)) {
-            return presentSemanticWorkResult(await remoteWorkspaces.read(executionWorkspaceId, { path, paths, offset, limit }, hostScopeIdFor(extra._meta, extra.sessionId)), target, hostScopeIdFor(extra._meta, extra.sessionId));
+            return presentSemanticWorkResult(await remoteWorkspaces.read(executionWorkspaceId, { path, paths, offset, limit }, hostScopeIdFor(requestContext)), target, hostScopeIdFor(requestContext));
         }
         if (path !== undefined) {
-            return presentSemanticWorkResult(await coreOperations.read({ workspaceId: executionWorkspaceId, path, offset, limit }, executionContext), target, hostScopeIdFor(extra._meta, extra.sessionId));
+            return presentSemanticWorkResult(await coreOperations.read({ workspaceId: executionWorkspaceId, path, offset, limit }, executionContext), target, hostScopeIdFor(requestContext));
         }
         const workspace = workspaces.getWorkspace(executionWorkspaceId);
         let response;
-        await runActivityTool(activityLifecycle, workspace, hostScopeIdFor(extra._meta, extra.sessionId), toolNames.read, activityRequestFor({ workspaceId: executionWorkspaceId, paths, offset, limit }, executionContext), async (parentContext) => {
+        await runActivityTool(activityLifecycle, workspace, hostScopeIdFor(requestContext), toolNames.read, activityRequestFor({ workspaceId: executionWorkspaceId, paths, offset, limit }, executionContext), async (parentContext) => {
+            const mediaBudget = createMediaBudget(config.mediaMaxBytes);
             const execution = await executeBulkRead({
                 paths: paths,
-                signal: extra.signal,
+                signal: requestContext.signal,
                 run: (childPath) => coreOperations.read({ workspaceId: executionWorkspaceId, path: childPath, offset, limit }, {
                     ...executionContext,
                     parentActivityId: parentContext.activityId,
                     turnId: parentContext.turnId,
+                    mediaBudget,
                 }),
                 isError: toolResultIsError,
                 resultText: toolResultText,
@@ -191,11 +223,17 @@ export function registerFilesystemTools(options) {
                 content,
                 structuredContent: {
                     result: contentText(content),
-                    results: execution.children.map(({ path: childPath, status, result }) => ({
-                        path: childPath,
-                        status,
-                        result,
-                    })),
+                    results: execution.children.map(({ path: childPath, status, result, response }) => {
+                        const media = response
+                            ? imageContentMetadata(toolResultContent(response))
+                            : undefined;
+                        return {
+                            path: childPath,
+                            status,
+                            result,
+                            ...(media ? { media } : {}),
+                        };
+                    }),
                     files: execution.children.length,
                     failed: execution.failed,
                     ...(agentsFiles.length > 0 ? { agentsFiles } : {}),
@@ -211,7 +249,7 @@ export function registerFilesystemTools(options) {
             : { type: "succeeded" }, activityRelationFor(executionContext));
         if (!response)
             throw new Error("Bulk Read completed without a response.");
-        return presentSemanticWorkResult(response, target, hostScopeIdFor(extra._meta, extra.sessionId));
+        return presentSemanticWorkResult(response, target, hostScopeIdFor(requestContext));
     });
     if (config.toolMode !== "codex") {
         registerAppTool(server, toolNames.write, {
@@ -231,13 +269,14 @@ export function registerFilesystemTools(options) {
             _meta: {},
             annotations: WRITE_TOOL_ANNOTATIONS,
         }, async ({ workspaceId, member, ...input }, extra) => {
+            const requestContext = mcpHandlerRequestContext(extra);
             const target = resolveExecutionTarget(workspaceId, member);
             const executionWorkspaceId = target.executionWorkspaceId;
-            const executionContext = await prepareExecutionContext(target, extra._meta, extra.signal, extra.sessionId);
+            const executionContext = await prepareExecutionContext(target, requestContext);
             if (remoteWorkspaces.has(executionWorkspaceId)) {
-                return presentSemanticWorkResult(await remoteWorkspaces.write(executionWorkspaceId, input, hostScopeIdFor(extra._meta, extra.sessionId)), target, hostScopeIdFor(extra._meta, extra.sessionId));
+                return presentSemanticWorkResult(await remoteWorkspaces.write(executionWorkspaceId, input, hostScopeIdFor(requestContext)), target, hostScopeIdFor(requestContext));
             }
-            return presentSemanticWorkResult(await coreOperations.write({ workspaceId: executionWorkspaceId, ...input }, executionContext), target, hostScopeIdFor(extra._meta, extra.sessionId));
+            return presentSemanticWorkResult(await coreOperations.write({ workspaceId: executionWorkspaceId, ...input }, executionContext), target, hostScopeIdFor(requestContext));
         });
         registerAppTool(server, toolNames.edit, {
             title: "Edit file",
@@ -281,19 +320,20 @@ export function registerFilesystemTools(options) {
             _meta: {},
             annotations: EDIT_TOOL_ANNOTATIONS,
         }, async ({ workspaceId, member, path, paths, edits }, extra) => {
+            const requestContext = mcpHandlerRequestContext(extra);
             if ((path === undefined) === (paths === undefined)) {
                 throw new Error("edit requires exactly one of path or paths.");
             }
             const target = resolveExecutionTarget(workspaceId, member);
             const executionWorkspaceId = target.executionWorkspaceId;
-            const executionContext = await prepareExecutionContext(target, extra._meta, extra.signal, extra.sessionId);
+            const executionContext = await prepareExecutionContext(target, requestContext);
             if (remoteWorkspaces.has(executionWorkspaceId)) {
-                return presentSemanticWorkResult(await remoteWorkspaces.edit(executionWorkspaceId, { path, paths, edits }, hostScopeIdFor(extra._meta, extra.sessionId)), target, hostScopeIdFor(extra._meta, extra.sessionId));
+                return presentSemanticWorkResult(await remoteWorkspaces.edit(executionWorkspaceId, { path, paths, edits }, hostScopeIdFor(requestContext)), target, hostScopeIdFor(requestContext));
             }
             if (path !== undefined) {
-                return presentSemanticWorkResult(await coreOperations.edit({ workspaceId: executionWorkspaceId, path, edits }, executionContext), target, hostScopeIdFor(extra._meta, extra.sessionId));
+                return presentSemanticWorkResult(await coreOperations.edit({ workspaceId: executionWorkspaceId, path, edits }, executionContext), target, hostScopeIdFor(requestContext));
             }
-            return presentSemanticWorkResult(await nativeBulkMutations.edit({ workspaceId: executionWorkspaceId, paths: paths, edits }, executionContext), target, hostScopeIdFor(extra._meta, extra.sessionId));
+            return presentSemanticWorkResult(await nativeBulkMutations.edit({ workspaceId: executionWorkspaceId, paths: paths, edits }, executionContext), target, hostScopeIdFor(requestContext));
         });
     }
     registerAppTool(server, toolNames.rename, {
@@ -313,13 +353,14 @@ export function registerFilesystemTools(options) {
         _meta: {},
         annotations: EDIT_TOOL_ANNOTATIONS,
     }, async ({ workspaceId, member, path, newPath }, extra) => {
+        const requestContext = mcpHandlerRequestContext(extra);
         const target = resolveExecutionTarget(workspaceId, member);
         const executionWorkspaceId = target.executionWorkspaceId;
-        const executionContext = await prepareExecutionContext(target, extra._meta, extra.signal, extra.sessionId);
+        const executionContext = await prepareExecutionContext(target, requestContext);
         if (remoteWorkspaces.has(executionWorkspaceId)) {
-            return presentSemanticWorkResult(await remoteWorkspaces.rename(executionWorkspaceId, { path, newPath }, hostScopeIdFor(extra._meta, extra.sessionId)), target, hostScopeIdFor(extra._meta, extra.sessionId));
+            return presentSemanticWorkResult(await remoteWorkspaces.rename(executionWorkspaceId, { path, newPath }, hostScopeIdFor(requestContext)), target, hostScopeIdFor(requestContext));
         }
-        return presentSemanticWorkResult(await coreOperations.rename({ workspaceId: executionWorkspaceId, path, newPath }, executionContext), target, hostScopeIdFor(extra._meta, extra.sessionId));
+        return presentSemanticWorkResult(await coreOperations.rename({ workspaceId: executionWorkspaceId, path, newPath }, executionContext), target, hostScopeIdFor(requestContext));
     });
     registerAppTool(server, toolNames.delete, {
         title: "Delete path",
@@ -353,19 +394,20 @@ export function registerFilesystemTools(options) {
         _meta: {},
         annotations: EDIT_TOOL_ANNOTATIONS,
     }, async ({ workspaceId, member, path, paths, recursive }, extra) => {
+        const requestContext = mcpHandlerRequestContext(extra);
         if ((path === undefined) === (paths === undefined)) {
             throw new Error("delete requires exactly one of path or paths.");
         }
         const target = resolveExecutionTarget(workspaceId, member);
         const executionWorkspaceId = target.executionWorkspaceId;
-        const executionContext = await prepareExecutionContext(target, extra._meta, extra.signal, extra.sessionId);
+        const executionContext = await prepareExecutionContext(target, requestContext);
         if (remoteWorkspaces.has(executionWorkspaceId)) {
-            return presentSemanticWorkResult(await remoteWorkspaces.delete(executionWorkspaceId, { path, paths, recursive }, hostScopeIdFor(extra._meta, extra.sessionId)), target, hostScopeIdFor(extra._meta, extra.sessionId));
+            return presentSemanticWorkResult(await remoteWorkspaces.delete(executionWorkspaceId, { path, paths, recursive }, hostScopeIdFor(requestContext)), target, hostScopeIdFor(requestContext));
         }
         if (path !== undefined) {
-            return presentSemanticWorkResult(await coreOperations.delete({ workspaceId: executionWorkspaceId, path, recursive }, executionContext), target, hostScopeIdFor(extra._meta, extra.sessionId));
+            return presentSemanticWorkResult(await coreOperations.delete({ workspaceId: executionWorkspaceId, path, recursive }, executionContext), target, hostScopeIdFor(requestContext));
         }
-        return presentSemanticWorkResult(await nativeBulkMutations.delete({ workspaceId: executionWorkspaceId, paths: paths, recursive }, executionContext), target, hostScopeIdFor(extra._meta, extra.sessionId));
+        return presentSemanticWorkResult(await nativeBulkMutations.delete({ workspaceId: executionWorkspaceId, paths: paths, recursive }, executionContext), target, hostScopeIdFor(requestContext));
     });
     if (config.toolMode === "codex") {
         registerAppTool(server, "apply_patch", {
@@ -392,15 +434,16 @@ export function registerFilesystemTools(options) {
             _meta: {},
             annotations: EDIT_TOOL_ANNOTATIONS,
         }, async ({ workspaceId, member, patch }, extra) => {
+            const requestContext = mcpHandlerRequestContext(extra);
             const target = resolveExecutionTarget(workspaceId, member);
             const executionWorkspaceId = target.executionWorkspaceId;
-            const executionContext = await prepareExecutionContext(target, extra._meta, extra.signal, extra.sessionId);
+            const executionContext = await prepareExecutionContext(target, requestContext);
             if (remoteWorkspaces.has(executionWorkspaceId)) {
-                return presentSemanticWorkResult(await remoteWorkspaces.applyPatch(executionWorkspaceId, { patch }, hostScopeIdFor(extra._meta, extra.sessionId)), target, hostScopeIdFor(extra._meta, extra.sessionId));
+                return presentSemanticWorkResult(await remoteWorkspaces.applyPatch(executionWorkspaceId, { patch }, hostScopeIdFor(requestContext)), target, hostScopeIdFor(requestContext));
             }
             const workspace = workspaces.getWorkspace(executionWorkspaceId);
-            return runActivityToolWithHooks(activityLifecycle, hooks, workspace, hostScopeIdFor(extra._meta, extra.sessionId), activityRequestFor({ workspaceId: executionWorkspaceId, patch }, executionContext), {
-                signal: extra.signal,
+            return runActivityToolWithHooks(activityLifecycle, hooks, workspace, hostScopeIdFor(requestContext), activityRequestFor({ workspaceId: executionWorkspaceId, patch }, executionContext), {
+                signal: requestContext.signal,
                 tool: "apply_patch",
                 invocation: workspaceHookInvocation(workspace),
                 payload: { patchBytes: Buffer.byteLength(patch) },
@@ -420,7 +463,7 @@ export function registerFilesystemTools(options) {
                         .map((file) => file.path);
                     logToolCall(config, {
                         tool: "apply_patch",
-                        ...workspaceLogContext(workspace, extra.sessionId),
+                        ...workspaceLogContext(workspace, requestContext.transportSessionId),
                         path: displayPath,
                         success: true,
                         durationMs: Math.round(performance.now() - startedAt),
@@ -447,9 +490,9 @@ export function registerFilesystemTools(options) {
                             removals: applied.removals,
                             files: applied.files,
                         },
-                    }, codeIntelligence, workspace.root, diagnosticPaths, extra.signal);
+                    }, codeIntelligence, workspace.root, diagnosticPaths, requestContext.signal);
                 },
-            }, activityRelationFor(executionContext)).then((result) => presentSemanticWorkResult(result, target, hostScopeIdFor(extra._meta, extra.sessionId)));
+            }, activityRelationFor(executionContext)).then((result) => presentSemanticWorkResult(result, target, hostScopeIdFor(requestContext)));
         });
     }
 }

package/dist/mcp/server/operations/runtime/operation-runtime.js

@@ -1,6 +1,7 @@
 import { CapabilityError } from "../../core/capability-registry.js";
 import { deletePath, renamePath } from "../../../filesystem/file-mutations.js";
 import { editFileTool, readFileTool, writeFileTool } from "../../../filesystem/filesystem-tools.js";
+import { createMediaBudget } from "../../../operations/media-content.js";
 import { runToolWithHooks } from "../../../hooks/hooks.js";
 import { toolNames } from "../../../server-instructions.js";
 import { BatchExecutor } from "../../../operations/batch/executor.js";
@@ -11,7 +12,7 @@ import { markReturnedOutput, processActivityOutcome, processToolResponse, } from
 import { capabilityActivityAuditRequest, capabilityActivityAuditResult } from "../../../../subagents/sessions/mcp/audit.js";
 import { activityRelationFor, activityRequestFor, runActivityTool, runActivityToolWithHooks, standardActivityOutcome, } from "../../core/activity-support.js";
 import { capabilityContextFor, managedWorktreeRecoveryCapabilityContext, workspaceHookInvocation, } from "../../core/capability-support.js";
-import { assertWorkspaceInstructionsLoadedBeforeSideEffect, contentLineCount, contentText, countDiffStats, formatDiscoveredWorkspaceInstructions, logFailedToolResponse, logToolCall, newFilePatch, textBlock, textSummary, toolResultContent, toolResultIsError, toolResultText, workspaceLogContext, } from "../../core/tool-support.js";
+import { assertWorkspaceInstructionsLoadedBeforeSideEffect, auditToolResultWithoutImageData, contentLineCount, contentText, countDiffStats, formatDiscoveredWorkspaceInstructions, imageContentMetadata, logFailedToolResponse, logToolCall, metadataSafeContent, newFilePatch, textBlock, textSummary, toolResultContent, toolResultIsError, toolResultText, workspaceLogContext, } from "../../core/tool-support.js";
 import { appendAutomaticMutationDiagnostics } from "./mutation-diagnostics.js";
 export function createOperationRuntime(options) {
     const { config, workspaces, activityLifecycle, hooks, processSessions, bashOutputStore, capabilityRegistry, codeIntelligence, hostScopeIdFor, } = options;
@@ -19,7 +20,7 @@ export function createOperationRuntime(options) {
         read: async (input, context) => {
             const { workspaceId, ...readInput } = input;
             const workspace = workspaces.getWorkspace(workspaceId);
-            return runActivityToolWithHooks(activityLifecycle, hooks, workspace, hostScopeIdFor(context.requestMeta, context.sessionId), activityRequestFor(input, context), {
+            return runActivityToolWithHooks(activityLifecycle, hooks, workspace, hostScopeIdFor(context), activityRequestFor(input, context), {
                 signal: context.signal,
                 tool: toolNames.read,
                 invocation: workspaceHookInvocation(workspace),
@@ -33,6 +34,7 @@ export function createOperationRuntime(options) {
                         cwd: workspace.root,
                         root: workspace.root,
                         readRoots: readPath.readRoots,
+                        mediaBudget: context.mediaBudget ?? createMediaBudget(config.mediaMaxBytes),
                     });
                     if (response.isError) {
                         logFailedToolResponse(config, {
@@ -49,10 +51,12 @@ export function createOperationRuntime(options) {
                     const content = discoveredInstructionContent
                         ? [discoveredInstructionContent, ...response.content]
                         : response.content;
+                    const media = imageContentMetadata(response.content);
                     const summary = {
                         ...textSummary(response.content),
                         offset: readInput.offset ?? 1,
                         limited: readInput.limit !== undefined,
+                        ...(media ? { media } : {}),
                     };
                     logToolCall(config, {
                         tool: toolNames.read,
@@ -70,11 +74,12 @@ export function createOperationRuntime(options) {
                                 workspaceId,
                                 path: readInput.path,
                                 summary,
-                                payload: { content: response.content },
+                                payload: { content: metadataSafeContent(response.content) },
                             },
                         },
                         structuredContent: {
                             result: contentText(content),
+                            ...(media ? { media } : {}),
                             ...(discoveredInstructions.length > 0
                                 ? {
                                     agentsFiles: discoveredInstructions.map((file) => ({
@@ -86,12 +91,12 @@ export function createOperationRuntime(options) {
                         },
                     };
                 },
-            }, activityRelationFor(context));
+            }, activityRelationFor(context), auditToolResultWithoutImageData);
         },
         write: async (input, context) => {
             const { workspaceId, ...writeInput } = input;
             const workspace = workspaces.getWorkspace(workspaceId);
-            return runActivityToolWithHooks(activityLifecycle, hooks, workspace, hostScopeIdFor(context.requestMeta, context.sessionId), activityRequestFor(input, context), {
+            return runActivityToolWithHooks(activityLifecycle, hooks, workspace, hostScopeIdFor(context), activityRequestFor(input, context), {
                 signal: context.signal,
                 tool: toolNames.write,
                 invocation: workspaceHookInvocation(workspace),
@@ -152,7 +157,7 @@ export function createOperationRuntime(options) {
         edit: async (input, context) => {
             const { workspaceId, ...editInput } = input;
             const workspace = workspaces.getWorkspace(workspaceId);
-            return runActivityToolWithHooks(activityLifecycle, hooks, workspace, hostScopeIdFor(context.requestMeta, context.sessionId), activityRequestFor(input, context), {
+            return runActivityToolWithHooks(activityLifecycle, hooks, workspace, hostScopeIdFor(context), activityRequestFor(input, context), {
                 signal: context.signal,
                 tool: toolNames.edit,
                 invocation: workspaceHookInvocation(workspace),
@@ -214,7 +219,7 @@ export function createOperationRuntime(options) {
         rename: async (input, context) => {
             const { workspaceId, path, newPath } = input;
             const workspace = workspaces.getWorkspace(workspaceId);
-            return runActivityToolWithHooks(activityLifecycle, hooks, workspace, hostScopeIdFor(context.requestMeta, context.sessionId), activityRequestFor(input, context), {
+            return runActivityToolWithHooks(activityLifecycle, hooks, workspace, hostScopeIdFor(context), activityRequestFor(input, context), {
                 signal: context.signal,
                 tool: toolNames.rename,
                 invocation: workspaceHookInvocation(workspace),
@@ -273,7 +278,7 @@ export function createOperationRuntime(options) {
         delete: async (input, context) => {
             const { workspaceId, path, recursive } = input;
             const workspace = workspaces.getWorkspace(workspaceId);
-            return runActivityToolWithHooks(activityLifecycle, hooks, workspace, hostScopeIdFor(context.requestMeta, context.sessionId), activityRequestFor(input, context), {
+            return runActivityToolWithHooks(activityLifecycle, hooks, workspace, hostScopeIdFor(context), activityRequestFor(input, context), {
                 signal: context.signal,
                 tool: toolNames.delete,
                 invocation: workspaceHookInvocation(workspace),
@@ -357,7 +362,7 @@ export function createOperationRuntime(options) {
                     maxOutputTokens,
                 };
             let undeliveredProcessId;
-            const activityResult = await runActivityTool(activityLifecycle, workspace, hostScopeIdFor(context.requestMeta, context.sessionId), surface, activityRequestFor(activityRequest, context), async (activityContext) => {
+            const activityResult = await runActivityTool(activityLifecycle, workspace, hostScopeIdFor(context), surface, activityRequestFor(activityRequest, context), async (activityContext) => {
                 try {
                     const result = await runToolWithHooks(hooks, {
                         signal: context.signal,
@@ -483,7 +488,7 @@ export function createOperationRuntime(options) {
             }
             const workspace = workspaces.getWorkspace(workspaceId);
             let changedPaths = [];
-            return runActivityTool(activityLifecycle, workspace, hostScopeIdFor(context.requestMeta, context.sessionId), toolNames.capability, activityRequestFor(capabilityActivityAuditRequest(input), context), (activityContext) => runToolWithHooks(hooks, {
+            return runActivityTool(activityLifecycle, workspace, hostScopeIdFor(context), toolNames.capability, activityRequestFor(capabilityActivityAuditRequest(input), context), (activityContext) => runToolWithHooks(hooks, {
                 signal: context.signal,
                 tool: toolNames.capability,
                 invocation: workspaceHookInvocation(workspace),
@@ -503,8 +508,10 @@ export function createOperationRuntime(options) {
                             activityId: activityContext.activityId,
                         });
                         changedPaths = execution.changedPaths ?? [];
+                        const transientContent = execution.content;
                         const result = {
-                            content: [textBlock(`Capability ${name} completed.\n${JSON.stringify(execution.value, null, 2)}`)],
+                            content: transientContent
+                                ?? [textBlock(`Capability ${name} completed.\n${JSON.stringify(execution.value, null, 2)}`)],
                             ...(execution.card
                                 ? {
                                     _meta: {

package/dist/mcp/server/transport/http-server.js

@@ -1,10 +1,7 @@
 import { randomUUID } from "node:crypto";
-import { createMcpExpressApp } from "@modelcontextprotocol/sdk/server/express.js";
-import { getOAuthProtectedResourceMetadataUrl } from "@modelcontextprotocol/sdk/server/auth/router.js";
-import { requireBearerAuth } from "@modelcontextprotocol/sdk/server/auth/middleware/bearerAuth.js";
-import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
-import { checkResourceAllowed, resourceUrlFromServerUrl } from "@modelcontextprotocol/sdk/shared/auth-utils.js";
+import { checkResourceAllowed, createMcpHandler, isInitializeRequest, isLegacyRequest, resourceUrlFromServerUrl, } from "@modelcontextprotocol/server";
+import { createMcpExpressApp, getOAuthProtectedResourceMetadataUrl, requireBearerAuth, } from "@modelcontextprotocol/express";
+import { NodeStreamableHTTPServerTransport, toNodeHandler, toWebRequest, } from "@modelcontextprotocol/node";
 import express from "express";
 import { ActivityAuditStore } from "../../../activity/history/audit-store.js";
 import { BashOutputStore } from "../../../activity/history/bash-output-store.js";
@@ -59,7 +56,7 @@ export function createHttpServer(config, options, createMcpServer) {
     });
     const workspaceStore = createWorkspaceStore(config.stateDir);
     const workspaces = new WorkspaceRegistry(config, workspaceStore);
-    const sharedRemoteWorkspaces = new RemoteWorkspaceRelay(config.configDir, config.stateDir);
+    const sharedRemoteWorkspaces = new RemoteWorkspaceRelay(config.configDir, config.stateDir, config.mediaMaxBytes);
     const sharedCompositeWorkspaces = new CompositeWorkspaceRegistry(config.stateDir);
     const sharedWorkspaceTasks = new WorkspaceTaskStore(config.stateDir);
     const sharedTaskReminders = new WorkspaceTaskReminderTracker(config.taskReminderInterval, sharedWorkspaceTasks);
@@ -79,6 +76,26 @@ export function createHttpServer(config, options, createMcpServer) {
     const subagentProviders = config.subagents
         ? getSubagentProviderAvailabilitySnapshot()
         : [];
+    const buildMcpServer = () => createMcpServer(config, workspaces, reviewCheckpoints, processSessions, subagentProviders, incomingArtifactAdapters, codeIntelligence, activityLifecycle, bashOutputStore, activityQueries, {
+        taskReminders: sharedTaskReminders,
+        remoteWorkspaces: sharedRemoteWorkspaces,
+        compositeWorkspaces: sharedCompositeWorkspaces,
+    });
+    const modernMcp = createMcpHandler(() => buildMcpServer(), {
+        legacy: "reject",
+        onerror: (error) => {
+            logEvent(config.logging, "error", "mcp_modern_handler_error", {
+                error: error.message,
+            });
+        },
+    });
+    const modernNodeHandler = toNodeHandler(modernMcp, {
+        onerror: (error) => {
+            logEvent(config.logging, "error", "mcp_modern_adapter_error", {
+                error: error.message,
+            });
+        },
+    });
     const logTransportCloseResults = (reason, results) => {
         let closedCount = 0;
         for (const result of results) {
@@ -219,15 +236,22 @@ export function createHttpServer(config, options, createMcpServer) {
             sendJsonRpcError(res, 401, -32001, "Unauthorized");
             return;
         }
-        logEvent(config.logging, "debug", "mcp_request", {
-            requestId,
-            httpMethod: req.method,
-            transportSessionIdPresent: Boolean(transportSessionId),
-            transportSessionIdPrefix: transportSessionIdPrefix(transportSessionId),
-            isInitialize: initializeRequest,
-            ...mcpRequestDebugFields(req.body),
-        });
         try {
+            const webRequest = await toWebRequest(req, req.body);
+            const legacyRequest = await isLegacyRequest(webRequest, req.body);
+            logEvent(config.logging, "debug", "mcp_request", {
+                requestId,
+                httpMethod: req.method,
+                protocolEra: legacyRequest ? "legacy" : "modern",
+                transportSessionIdPresent: Boolean(transportSessionId),
+                transportSessionIdPrefix: transportSessionIdPrefix(transportSessionId),
+                isInitialize: initializeRequest,
+                ...mcpRequestDebugFields(req.body),
+            });
+            if (!legacyRequest) {
+                await modernNodeHandler(req, res, req.body);
+                return;
+            }
             let transport;
             if (transportSessionId) {
                 transport = transports.get(transportSessionId);
@@ -237,7 +261,7 @@ export function createHttpServer(config, options, createMcpServer) {
                 }
             }
             else if (initializeRequest) {
-                transport = new StreamableHTTPServerTransport({
+                transport = new NodeStreamableHTTPServerTransport({
                     sessionIdGenerator: () => randomUUID(),
                     onsessioninitialized: (newTransportSessionId) => {
                         if (transport) {
@@ -261,11 +285,7 @@ export function createHttpServer(config, options, createMcpServer) {
                         });
                     }
                 };
-                const server = createMcpServer(config, workspaces, reviewCheckpoints, processSessions, subagentProviders, incomingArtifactAdapters, codeIntelligence, activityLifecycle, bashOutputStore, activityQueries, {
-                    taskReminders: sharedTaskReminders,
-                    remoteWorkspaces: sharedRemoteWorkspaces,
-                    compositeWorkspaces: sharedCompositeWorkspaces,
-                });
+                const server = buildMcpServer();
                 await server.connect(transport);
             }
             else {
@@ -294,6 +314,7 @@ export function createHttpServer(config, options, createMcpServer) {
                 clearInterval(transportCleanupTimer);
                 const results = await transports.closeAll();
                 logTransportCloseResults("server_shutdown", results);
+                await modernMcp.close();
                 await sharedRemoteWorkspaces.shutdown();
                 processSessions.shutdown();
                 await codeIntelligence.shutdown();