@akira-tl/forgerelay 1.1.0 → 1.1.1

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

@@ -3,6 +3,7 @@ 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";
@@ -85,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.");
         }
@@ -101,7 +103,7 @@ export function registerFilesystemTools(options) {
             const mediaBudget = createMediaBudget(config.mediaMaxBytes);
             const execution = await executeBulkRead({
                 paths: requestedPaths,
-                signal: extra.signal,
+                signal: requestContext.signal,
                 run: (requestedPath) => readFileTool({ path: requestedPath, offset, limit }, {
                     cwd: process.cwd(),
                     root: config.allowedRoots[0] ?? process.cwd(),
@@ -181,20 +183,20 @@ 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,
@@ -247,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, {
@@ -267,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",
@@ -317,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, {
@@ -349,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",
@@ -389,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", {
@@ -428,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) },
@@ -456,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),
@@ -483,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

@@ -20,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),
@@ -96,7 +96,7 @@ export function createOperationRuntime(options) {
         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),
@@ -157,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),
@@ -219,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),
@@ -278,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),
@@ -362,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,
@@ -488,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),

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";
@@ -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();

package/dist/mcp/server/workspace/runtime/workspace-open.js

@@ -1,5 +1,5 @@
 import { registerAppTool } from "@modelcontextprotocol/ext-apps/server";
-import { openAiConversationScopeId } from "../../../request-meta.js";
+import { mcpHandlerRequestContext } from "../../../request-context.js";
 import { formatPathForPrompt } from "../../../../workspaces/resources/skills.js";
 import { compositeCapabilityContext } from "../../core/capability-support.js";
 import { compositeWorkspaceLogContext, logToolCall, textBlock } from "../../core/tool-support.js";
@@ -7,14 +7,13 @@ import { openWorkspaceToolDefinition } from "./workspace-open-schema.js";
 import { presentLocalWorkspaceOpen, workspaceTaskUsageInstruction, } from "./workspace-open-presentation.js";
 export function registerOpenWorkspaceTool(options) {
     const { server } = options;
-    registerAppTool(server, "open_workspace", openWorkspaceToolDefinition, (args, extra) => handleOpenWorkspace(options, args, extra));
+    registerAppTool(server, "open_workspace", openWorkspaceToolDefinition, (args, extra) => handleOpenWorkspace(options, args, mcpHandlerRequestContext(extra)));
 }
-async function handleOpenWorkspace(options, input, extra) {
-    const { config, workspaces, remoteWorkspaces, compositeWorkspaces, workspaceTasks, processSessions, capabilityRegistry, compositeTaskGuides, loadCompositeMemberContext, rememberWorkspacePanelState, hostScopeIdFor, presentation, } = options;
+async function handleOpenWorkspace(options, input, requestContext) {
+    const { config, workspaces, remoteWorkspaces, compositeWorkspaces, workspaceTasks, processSessions, capabilityRegistry, compositeTaskGuides, loadCompositeMemberContext, rememberWorkspacePanelState, hostScopeIdFor, contextDeliveryScopeIdFor, presentation, } = options;
     const { action = "open", memberAction, member, kind, name, memberName, path, relay, workspaceId, mode, baseRef, newWorktree, newWorkspace, context, root, status, state, staleOnly, offset, limit, } = input;
-    const { _meta, sessionId } = extra;
     const startedAt = performance.now();
-    const conversationScopeId = openAiConversationScopeId(_meta);
+    const conversationScopeId = contextDeliveryScopeIdFor(requestContext);
     const protectedWorkspaceIds = processSessions.activeWorkspaceIds();
     const inspectTaskSummary = (targetWorkspaceId) => {
         try {
@@ -469,7 +468,7 @@ async function handleOpenWorkspace(options, input, extra) {
             newWorktree !== undefined || newWorkspace !== undefined) {
             throw new Error("Resuming a relayed Workspace by workspaceId accepts context only.");
         }
-        const resumed = await remoteWorkspaces.resumeWorkspace(workspaceId, context ?? "auto", hostScopeIdFor(_meta, sessionId));
+        const resumed = await remoteWorkspaces.resumeWorkspace(workspaceId, context ?? "auto", hostScopeIdFor(requestContext));
         rememberWorkspacePanelState(workspaceId, resumed);
         return resumed;
     }
@@ -483,7 +482,7 @@ async function handleOpenWorkspace(options, input, extra) {
             newWorktree,
             newWorkspace,
             context,
-        }, hostScopeIdFor(_meta, sessionId));
+        }, hostScopeIdFor(requestContext));
         const relayedSkills = Array.isArray(opened.skills)
             ? opened.skills
             : [];
