@alan-ai-hq/agent-manager 0.1.91 → 0.1.92

package/dist/index.cjs

@@ -3404,7 +3404,7 @@ var require_websocket = __commonJS({
     var http2 = require("http");
     var net = require("net");
     var tls = require("tls");
-    var { randomBytes: randomBytes13, createHash: createHash17 } = require("crypto");
+    var { randomBytes: randomBytes13, createHash: createHash18 } = require("crypto");
     var { Duplex, Readable: Readable2 } = require("stream");
     var { URL: URL2 } = require("url");
     var PerMessageDeflate = require_permessage_deflate();
@@ -4061,7 +4061,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash17("sha1").update(key + GUID).digest("base64");
+        const digest = createHash18("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -4428,7 +4428,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter = require("events");
     var http2 = require("http");
     var { Duplex } = require("stream");
-    var { createHash: createHash17 } = require("crypto");
+    var { createHash: createHash18 } = require("crypto");
     var extension = require_extension();
     var PerMessageDeflate = require_permessage_deflate();
     var subprotocol = require_subprotocol();
@@ -4725,7 +4725,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest = createHash17("sha1").update(key + GUID).digest("base64");
+        const digest = createHash18("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -15451,7 +15451,7 @@ function describeError(error61) {
 }
 
 // src/version.ts
-var AGENT_VERSION = "0.1.91";
+var AGENT_VERSION = "0.1.92";
 
 // src/daemon-worktree.ts
 var import_node_child_process3 = require("child_process");
@@ -36003,6 +36003,42 @@ var import_fs = require("fs");
 var import_os = require("os");
 var import_path = require("path");
 
+// ../shared/dist/utils/workflow-tools-filter.js
+var WORKFLOW_ALWAYS_ALLOWED_BUILTIN_TOOLS = [
+  "search_context",
+  "create_test_report",
+  "create_plan",
+  "create_document_artifact",
+  "upsert_prototype_version",
+  "list_artifacts",
+  "get_artifact",
+  "list_prototypes",
+  "get_prototype"
+];
+function createWorkflowToolsFilter(workflowTools) {
+  const hasFilter = !!workflowTools && workflowTools.length > 0;
+  if (!hasFilter) {
+    return {
+      hasFilter: false,
+      isMcpServerAllowed: () => true,
+      resolveAllowedBuiltinTools: () => null
+    };
+  }
+  const tools = workflowTools;
+  const mcpServerIds = new Set(tools.filter((t) => t.type === "mcp").map((t) => t.id));
+  const builtinToolIds = tools.filter((t) => t.type === "builtin" || t.type === "integration").map((t) => t.id);
+  return {
+    hasFilter: true,
+    isMcpServerAllowed: (serverName) => mcpServerIds.has(serverName),
+    resolveAllowedBuiltinTools: () => {
+      const merged = new Set(builtinToolIds);
+      for (const id of WORKFLOW_ALWAYS_ALLOWED_BUILTIN_TOOLS)
+        merged.add(id);
+      return [...merged];
+    }
+  };
+}
+
 // ../shared/dist/agent/agent-definitions.js
 var COORDINATOR_PROMPT = `## You are the Orchestrator
 
@@ -36490,6 +36526,34 @@ function buildAlanMcpServers(registration) {
     }
   };
 }
+var ALAN_RUN_REFERENCE_ENV = "ALAN_RUN_REFERENCE";
+var MCP_CONFIG_KEY = /^[A-Za-z0-9_-]+$/;
+function isExternalMcpServerName(name) {
+  return MCP_CONFIG_KEY.test(name) && name !== "alan";
+}
+function isMcpConfigKey(name) {
+  return MCP_CONFIG_KEY.test(name);
+}
+var CURSOR_RUN_REFERENCE_HEADER_VALUE = `\${env:${ALAN_RUN_REFERENCE_ENV}}`;
+function toCursorMcpServers(src) {
+  const out = {};
+  for (const [name, raw] of Object.entries(src)) {
+    if (!raw || typeof raw !== "object")
+      continue;
+    const s = raw;
+    const isHttp = typeof s.type === "string" && s.type === "http" || typeof s.url === "string";
+    if (!isHttp) {
+      out[name] = s;
+      continue;
+    }
+    const headers = Object.fromEntries(Object.entries(s.headers ?? {}).filter(([key]) => key.toLowerCase() !== "x-alan-run-reference"));
+    out[name] = {
+      ...s,
+      headers: { ...headers, "x-alan-run-reference": CURSOR_RUN_REFERENCE_HEADER_VALUE }
+    };
+  }
+  return out;
+}
 function toFactoryMcpServers(src) {
   const out = {};
   for (const [name, raw] of Object.entries(src)) {
@@ -36634,7 +36698,10 @@ function renderAlanMcpConfigFiles(mcpServers, home) {
       mergeJsonKey: "mcpServers"
     },
     { path: `${home}/.codex/config.toml`, content: toCodexMcpToml(mcpServers) },
-    { path: `${home}/.cursor/mcp.json`, content: JSON.stringify({ mcpServers }) },
+    {
+      path: `${home}/.cursor/mcp.json`,
+      content: JSON.stringify({ mcpServers: toCursorMcpServers(mcpServers) })
+    },
     {
       path: `${home}/.factory/mcp.json`,
       content: JSON.stringify({ mcpServers: toFactoryMcpServers(mcpServers) })
@@ -38302,6 +38369,7 @@ var import_os4 = require("os");
 var import_path5 = require("path");
 var import_url = require("url");
 var import_crypto4 = require("crypto");
+var import_crypto5 = require("crypto");
 var import_fs6 = require("fs");
 var import_os5 = require("os");
 var import_path6 = require("path");
@@ -38319,14 +38387,16 @@ var import_path9 = require("path");
 var import_fs10 = require("fs");
 var import_os9 = require("os");
 var import_path10 = require("path");
-var import_crypto5 = require("crypto");
+var import_crypto6 = require("crypto");
 var import_readline2 = require("readline");
 var import_url2 = require("url");
-var import_crypto6 = require("crypto");
+var import_crypto7 = require("crypto");
 var import_fs11 = require("fs");
 var import_path11 = require("path");
-var ALAN_RUN_REFERENCE_ENV = "ALAN_RUN_REFERENCE";
 var ALAN_MCP_URL_ENV = "ALAN_MCP_URL";
+function deliversRunReferenceViaEnv(backendKind) {
+  return backendKind === "cursor_agent_cli";
+}
 var ALAN_AGENT_ENTRY_ENV = "ALAN_AGENT_ENTRY";
 var ALAN_NODE_EXECUTABLE_ENV = "ALAN_NODE_EXECUTABLE";
 function usesProcessLocalManagedMcp(backendKind) {
@@ -41091,6 +41161,65 @@ function createAntigravityCliBackend(command = "agy", defaultArgs = []) {
     }
   };
 }
+function isWorkflowRun(config2) {
+  return Boolean(config2.workflowId || config2.workflowExecutionId);
+}
+function selectExternalMcpServers(config2) {
+  const selected = {};
+  const filter = isWorkflowRun(config2) ? createWorkflowToolsFilter(config2.workflowTools) : null;
+  if (filter && !filter.hasFilter) return selected;
+  for (const [name, server] of Object.entries(config2.externalMcpServers ?? {})) {
+    if (!isExternalMcpServerName(name)) continue;
+    if (filter && !filter.isMcpServerAllowed(name)) continue;
+    selected[name] = server;
+  }
+  return selected;
+}
+function headerEnvName(server, header) {
+  const fingerprint = (0, import_crypto5.createHash)("sha256").update(`${server}\0${header}`).digest("hex").slice(0, 12).toUpperCase();
+  return `ALAN_MCP_HEADER_${fingerprint}`;
+}
+function planExternalMcpDelivery(config2, processEnv) {
+  const verbatim = selectExternalMcpServers(config2);
+  const servers = {};
+  const env = {};
+  for (const [name, server] of Object.entries(verbatim)) {
+    if (server.url && server.type !== "stdio") {
+      const headerEnv = {};
+      for (const [header, value2] of Object.entries(server.headers ?? {})) {
+        if (!isMcpConfigKey(header)) continue;
+        const variable = headerEnvName(name, header);
+        env[variable] = value2;
+        headerEnv[header] = variable;
+      }
+      servers[name] = {
+        type: server.type === "sse" ? "sse" : "http",
+        url: server.url,
+        ...Object.keys(headerEnv).length ? { headerEnv } : {}
+      };
+    } else if (server.command) {
+      const envKeys = [];
+      for (const [key, value2] of Object.entries(server.env ?? {})) {
+        if (!isMcpConfigKey(key)) continue;
+        if (key in processEnv || key in env && env[key] !== value2) {
+          console.warn(
+            `[external-mcp] Not forwarding env ${key} for MCP server ${name}: it is already set for this run`
+          );
+          continue;
+        }
+        env[key] = value2;
+        envKeys.push(key);
+      }
+      servers[name] = {
+        type: "stdio",
+        command: server.command,
+        ...server.args?.length ? { args: server.args } : {},
+        ...envKeys.length ? { envKeys } : {}
+      };
+    }
+  }
+  return { servers, env, verbatim };
+}
 function resolveClaudeHome(env, variant = "claude") {
   if (variant === "supatest") {
     return (0, import_path6.join)((0, import_os5.homedir)(), ".supatest", "claude-internal");
@@ -41525,22 +41654,40 @@ function buildClaudeModelArg(baseModel, selectedContextWindow) {
   if (selectedContextWindow === "1m") return `${baseModel}[1m]`;
   return baseModel;
 }
-function buildClaudeManagedMcpArgs(registration, env) {
-  const entry = env[ALAN_AGENT_ENTRY_ENV]?.trim() || process.argv[1];
-  const node2 = env[ALAN_NODE_EXECUTABLE_ENV]?.trim() || process.execPath;
-  if (!entry) throw new Error("Cannot resolve the Alan MCP proxy entrypoint");
+function buildClaudeManagedMcpArgs(registration, options = {}) {
+  const mcpServers = {};
+  for (const [name, server] of Object.entries(options.externalServers ?? {})) {
+    if (server.type === "stdio") {
+      mcpServers[name] = {
+        type: "stdio",
+        command: server.command,
+        ...server.args?.length ? { args: server.args } : {},
+        ...server.envKeys?.length ? { env: Object.fromEntries(server.envKeys.map((key) => [key, `\${${key}}`])) } : {}
+      };
+    } else {
+      mcpServers[name] = {
+        type: server.type,
+        url: server.url,
+        ...server.headerEnv ? {
+          headers: Object.fromEntries(
+            Object.entries(server.headerEnv).map(([header, variable]) => [
+              header,
+              `\${${variable}}`
+            ])
+          )
+        } : {}
+      };
+    }
+  }
+  mcpServers.alan = {
+    type: "http",
+    url: registration.url,
+    headers: { "x-alan-run-reference": `\${${ALAN_RUN_REFERENCE_ENV}}` }
+  };
   return [
-    "--strict-mcp-config",
+    ...options.strict ? ["--strict-mcp-config"] : [],
     "--mcp-config",
-    JSON.stringify({
-      mcpServers: {
-        [managedMcpServerName(registration)]: {
-          type: "stdio",
-          command: node2,
-          args: [entry, "mcp-proxy"]
-        }
-      }
-    })
+    JSON.stringify({ mcpServers })
   ];
 }
 function createClaudeCliBackend(command = "claude", defaultArgs = []) {
@@ -41549,11 +41696,12 @@ function createClaudeCliBackend(command = "claude", defaultArgs = []) {
     supportTier: "structured",
     async run(context) {
       const managedRegistration = context.config.alanMcp;
+      const externalMcp = managedRegistration ? planExternalMcpDelivery(context.config, context.env) : void 0;
       const runContext = managedRegistration ? {
         ...context,
         env: {
           ...context.env,
-          [ALAN_MCP_URL_ENV]: managedRegistration.url,
+          ...externalMcp?.env,
           [ALAN_RUN_REFERENCE_ENV]: requireManagedRunReference(managedRegistration)
         }
       } : context;
@@ -41567,7 +41715,12 @@ function createClaudeCliBackend(command = "claude", defaultArgs = []) {
         getClaudePermissionMode(context.config)
       ];
       if (managedRegistration) {
-        args.push(...buildClaudeManagedMcpArgs(managedRegistration, runContext.env));
+        args.push(
+          ...buildClaudeManagedMcpArgs(managedRegistration, {
+            strict: isWorkflowRun(context.config),
+            externalServers: externalMcp?.servers
+          })
+        );
       }
       const disallowedTools = getClaudeDisallowedTools(context.config);
       if (disallowedTools.length > 0) {
@@ -42796,31 +42949,59 @@ function buildCodexEffortArgs(selectedEffortLevel, options) {
 }
 var CODEX_STARTUP_TIMEOUT_MS = 3e5;
 var ALAN_MCP_STARTUP_TIMEOUT_SEC = 30;
-function buildCodexManagedMcpArgs(registration) {
-  const serverName = managedMcpServerName(registration);
+function buildCodexManagedMcpArgs(registration, options = {}) {
   return [
-    "--ignore-user-config",
+    // Workflow runs keep the exclusive config: their tool set is a policy,
+    // not the user's own server list.
+    ...options.strict ? ["--ignore-user-config"] : [],
     "-c",
-    `mcp_servers.${serverName}.url=${JSON.stringify(registration.url)}`,
+    `mcp_servers.alan.url=${JSON.stringify(registration.url)}`,
     "-c",
-    `mcp_servers.${serverName}.env_http_headers.x-alan-run-reference=${JSON.stringify(ALAN_RUN_REFERENCE_ENV)}`,
+    `mcp_servers.alan.env_http_headers.x-alan-run-reference=${JSON.stringify(ALAN_RUN_REFERENCE_ENV)}`,
     "-c",
-    `mcp_servers.${serverName}.required=true`,
+    "mcp_servers.alan.required=true",
     "-c",
-    `mcp_servers.${serverName}.startup_timeout_sec=${ALAN_MCP_STARTUP_TIMEOUT_SEC}`
+    `mcp_servers.alan.startup_timeout_sec=${ALAN_MCP_STARTUP_TIMEOUT_SEC}`
   ];
 }
+function buildCodexExternalMcpArgs(servers) {
+  const args = [];
+  for (const [name, server] of Object.entries(servers ?? {})) {
+    const key = `mcp_servers.${name}`;
+    if (server.type === "stdio") {
+      args.push("-c", `${key}.command=${JSON.stringify(server.command)}`);
+      if (server.args?.length) args.push("-c", `${key}.args=${JSON.stringify(server.args)}`);
+      if (server.envKeys?.length) {
+        args.push("-c", `${key}.env_vars=${JSON.stringify(server.envKeys)}`);
+      }
+    } else {
+      if (server.type === "sse") continue;
+      args.push("-c", `${key}.url=${JSON.stringify(server.url)}`);
+      for (const [header, variable] of Object.entries(server.headerEnv ?? {})) {
+        args.push("-c", `${key}.env_http_headers.${header}=${JSON.stringify(variable)}`);
+      }
+    }
+  }
+  return args;
+}
 function createCodexRuntimeBackend(command = "codex", defaultArgs = []) {
   return {
     kind: "codex_app_server",
     supportTier: "structured",
     async run(context) {
       const managedRegistration = context.config.alanMcp;
-      const managedMcpArgs = managedRegistration ? buildCodexManagedMcpArgs(managedRegistration) : [];
+      const externalMcp = managedRegistration ? planExternalMcpDelivery(context.config, context.env) : void 0;
+      const managedMcpArgs = managedRegistration ? [
+        ...buildCodexManagedMcpArgs(managedRegistration, {
+          strict: isWorkflowRun(context.config)
+        }),
+        ...buildCodexExternalMcpArgs(externalMcp?.servers)
+      ] : [];
       const runContext = managedRegistration ? {
         ...context,
         env: {
           ...context.env,
+          ...externalMcp?.env,
           [ALAN_RUN_REFERENCE_ENV]: requireManagedRunReference(managedRegistration)
         }
       } : context;
@@ -43781,6 +43962,13 @@ function createCursorAgentCliBackend(command = "cursor-agent", defaultArgs = [])
         context.cwd
       );
       const approveMcps = context.config.alanMcp ? await cliSupportsFlag(command, "--approve-mcps", context.env) : false;
+      const runContext = context.config.alanMcp ? {
+        ...context,
+        env: {
+          ...context.env,
+          [ALAN_RUN_REFERENCE_ENV]: requireManagedRunReference(context.config.alanMcp)
+        }
+      } : context;
       try {
         return await createGenericCliBackend({
           kind: "cursor_agent_cli",
@@ -43858,7 +44046,7 @@ function createCursorAgentCliBackend(command = "cursor-agent", defaultArgs = [])
             return appendImagePathReferences(prompt, imageFiles);
           },
           parseStructuredLine: parseCursorStructuredLine
-        }).run(context);
+        }).run(runContext);
       } finally {
         cleanup();
       }
@@ -44914,6 +45102,28 @@ function resolveKimiCliModelArg(model) {
   if (trimmed.startsWith("claude-")) return void 0;
   return trimmed;
 }
+function buildKimiMcpConfig(registration, externalServers = {}) {
+  const mcpServers = {};
+  for (const [name, server] of Object.entries(externalServers)) {
+    if (server.url && server.type !== "stdio") {
+      mcpServers[name] = {
+        url: server.url,
+        ...server.headers ? { headers: server.headers } : {}
+      };
+    } else if (server.command) {
+      mcpServers[name] = {
+        command: server.command,
+        ...server.args?.length ? { args: server.args } : {},
+        ...server.env ? { env: server.env } : {}
+      };
+    }
+  }
+  mcpServers[managedMcpServerName(registration)] = {
+    url: registration.url,
+    headers: { "x-alan-run-reference": requireManagedRunReference(registration) }
+  };
+  return { mcpServers };
+}
 function createKimiCliBackend(command = "kimi-cli", defaultArgs = []) {
   return {
     kind: "kimi_cli",
@@ -44925,14 +45135,9 @@ function createKimiCliBackend(command = "kimi-cli", defaultArgs = []) {
       if (registration && mcpConfigPath) {
         (0, import_fs9.writeFileSync)(
           mcpConfigPath,
-          JSON.stringify({
-            mcpServers: {
-              [managedMcpServerName(registration)]: {
-                url: registration.url,
-                headers: { "x-alan-run-reference": requireManagedRunReference(registration) }
-              }
-            }
-          }),
+          JSON.stringify(
+            buildKimiMcpConfig(registration, selectExternalMcpServers(context.config))
+          ),
           { mode: 384 }
         );
       }
@@ -45459,7 +45664,7 @@ function leaseKeyFor(context) {
   if (!conversationId) return null;
   const runReference = context.config.alanMcp?.headers?.["x-alan-run-reference"];
   if (!runReference) return `conv:${conversationId}`;
-  const fingerprint = (0, import_crypto5.createHash)("sha256").update(runReference).digest("hex").slice(0, 16);
+  const fingerprint = (0, import_crypto6.createHash)("sha256").update(runReference).digest("hex").slice(0, 16);
   return `conv:${conversationId}|mcp:${fingerprint}`;
 }
 function isLeaseUsable(lease) {
@@ -46484,8 +46689,10 @@ var BaseMachineAgent = class _BaseMachineAgent {
    */
   async beginMcpConfigCriticalSection(backend, context) {
     const runHeaders = context.config.alanMcp?.headers;
-    if (!runHeaders || usesProcessLocalManagedMcp(backend.kind)) return () => {
-    };
+    if (!runHeaders || usesProcessLocalManagedMcp(backend.kind) || deliversRunReferenceViaEnv(backend.kind)) {
+      return () => {
+      };
+    }
     const releaseGate = await acquireMcpConfigWriteGate();
     try {
       const writtenClis = await syncAlanMcpSessionHeaders({
@@ -46498,7 +46705,11 @@ var BaseMachineAgent = class _BaseMachineAgent {
         void this.presenter.onLog(`Synced Alan MCP session headers to ${writtenClis.join(", ")}`);
       }
     } catch (error61) {
-      console.warn("[base-machine-agent] Failed to sync MCP session headers", error61);
+      releaseGate();
+      throw new Error(
+        `Alan could not write this run's MCP credential for ${backend.kind}, so the provider was not started: ${error61 instanceof Error ? error61.message : String(error61)}`,
+        { cause: error61 }
+      );
     }
     return releaseGate;
   }
@@ -46993,7 +47204,7 @@ function extractGeneratedImagesFromToolResult(toolId, content, cwd, toolName, op
     const { width, height } = readImageDimensions2(buffer, mimeType);
     images.push({
       type: "generated_image",
-      id: (0, import_crypto6.randomUUID)(),
+      id: (0, import_crypto7.randomUUID)(),
       filename: (0, import_path11.basename)(path2),
       mimeType,
       size: buffer.length,
@@ -47001,7 +47212,7 @@ function extractGeneratedImagesFromToolResult(toolId, content, cwd, toolName, op
       height,
       data: buffer.toString("base64"),
       sourcePath: path2,
-      sourceHash: (0, import_crypto6.createHash)("sha256").update(buffer).digest("hex"),
+      sourceHash: (0, import_crypto7.createHash)("sha256").update(buffer).digest("hex"),
       toolId,
       ts: Date.now()
     });
@@ -47033,7 +47244,7 @@ function extractSessionMediaFromToolResult(toolId, content, cwd, toolName, optio
     media.push({
       type: "session_media",
       kind,
-      id: (0, import_crypto6.randomUUID)(),
+      id: (0, import_crypto7.randomUUID)(),
       filename: (0, import_path11.basename)(path2),
       mimeType,
       size: buffer.length,
@@ -47041,7 +47252,7 @@ function extractSessionMediaFromToolResult(toolId, content, cwd, toolName, optio
       height: dimensions?.height,
       data: buffer.toString("base64"),
       sourcePath: path2,
-      sourceHash: (0, import_crypto6.createHash)("sha256").update(buffer).digest("hex"),
+      sourceHash: (0, import_crypto7.createHash)("sha256").update(buffer).digest("hex"),
       toolId,
       ts: Date.now()
     });
@@ -56805,7 +57016,12 @@ async function ensureAlanMcpRegistered(backendKind, registration, home = (0, imp
         releaseLock();
       }
     }
-    const fileOk = paths.length > 0 && paths.every((p) => registrationsMatch(readAlanMcpRegistration(p), registration));
+    const fileOk = files.length > 0 && files.every(
+      (file2) => registrationsMatch(
+        readAlanMcpRegistration(file2.path),
+        parseAlanMcpRegistration(file2.path, file2.content) ?? registration
+      )
+    );
     if (!fileOk) {
       const issue2 = {
         code: "mcp_config_repair_required",
@@ -56979,7 +57195,8 @@ function hasUsableRegistrationCredential(headers) {
   const normalized = new Map(
     Object.entries(headers).map(([name, value2]) => [name.toLowerCase(), value2.trim()])
   );
-  return Boolean(normalized.get("x-alan-run-reference") || normalized.get("authorization"));
+  const reference = normalized.get("x-alan-run-reference") ?? "";
+  return Boolean(reference && !reference.startsWith("${") || normalized.get("authorization"));
 }
 function readAlanMcpRegistration(path2) {
   return parseAlanMcpRegistration(path2, (0, import_node_fs16.readFileSync)(path2, "utf8"));
@@ -75271,6 +75488,7 @@ async function handleAgentExecute(ctx, payload) {
     prMeta: payload.prMeta,
     conversationId: payload.conversationId,
     alanMcp: payload.alanMcp,
+    externalMcpServers: payload.externalMcpServers,
     taskId: payload.taskId ?? payload.taskMeta?.id,
     teamId: payload.teamId,
     currentUser: payload.currentUser,
@@ -96809,6 +97027,7 @@ var WSClient = class {
           providerSessionId: data.providerSessionId,
           resumeFallbackContext: data.resumeFallbackContext,
           backendKind: data.backendKind,
+          providerApiKey: data.providerApiKey,
           agentId: data.agentId,
           agentPrompt: data.agentPrompt,
           selectedModel: data.selectedModel,
@@ -96826,7 +97045,10 @@ var WSClient = class {
           cloudEnvironmentId: data.cloudEnvironmentId,
           conversationId: data.conversationId,
           teamId: data.teamId,
-          currentUser: data.currentUser
+          currentUser: data.currentUser,
+          terminalContextRefs: data.terminalContextRefs,
+          terminalSnapshots: data.terminalSnapshots,
+          externalMcpServers: data.externalMcpServers
         };
         const acceptDelivery = () => {
           if (data.messageId) this.rememberAcceptedMessageId(data.messageId);
@@ -96850,6 +97072,9 @@ var WSClient = class {
     this.socket.on("stop", () => {
       callbacks.onStop();
     });
+    this.socket.on("agent.abort", (data) => {
+      callbacks.onAbort?.({ runId: data?.runId, reason: data?.reason });
+    });
     this.socket.on("tool_response", (data) => {
       if (data?.toolId && typeof data.response === "string") {
         callbacks.onToolResponse?.(data.toolId, data.response);
@@ -96907,6 +97132,7 @@ async function runSandbox(config2) {
   let currentTaskMeta;
   let currentPrMeta;
   let currentWorkflowTools;
+  let currentExternalMcpServers;
   let currentMaxIterations = config2.maxIterations ?? 50;
   let currentTaskId = config2.taskId;
   let currentConversationId = config2.sessionId;
@@ -97001,6 +97227,14 @@ async function runSandbox(config2) {
         lifecycle.info("sandbox_agent_stop_received");
         stopActiveAgent();
       },
+      onAbort: ({ runId, reason }) => {
+        if (runId && currentRunId && runId !== currentRunId) {
+          lifecycle.info("sandbox_agent_abort_ignored_stale_run", { runId, currentRunId });
+          return;
+        }
+        lifecycle.info("sandbox_agent_abort_received", { runId, reason });
+        stopActiveAgent(reason === "watchdog_timeout" ? "watchdog_timeout" : "user");
+      },
       onToolResponse: (toolId, response) => {
         if (currentAgent) {
           const sent = currentAgent.sendToolResponse(toolId, response);
@@ -97197,6 +97431,7 @@ async function runSandbox(config2) {
           resumeFallbackContext,
           taskMeta: currentTaskMeta,
           prMeta: currentPrMeta,
+          externalMcpServers: currentExternalMcpServers,
           taskId: currentTaskId,
           conversationId: currentConversationId,
           alanMcp: currentAlanMcp,
@@ -97314,6 +97549,7 @@ async function runSandbox(config2) {
       activeMode = nextPayload.mode;
     }
     currentAlanMcp = nextPayload.alanMcp;
+    currentExternalMcpServers = nextPayload.externalMcpServers;
     if (nextPayload.taskMeta !== void 0) {
       currentTaskMeta = nextPayload.taskMeta;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alan-ai-hq/agent-manager",
-  "version": "0.1.91",
+  "version": "0.1.92",
   "type": "module",
   "description": "Alan agent runtime — cloud sandbox and local daemon (alan-agent CLI)",
   "bin": {
@@ -27,8 +27,8 @@
     "tsx": "^4.19.0",
     "typescript": "~5.9.3",
     "@alan-ai/agent-core": "0.1.0",
-    "@alan-ai/sandbox-runtime-spec": "0.1.0",
-    "@alan-ai/shared": "0.1.0"
+    "@alan-ai/shared": "0.1.0",
+    "@alan-ai/sandbox-runtime-spec": "0.1.0"
   },
   "scripts": {
     "build": "tsup",