@@ -568,5 +567,10 @@ async function handleOpenWorkspace(options, input, extra) {
         rememberWorkspacePanelState(opened.workspaceId, response);
         return response;
     }
-    return presentLocalWorkspaceOpen(presentation, input, { conversationScopeId, protectedWorkspaceIds, startedAt, sessionId });
+    return presentLocalWorkspaceOpen(presentation, input, {
+        conversationScopeId,
+        protectedWorkspaceIds,
+        startedAt,
+        sessionId: requestContext.transportSessionId,
+    });
 }

package/dist/mcp/server/workspace/runtime/workspace-tools.js

@@ -1,5 +1,6 @@
 import { registerAppTool } from "@modelcontextprotocol/ext-apps/server";
 import * as z from "zod/v4";
+import { mcpHandlerRequestContext } from "../../../request-context.js";
 import { CapabilityError } from "../../core/capability-registry.js";
 import { attachHookReports, runToolWithHooks } from "../../../hooks/hooks.js";
 import { toolNames } from "../../../server-instructions.js";
@@ -36,8 +37,9 @@ export function registerWorkspaceAuxiliaryTools(options) {
             openWorldHint: false,
         },
     }, async ({ workspaceId, path }, extra) => {
+        const requestContext = mcpHandlerRequestContext(extra);
         if (remoteWorkspaces.has(workspaceId)) {
-            return remoteWorkspaces.workspaceInstruction(workspaceId, path, hostScopeIdFor(extra._meta, extra.sessionId));
+            return remoteWorkspaces.workspaceInstruction(workspaceId, path, hostScopeIdFor(requestContext));
         }
         if (compositeWorkspaces.has(workspaceId)) {
             throw new Error("Composite Workspace instructions belong to a selected member; open that member context before viewing its instruction files.");
@@ -91,6 +93,7 @@ export function registerWorkspaceAuxiliaryTools(options) {
             openWorldHint: true,
         },
     }, async ({ workspaceId, member, name, action, arguments: capabilityArguments, file }, extra) => {
+        const requestContext = mcpHandlerRequestContext(extra);
         if (name === "workspace.tasks" && compositeWorkspaces.has(workspaceId)) {
             if (member !== undefined) {
                 throw new Error(`workspace.tasks belongs to Composite Workspace ${workspaceId} itself and does not accept member.`);
@@ -105,9 +108,9 @@ export function registerWorkspaceAuxiliaryTools(options) {
                 if (action === "run") {
                     const execution = await capabilityRegistry.run(name, capabilityArguments ?? {}, context, {
                         nativeFile: file,
-                        signal: extra.signal,
-                        requestMeta: extra._meta,
-                        sessionId: extra.sessionId,
+                        signal: requestContext.signal,
+                        requestMeta: requestContext.requestMeta,
+                        sessionId: requestContext.transportSessionId,
                     });
                     const result = {
                         content: [textBlock(`Capability ${name} completed.\n${JSON.stringify(execution.value, null, 2)}`)],
@@ -146,7 +149,7 @@ export function registerWorkspaceAuxiliaryTools(options) {
                 return result;
             }
             catch (error) {
-                if (extra.signal.aborted)
+                if (requestContext.signal.aborted)
                     throw error;
                 const capabilityError = error instanceof CapabilityError
                     ? error
@@ -171,16 +174,16 @@ export function registerWorkspaceAuxiliaryTools(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)) {
             const response = await remoteWorkspaces.capability(executionWorkspaceId, {
                 name,
                 action,
                 ...(capabilityArguments !== undefined ? { arguments: capabilityArguments } : {}),
                 ...(file !== undefined ? { file } : {}),
-            }, hostScopeIdFor(extra._meta, extra.sessionId));
+            }, hostScopeIdFor(requestContext));
             return action === "run" && name !== "workspace.tasks"
-                ? presentSemanticWorkResult(response, target, hostScopeIdFor(extra._meta, extra.sessionId))
+                ? presentSemanticWorkResult(response, target, hostScopeIdFor(requestContext))
                 : presentExecutionResult(response, target);
         }
         if (action === "run" && name === "batch.execute") {
@@ -189,9 +192,9 @@ export function registerWorkspaceAuxiliaryTools(options) {
             try {
                 const execution = await capabilityRegistry.run(name, capabilityArguments ?? {}, capabilityContextFor(workspace), {
                     nativeFile: file,
-                    signal: extra.signal,
-                    requestMeta: extra._meta,
-                    sessionId: extra.sessionId,
+                    signal: requestContext.signal,
+                    requestMeta: requestContext.requestMeta,
+                    sessionId: requestContext.transportSessionId,
                 });
                 const result = {
                     content: [textBlock(`Capability ${name} completed.\n${JSON.stringify(execution.value, null, 2)}`)],
@@ -199,16 +202,16 @@ export function registerWorkspaceAuxiliaryTools(options) {
                 };
                 logToolCall(config, {
                     tool: toolNames.capability,
-                    ...workspaceLogContext(workspace, extra.sessionId),
+                    ...workspaceLogContext(workspace, requestContext.transportSessionId),
                     capability: name,
                     action,
                     success: true,
                     durationMs: Math.round(performance.now() - startedAt),
                 });
-                return presentSemanticWorkResult(result, target, hostScopeIdFor(extra._meta, extra.sessionId));
+                return presentSemanticWorkResult(result, target, hostScopeIdFor(requestContext));
             }
             catch (error) {
-                if (extra.signal.aborted)
+                if (requestContext.signal.aborted)
                     throw error;
                 const capabilityError = error instanceof CapabilityError
                     ? error
@@ -224,7 +227,7 @@ export function registerWorkspaceAuxiliaryTools(options) {
                 };
                 logFailedToolResponse(config, {
                     tool: toolNames.capability,
-                    ...workspaceLogContext(workspace, extra.sessionId),
+                    ...workspaceLogContext(workspace, requestContext.transportSessionId),
                     capability: name,
                     action,
                 }, result.content, startedAt);
@@ -235,11 +238,11 @@ export function registerWorkspaceAuxiliaryTools(options) {
             const response = await coreOperations.capabilityRun({ workspaceId: executionWorkspaceId, name, arguments: capabilityArguments, file }, executionContext);
             return name === "workspace.tasks"
                 ? presentExecutionResult(response, target)
-                : presentSemanticWorkResult(response, target, hostScopeIdFor(extra._meta, extra.sessionId));
+                : presentSemanticWorkResult(response, target, hostScopeIdFor(requestContext));
         }
         const workspace = workspaces.getWorkspace(executionWorkspaceId);
-        return runActivityToolWithHooks(activityLifecycle, hooks, workspace, hostScopeIdFor(extra._meta, extra.sessionId), activityRequestFor({ workspaceId: executionWorkspaceId, name, action, arguments: capabilityArguments, file }, executionContext), {
-            signal: extra.signal,
+        return runActivityToolWithHooks(activityLifecycle, hooks, workspace, hostScopeIdFor(requestContext), activityRequestFor({ workspaceId: executionWorkspaceId, name, action, arguments: capabilityArguments, file }, executionContext), {
+            signal: requestContext.signal,
             tool: toolNames.capability,
             invocation: workspaceHookInvocation(workspace),
             payload: { name, action },
@@ -332,6 +335,7 @@ export function registerWorkspaceAuxiliaryTools(options) {
         _meta: {},
         annotations: WRITE_TOOL_ANNOTATIONS,
     }, async ({ workspaceId, action = "close", commitMessage }, extra) => {
+        const requestContext = mcpHandlerRequestContext(extra);
         if (compositeWorkspaces.has(workspaceId)) {
             const startedAt = performance.now();
             if (commitMessage !== undefined) {
@@ -392,7 +396,7 @@ export function registerWorkspaceAuxiliaryTools(options) {
             };
         }
         if (remoteWorkspaces.has(workspaceId)) {
-            const response = await remoteWorkspaces.closeWorkspace(workspaceId, { action, ...(commitMessage !== undefined ? { commitMessage } : {}) }, hostScopeIdFor(extra._meta, extra.sessionId));
+            const response = await remoteWorkspaces.closeWorkspace(workspaceId, { action, ...(commitMessage !== undefined ? { commitMessage } : {}) }, hostScopeIdFor(requestContext));
             if (action === "delete") {
                 activityQueries.deleteWorkspaceHistory(config.stateDir, workspaceId);
             }
@@ -409,7 +413,7 @@ export function registerWorkspaceAuxiliaryTools(options) {
                 throw new Error(`Workspace ${session.id} still owns a running process. Poll, interrupt, or wait for it before deleting this Workspace.`);
             }
             const response = await runToolWithHooks(hooks, {
-                signal: extra.signal,
+                signal: requestContext.signal,
                 tool: toolNames.closeWorkspace,
                 invocation: {
                     workspaceId: session.id,
@@ -428,7 +432,7 @@ export function registerWorkspaceAuxiliaryTools(options) {
                     const result = `Deleted ForgeRelay Workspace ${session.id}. Physical project files were not removed.`;
                     logToolCall(config, {
                         tool: toolNames.closeWorkspace,
-                        ...workspaceLogContext(session, extra.sessionId),
+                        ...workspaceLogContext(session, requestContext.transportSessionId),
                         action: "delete",
                         path: session.root,
                         success: true,
@@ -463,7 +467,7 @@ export function registerWorkspaceAuxiliaryTools(options) {
             }
             const hookRoot = session.sourceRoot ?? session.root;
             const response = await runToolWithHooks(hooks, {
-                signal: extra.signal,
+                signal: requestContext.signal,
                 tool: toolNames.closeWorkspace,
                 invocation: {
                     workspaceId: session.id,
@@ -509,7 +513,7 @@ export function registerWorkspaceAuxiliaryTools(options) {
         }
         const workspace = workspaces.getWorkspace(session.id);
         const response = await runToolWithHooks(hooks, {
-            signal: extra.signal,
+            signal: requestContext.signal,
             tool: toolNames.closeWorkspace,
             invocation: workspaceHookInvocation(workspace),
             payload: { workspaceId: workspace.id, action, commitMessage, mode: workspace.mode },
@@ -558,7 +562,7 @@ export function registerWorkspaceAuxiliaryTools(options) {
                     ].join("\n");
                     logToolCall(config, {
                         tool: toolNames.closeWorkspace,
-                        ...workspaceLogContext(workspace, extra.sessionId),
+                        ...workspaceLogContext(workspace, requestContext.transportSessionId),
                         action,
                         path: closed.sourceRoot,
                         success: true,
@@ -610,7 +614,7 @@ export function registerWorkspaceAuxiliaryTools(options) {
                 const result = `Closed checkout-backed Workspace ${checkoutWorkspaceId}; its ForgeRelay identity was preserved for later reopen. Physical project files were not removed.`;
                 logToolCall(config, {
                     tool: toolNames.closeWorkspace,
-                    ...workspaceLogContext(workspace, extra.sessionId),
+                    ...workspaceLogContext(workspace, requestContext.transportSessionId),
                     action: "close",
                     path: workspace.root,
                     success: true,