@opengeni/runtime 2.5.2 → 2.5.3-canary.0

package/dist/{chunk-GJC7H2FC.js → chunk-SD6MDONS.js}

@@ -23,11 +23,11 @@ import {
   withRunCredentialsClient,
   withRunCredentialsSession,
   wrapCapabilityToolsForTurnCancellation
-} from "./chunk-LGLJ5PVD.js";
+} from "./chunk-VVEGJPDR.js";
 import {
   MemorySession,
   connectMcpServers
-} from "./chunk-CD22I76N.js";
+} from "./chunk-FHGLYLBL.js";
 import {
   SKILL_MAX_FILES,
   SkillFileError,
@@ -108,7 +108,7 @@ import {
   tool,
   withGenerationSpan,
   withResponseSpan
-} from "./chunk-25B3EQRW.js";
+} from "./chunk-UNICCRW5.js";
 
 // src/command-read-refresh.ts
 async function executeCommandReadWithRefresh(input) {
@@ -203,6 +203,168 @@ function commandSnapshot(result) {
   }
 }
 
+// src/mcp-operation-dispatch.ts
+import { AsyncLocalStorage } from "async_hooks";
+var dispatchContext = new AsyncLocalStorage();
+function hasActiveRecoverableMcpOperation() {
+  return dispatchContext.getStore() !== void 0;
+}
+var McpOperationOutcomeUnknownError = class extends Error {
+  constructor(operationId, cause) {
+    super(
+      `MCP operation ${operationId} has an unknown outcome. Read the existing operation result; do not repeat the mutation.`,
+      { cause }
+    );
+    this.operationId = operationId;
+    this.name = "McpOperationOutcomeUnknownError";
+  }
+  code = "mcp_operation_outcome_unknown";
+};
+async function runRecoverableMcpOperation(operation, persistence, execute) {
+  const context = {
+    operation: { ...operation },
+    persistence,
+    captureStarted: false,
+    captured: false,
+    closed: false
+  };
+  return await dispatchContext.run(context, async () => {
+    let result;
+    try {
+      try {
+        result = await execute();
+      } catch (error) {
+        if (!context.captured) throw error;
+        try {
+          await persistence.settleOriginal({
+            operationId: operation.operationId,
+            outcome: "outcome_unknown"
+          });
+        } catch {
+        }
+        throw new McpOperationOutcomeUnknownError(operation.operationId, error);
+      }
+      if (!context.captured) {
+        throw new Error("Recoverable MCP execution did not cross its durable capture boundary");
+      }
+      try {
+        await persistence.settleOriginal({
+          operationId: operation.operationId,
+          outcome: "completed",
+          result
+        });
+      } catch (error) {
+        throw new McpOperationOutcomeUnknownError(operation.operationId, error);
+      }
+      return result;
+    } finally {
+      context.closed = true;
+    }
+  });
+}
+async function captureMcpOperationDispatch(input) {
+  const context = dispatchContext.getStore();
+  if (!context) return;
+  const operation = context.operation;
+  if (input.operationId !== operation.operationId || input.serverId !== operation.serverId || input.toolName !== operation.originalTool || input.destinationDigest !== operation.destinationDigest || !/^[a-f0-9]{64}$/u.test(input.authorityDigest))
+    throw new Error("Recoverable MCP dispatch identity does not match its trusted binding");
+  if (context.closed || context.captureStarted) {
+    throw new Error("MCP operation dispatch is already claimed or closed");
+  }
+  context.captureStarted = true;
+  const result = await context.persistence.capture({
+    ...operation,
+    authorityDigest: input.authorityDigest
+  });
+  if (result !== "created")
+    throw new Error("MCP operation was already dispatched; read its existing result");
+  if (context.closed) throw new Error("MCP operation dispatch closed during capture");
+  context.captured = true;
+}
+
+// src/mcp-operation-observation.ts
+import { AttemptToolResult } from "@opengeni/contracts";
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
+var observationAuthority = new AsyncLocalStorage2();
+async function runMcpOperationObservationWithAuthority(binding, execute) {
+  const scope = { binding: { ...binding }, closed: false };
+  return await observationAuthority.run(scope, async () => {
+    try {
+      return await execute();
+    } finally {
+      scope.closed = true;
+    }
+  });
+}
+function assertMcpOperationObservationAuthority(actual) {
+  const scope = observationAuthority.getStore();
+  if (!scope) return;
+  const expected = scope.binding;
+  if (scope.closed || actual.serverId !== expected.serverId || actual.toolName !== expected.observerTool || actual.destinationDigest !== expected.destinationDigest || actual.authorityDigest !== expected.authorityDigest) {
+    throw new Error("MCP operation observation authority changed before provider use");
+  }
+}
+var fingerprint = external_exports.object({
+  version: external_exports.literal(1),
+  algorithm: external_exports.literal("sha256"),
+  value: external_exports.string().regex(/^[a-f0-9]{64}$/u)
+}).strict();
+var identity = {
+  version: external_exports.literal(1),
+  operationRef: external_exports.string().uuid(),
+  fingerprint
+};
+var receiptSchema = external_exports.discriminatedUnion("status", [
+  external_exports.object({ ...identity, status: external_exports.literal("unknown") }).strict(),
+  external_exports.object({
+    ...identity,
+    status: external_exports.literal("pending"),
+    evidenceRevision: external_exports.string().min(1)
+  }).strict(),
+  external_exports.object({
+    ...identity,
+    status: external_exports.literal("completed"),
+    receiptRevision: external_exports.string().min(1).refine((value) => Buffer.byteLength(value, "utf8") <= 1024, {
+      message: "MCP receipt revision must fit the ledger's 1024-byte identity field"
+    }),
+    result: AttemptToolResult
+  }).strict(),
+  external_exports.object({ ...identity, status: external_exports.literal("conflict") }).strict()
+]);
+var bindingSchema = external_exports.object({
+  operationId: external_exports.string().uuid(),
+  serverId: external_exports.string().min(1),
+  originalTool: external_exports.string().min(1),
+  observerTool: external_exports.string().min(1),
+  argumentDigest: fingerprint.shape.value
+}).strict().refine((value) => value.originalTool !== value.observerTool, {
+  message: "The observer must not be the original mutation tool"
+});
+async function observeMcpOperation(input) {
+  const binding = bindingSchema.parse(input.binding);
+  if (!await input.authorize("before_request")) {
+    throw new Error("MCP operation observation is not authorized");
+  }
+  const response = await input.callObserver(binding.observerTool, {
+    version: 1,
+    operationRef: binding.operationId,
+    originalTool: binding.originalTool,
+    fingerprint: { version: 1, algorithm: "sha256", value: binding.argumentDigest }
+  });
+  if (!await input.authorize("before_delivery")) {
+    throw new Error("MCP operation observation is not authorized for delivery");
+  }
+  const envelope = AttemptToolResult.parse(response);
+  if (envelope.isError) {
+    throw new Error("MCP operation observer returned an error, not a receipt");
+  }
+  const receipt = receiptSchema.parse(envelope.structuredContent);
+  if (receipt.operationRef !== binding.operationId || receipt.fingerprint.value !== binding.argumentDigest) {
+    throw new Error("MCP operation observation receipt identity does not match");
+  }
+  return receipt;
+}
+
 // src/skill-catalog.ts
 var SKILL_CATALOG_MAX_BYTES = 32 * 1024;
 var SKILL_CATALOG_MAX_ENTRIES = 128;
@@ -259,6 +421,7 @@ import {
   AGENT_INSTRUCTIONS_CORE_PLACEHOLDER,
   collectSandboxEnvironment,
   configuredProviders as configuredProviders2,
+  McpOperationRecoverySchema,
   firstPartyMcpInternalBaseUrl,
   firstPartyMcpInternalWorkspaceUrl as firstPartyMcpInternalWorkspaceUrl2,
   resolveFirstPartyDelegationSecret as resolveFirstPartyDelegationSecret2,
@@ -299,7 +462,7 @@ import {
   GenerateVideoToolInput,
   GetVideoGenerationCapabilitiesToolInput,
   RequestHumanInputToolInput as RequestHumanInputToolInput2,
-  AttemptToolResult as AttemptToolResult2
+  AttemptToolResult as AttemptToolResult3
 } from "@opengeni/contracts";
 import { renderSessionGoalContext as renderSessionGoalContext2 } from "@opengeni/contracts";
 
@@ -2842,13 +3005,13 @@ function convertToOutputItem(items) {
       };
       return output;
     } else if (item.type === "program") {
-      const { id, call_id, code, fingerprint, type: _type, ...providerData } = item;
+      const { id, call_id, code, fingerprint: fingerprint2, type: _type, ...providerData } = item;
       const output = {
         type: "program",
         id,
         callId: call_id,
         code,
-        fingerprint,
+        fingerprint: fingerprint2,
         providerData
       };
       return output;
@@ -3763,14 +3926,14 @@ var OpenAIResponsesWSModel = class extends OpenAIResponsesModel {
     return baseURL.toString();
   }
   async #ensureWebSocketConnection(wsURL, headers, signal, requestTimeoutDeadline) {
-    const identity = this.#getConnectionIdentity(wsURL, headers);
-    if (this.#wsConnection && this.#wsConnectionIdentity && this.#wsConnectionIdentity === identity && this.#wsConnection.isReusable()) {
+    const identity2 = this.#getConnectionIdentity(wsURL, headers);
+    if (this.#wsConnection && this.#wsConnectionIdentity && this.#wsConnectionIdentity === identity2 && this.#wsConnection.isReusable()) {
       return { connection: this.#wsConnection, reused: true };
     }
     await this.#dropWebSocketConnection();
     const connectTimeout = this.#resolveWebSocketRequestTimeout(requestTimeoutDeadline, (configuredTimeoutMs) => `Responses websocket connection timed out before opening after ${configuredTimeoutMs}ms.`);
     this.#wsConnection = await ResponsesWebSocketConnection.connect(wsURL, headers, signal, connectTimeout.timeoutMs, connectTimeout.errorMessage, this.#websocketOptions);
-    this.#wsConnectionIdentity = identity;
+    this.#wsConnectionIdentity = identity2;
     return { connection: this.#wsConnection, reused: false };
   }
   async #reconnectWebSocketConnection(wsURL, headers, signal, requestTimeoutDeadline) {
@@ -7022,8 +7185,8 @@ function searchToolPool(availableTools, rawArguments) {
 }
 
 // src/model-request-capture.ts
-import { AsyncLocalStorage } from "async_hooks";
-var modelRequestCapture = new AsyncLocalStorage();
+import { AsyncLocalStorage as AsyncLocalStorage3 } from "async_hooks";
+var modelRequestCapture = new AsyncLocalStorage3();
 var captureIndices = /* @__PURE__ */ new WeakMap();
 function nextModelContextCaptureIndex(agent) {
   const index = (captureIndices.get(agent) ?? 0) + 1;
@@ -7787,7 +7950,7 @@ var LazyToolModelProvider = class {
 
 // src/mcp-result-custom-data.ts
 import {
-  AttemptToolResult
+  AttemptToolResult as AttemptToolResult2
 } from "@opengeni/contracts";
 import { randomUUID } from "crypto";
 var OPENGENI_MCP_RESULT_CUSTOM_DATA_KEY = "__opengeniMcpResultV1";
@@ -7858,7 +8021,7 @@ function normalizeSdkToolOutputCustomData(value) {
   return JSON.parse(JSON.stringify(value));
 }
 function normalizeMcpResult(value) {
-  return normalizeProtocolJsonValue(AttemptToolResult.parse(value), "$.mcpResult");
+  return normalizeProtocolJsonValue(AttemptToolResult2.parse(value), "$.mcpResult");
 }
 var McpResultCustomDataBridge = class {
   constructor(input) {
@@ -8048,7 +8211,7 @@ function compactMcpResultCustomDataRunState(serialized) {
 function mcpResultFromCustomData(customData) {
   if (!customData || typeof customData !== "object" || Array.isArray(customData)) return null;
   const marker = customData[OPENGENI_MCP_RESULT_CUSTOM_DATA_KEY];
-  const parsed = AttemptToolResult.safeParse(marker);
+  const parsed = AttemptToolResult2.safeParse(marker);
   return parsed.success ? parsed.data : null;
 }
 
@@ -8263,7 +8426,7 @@ import {
   CODEX_ORIGINATOR,
   codexAppsSanitizingFetch
 } from "@opengeni/codex";
-import { AsyncLocalStorage as AsyncLocalStorage3 } from "async_hooks";
+import { AsyncLocalStorage as AsyncLocalStorage5 } from "async_hooks";
 import { createHash as createHash5, randomUUID as randomUUID3 } from "crypto";
 import { dirname as dirname2, isAbsolute, join as join2, posix as posixPath2 } from "path";
 
@@ -10975,9 +11138,9 @@ function* jsonStringFragments(value) {
 }
 
 // src/model-preparation-diagnostics.ts
-import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
-var modelPreparationObserver = new AsyncLocalStorage2();
-var modelTransportStartedObserver = new AsyncLocalStorage2();
+import { AsyncLocalStorage as AsyncLocalStorage4 } from "async_hooks";
+var modelPreparationObserver = new AsyncLocalStorage4();
+var modelTransportStartedObserver = new AsyncLocalStorage4();
 var ModelPreparationTraceProcessor = class {
   async onTraceStart(_trace) {
   }
@@ -11933,7 +12096,7 @@ import { existsSync, readdirSync } from "fs";
 // ../sdk/package.json
 var package_default = {
   name: "@opengeni/sdk",
-  version: "5.0.3",
+  version: "5.0.5-canary.0",
   description: "Framework-agnostic TypeScript SDK for the OpenGeni API: typed client, session lifecycle, SSE event streaming with reconnect + replay-by-sequence, and proxy re-streaming helpers.",
   license: "Apache-2.0",
   repository: {
@@ -12073,7 +12236,7 @@ var package_default = {
 // ../react/package.json
 var package_default2 = {
   name: "@opengeni/react",
-  version: "5.0.4",
+  version: "5.0.5-canary.0",
   description: "React hooks and styled components for OpenGeni: live session streaming, chat composer, message timeline, session status, and fleet views \u2014 token-themed (CSS variables), dark-first, built on Tailwind v4 + Radix + Motion.",
   license: "Apache-2.0",
   repository: {
@@ -12325,7 +12488,7 @@ var package_default2 = {
 // ../codemode/package.json
 var package_default3 = {
   name: "@opengeni/codemode",
-  version: "0.5.5",
+  version: "0.5.6-canary.0",
   description: "Attempt-frozen programmatic tool catalog and execution authority for OpenGeni.",
   license: "Apache-2.0",
   repository: {
@@ -12374,7 +12537,7 @@ var package_default3 = {
 // ../ogtool/package.json
 var package_default4 = {
   name: "@opengeni/ogtool",
-  version: "0.3.37",
+  version: "0.3.38-canary.0",
   description: "Codemode CLI and typed client entrypoint for an OpenGeni execution attempt.",
   license: "Apache-2.0",
   repository: {
@@ -16788,7 +16951,8 @@ var ConnectorActionExecutionError = class extends Error {
     this.connectorActionOutcome = outcome;
   }
 };
-var modelToolInvocation = new AsyncLocalStorage3();
+var modelToolInvocation = new AsyncLocalStorage5();
+var modelMcpCallIdentity = new AsyncLocalStorage5();
 var agentInputWaitYields = /* @__PURE__ */ new WeakMap();
 function rigInstructions(rig) {
   return [
@@ -17231,6 +17395,7 @@ function buildOpenGeniAgent(settings, resources, options = {}) {
       agent2,
       options.approvedToolCallId
     );
+    installModelMcpCallIdentity(agent2);
     return agent2;
   }
   if (options.activeSandboxBackend === "selfhosted" && !options.sandboxWorkspaceRoot) {
@@ -17332,6 +17497,7 @@ function buildOpenGeniAgent(settings, resources, options = {}) {
     agent,
     options.approvedToolCallId
   );
+  installModelMcpCallIdentity(agent);
   return agent;
 }
 function maybeInstallLazyToolTransport(agent, settings, options) {
@@ -17368,6 +17534,35 @@ function sessionMcpApprovalConnectionId(serverId, url) {
   const targetHash = createHash5("sha256").update(url, "utf8").digest("hex");
   return `session-mcp:${serverId}:${targetHash}`;
 }
+function installModelMcpCallIdentity(agent) {
+  const listMcpTools = agent.getMcpTools.bind(agent);
+  agent.getMcpTools = async (resolutionContext) => (await listMcpTools(resolutionContext)).map((tool2) => {
+    if (tool2.type !== "function") return tool2;
+    const invoke = tool2.invoke.bind(tool2);
+    return {
+      ...tool2,
+      invoke: async (runContext, input, details) => {
+        const callId3 = details?.toolCall?.callId;
+        return await modelMcpCallIdentity.run(
+          typeof callId3 === "string" && callId3.length > 0 ? { modelName: tool2.name, callId: callId3 } : null,
+          async () => await invoke(runContext, input, details)
+        );
+      }
+    };
+  });
+  const clone = agent.clone?.bind(agent);
+  if (clone) {
+    agent.clone = (config) => {
+      const cloned = clone(config);
+      installModelMcpCallIdentity(cloned);
+      return cloned;
+    };
+  }
+}
+function modelMcpSourceCallId(modelName) {
+  const identity2 = modelMcpCallIdentity.getStore();
+  return identity2?.modelName === modelName ? identity2.callId : void 0;
+}
 function installMcpApprovalPolicy(agent, policies, connectorActionPolicy, approvedToolCallId) {
   const approvalRequiredCallIds = /* @__PURE__ */ new Set();
   const preparations = /* @__PURE__ */ new Map();
@@ -17958,24 +18153,30 @@ async function prepareAgentTools(settings, tools, options = {}) {
         }
         const optional2 = tool2.optional === true;
         return {
-          server: new PrefixedMcpServer(
-            local.server,
-            config.id,
-            config.allowedTools,
-            optional2 || Boolean(config.connectionRef),
-            aggregateToolBudget,
-            `${config.id}:${index}`,
-            false,
-            buildConnectorAttachmentAuthority(
-              config,
-              options,
-              resolvedMcpToolConnectionIds,
-              config.url,
-              local.resolvedConnectionId
+          server: configureMcpOperationRecovery(
+            new PrefixedMcpServer(
+              local.server,
+              config.id,
+              config.allowedTools,
+              optional2 || Boolean(config.connectionRef),
+              aggregateToolBudget,
+              `${config.id}:${index}`,
+              false,
+              buildConnectorAttachmentAuthority(
+                config,
+                options,
+                resolvedMcpToolConnectionIds,
+                config.url,
+                local.resolvedConnectionId
+              ),
+              tool2.eager !== true,
+              local.preflightCall,
+              local.approvalAuthority
             ),
-            tool2.eager !== true,
-            local.preflightCall,
-            local.approvalAuthority
+            config,
+            options,
+            config.url,
+            false
           ),
           bestEffort: optional2 || Boolean(config.connectionRef),
           optional: optional2,
@@ -18048,20 +18249,26 @@ async function prepareAgentTools(settings, tools, options = {}) {
           clientSessionTimeoutSeconds: Math.ceil(config.timeoutMs / 1e3)
         } : {}
       });
-      const server = new PrefixedMcpServer(
-        innerServer,
-        config.id,
-        config.allowedTools,
-        bestEffort,
-        aggregateToolBudget,
-        `${config.id}:${index}`,
-        firstParty && !bestEffort,
-        buildConnectorAttachmentAuthority(config, options, resolvedMcpToolConnectionIds, url),
-        tool2.eager !== true,
-        void 0,
-        void 0,
-        firstParty && config.id === "opengeni" && !config.connectionRef && !bridge ? inputWaitYield : void 0,
-        firstParty && config.id === "opengeni" && !config.connectionRef && !bridge ? options.refreshOwnedCommand : void 0
+      const server = configureMcpOperationRecovery(
+        new PrefixedMcpServer(
+          innerServer,
+          config.id,
+          config.allowedTools,
+          bestEffort,
+          aggregateToolBudget,
+          `${config.id}:${index}`,
+          firstParty && !bestEffort,
+          buildConnectorAttachmentAuthority(config, options, resolvedMcpToolConnectionIds, url),
+          tool2.eager !== true,
+          void 0,
+          void 0,
+          firstParty && config.id === "opengeni" && !config.connectionRef && !bridge ? inputWaitYield : void 0,
+          firstParty && config.id === "opengeni" && !config.connectionRef && !bridge ? options.refreshOwnedCommand : void 0
+        ),
+        config,
+        options,
+        url,
+        Boolean(config.connectionRef) && !bridge && !isCodexAppsMcpServer(config)
       );
       return {
         server,
@@ -18570,17 +18777,39 @@ async function prepareToolGatewayDefinitionsFromServers(servers, registry) {
               ...context.signal ? { signal: context.signal } : {}
             })
           } : {},
-          execute: async (args, context) => await server.executeCatalogTool(
-            toolName,
-            args,
-            {
-              ...context.transportMeta ?? {},
-              opengeniOperationId: context.operationId
-            },
-            {
-              ...context.signal ? { signal: context.signal } : {}
+          execute: async (args, context) => {
+            const execute = async () => await server.executeCatalogTool(
+              toolName,
+              args,
+              {
+                ...context.transportMeta ?? {},
+                opengeniOperationId: context.operationId
+              },
+              {
+                ...context.signal ? { signal: context.signal } : {}
+              }
+            );
+            const recovery = configuredMcpOperationRecovery(server, toolName);
+            if (!recovery) return await execute();
+            if (!recovery.supported || !["model", "codemode"].includes(context.caller.kind)) {
+              throw new Error(
+                "MCP operation recovery requires an exact attempt and remote brokered execution"
+              );
             }
-          )
+            return await runRecoverableMcpOperation(
+              {
+                operationId: context.operationId,
+                ...context.sourceCallId === void 0 ? {} : { sourceCallId: context.sourceCallId },
+                serverId: server.registryId,
+                originalTool: toolName,
+                observerTool: recovery.policy[toolName].observerTool,
+                destinationDigest: recovery.destinationDigest,
+                argumentDigest: digestCanonicalJson(args)
+              },
+              recovery.persistence,
+              execute
+            );
+          }
         };
       });
     }
@@ -18594,6 +18823,22 @@ function attemptToolCodemodePath(serverId, toolName) {
   }
   return [serverId, toolName];
 }
+var mcpOperationRecoveryByServer = /* @__PURE__ */ new WeakMap();
+function configureMcpOperationRecovery(server, config, options, destinationUrl, brokered) {
+  if (config.operationRecovery && options.mcpOperationPersistence) {
+    mcpOperationRecoveryByServer.set(server, {
+      policy: McpOperationRecoverySchema.parse(config.operationRecovery),
+      persistence: options.mcpOperationPersistence,
+      destinationDigest: digestCanonicalJson(new URL(destinationUrl).toString()),
+      supported: brokered && attemptToolScope(options) !== null
+    });
+  }
+  return server;
+}
+function configuredMcpOperationRecovery(server, toolName) {
+  const recovery = mcpOperationRecoveryByServer.get(server);
+  return recovery && Object.hasOwn(recovery.policy, toolName) ? recovery : void 0;
+}
 function attemptToolSource(serverId) {
   if (serverId === "opengeni" || serverId === "files" || serverId === "docs") {
     return serverId;
@@ -18650,6 +18895,24 @@ function connectionBrokerFetch(baseFetch, config, options, resolvedMcpConnection
         suppressSetupAuthNeeded
       );
     }
+    if (request.method === "tools/call") {
+      assertMcpOperationObservationAuthority({
+        serverId: config.id,
+        ...request.toolName === void 0 ? {} : { toolName: request.toolName },
+        destinationDigest: digestCanonicalJson(destinationUrl),
+        ...first.operationAuthorityDigest === void 0 ? {} : { authorityDigest: first.operationAuthorityDigest }
+      });
+      if (hasActiveRecoverableMcpOperation() && (request.batch || request.id === void 0 || request.id === null || !request.operationId || !request.toolName)) {
+        throw new Error("Recoverable MCP request is missing its exact dispatch identity");
+      }
+      await captureMcpOperationDispatch({
+        operationId: request.operationId ?? "",
+        serverId: config.id,
+        toolName: request.toolName ?? "",
+        destinationDigest: digestCanonicalJson(destinationUrl),
+        authorityDigest: first.operationAuthorityDigest ?? ""
+      });
+    }
     const response = await baseFetch(
       fetchInputForAttempt(input),
       withConnectionHeaders(input, init, first.headers)
@@ -19635,10 +19898,12 @@ var AttemptDefinitionMcpServer = class {
   async callToolResult(toolName, args, meta, options) {
     if (this.closed) throw new Error("local model tool server is closed");
     const environment = await this.requiredAttemptToolEnvironment();
+    const sourceCallId = modelMcpSourceCallId(toolName);
     return await this.resultCustomDataBridge.captureResult(
       args,
       async (cleanArgs) => environment.callModel({
         modelName: toolName,
+        ...sourceCallId === void 0 ? {} : { sourceCallId },
         arguments: cleanArgs ?? {},
         subjectId: this.subjectId,
         ...meta === void 0 ? {} : { transportMeta: meta },
@@ -19888,8 +20153,10 @@ var PrefixedMcpServer = class _PrefixedMcpServer {
     }
     return await this.resultCustomDataBridge.captureResult(args, async (cleanArgs) => {
       if (this.attemptToolEnvironment) {
+        const sourceCallId = modelMcpSourceCallId(toolName);
         return await this.attemptToolEnvironment.callModel({
           modelName: toolName,
+          ...sourceCallId === void 0 ? {} : { sourceCallId },
           arguments: cleanArgs ?? {},
           subjectId: this.attemptToolSubjectId,
           ...meta === void 0 ? {} : { transportMeta: meta },
@@ -19909,6 +20176,9 @@ var PrefixedMcpServer = class _PrefixedMcpServer {
     if (!this.isAllowed(unprefixed)) {
       throw new Error(`MCP tool ${unprefixed} is not allowed for server ${this.registryId}`);
     }
+    if (configuredMcpOperationRecovery(this, unprefixed) && !hasActiveRecoverableMcpOperation()) {
+      throw new Error("MCP operation recovery requires its trusted attempt execution context");
+    }
     const recordsPhysicalCall = !(this.inner instanceof _PrefixedMcpServer);
     const startedAt = recordsPhysicalCall ? performance.now() : 0;
     let metricRecorded = false;
@@ -19929,7 +20199,7 @@ var PrefixedMcpServer = class _PrefixedMcpServer {
         args: args ?? {},
         ...options?.signal ? { signal: options.signal } : {},
         refresh: this.refreshOwnedCommand,
-        call: async (callArgs) => AttemptToolResult2.parse(unwrapSdkMcpResultProjection(await physicalCall(callArgs)))
+        call: async (callArgs) => AttemptToolResult3.parse(unwrapSdkMcpResultProjection(await physicalCall(callArgs)))
       }) : await physicalCall(args ?? {});
       const rawOutput = unwrapSdkMcpResultProjection(projectedOutput);
       const connectionId = operationId ? this.connectorAttachmentAuthority?.connectionIdForOperation(operationId) : void 0;
@@ -19954,7 +20224,7 @@ var PrefixedMcpServer = class _PrefixedMcpServer {
           });
         }
       });
-      const result = AttemptToolResult2.parse(output);
+      const result = AttemptToolResult3.parse(output);
       boundedMcpToolResult(result);
       recordOutcome(result.isError === true ? "provider_declared_error" : "success");
       if (unprefixed === "wait_for_input" && result.isError !== true) {
@@ -19962,6 +20232,12 @@ var PrefixedMcpServer = class _PrefixedMcpServer {
       }
       return result;
     } catch (error) {
+      if (hasActiveRecoverableMcpOperation()) {
+        recordOutcome(
+          isToolOutcomeUncertainMcpError(error) ? "outcome_uncertain" : isAuthNeededMcpError(error) ? "auth_needed" : mcpThrownToolCallOutcome(error, options?.signal)
+        );
+        throw error;
+      }
       if (isToolOutcomeUncertainMcpError(error)) {
         recordOutcome("outcome_uncertain");
         return boundedMcpToolResult({
@@ -22845,6 +23121,13 @@ function sortJson(value) {
 }
 
 export {
+  hasActiveRecoverableMcpOperation,
+  McpOperationOutcomeUnknownError,
+  runRecoverableMcpOperation,
+  captureMcpOperationDispatch,
+  runMcpOperationObservationWithAuthority,
+  assertMcpOperationObservationAuthority,
+  observeMcpOperation,
   formatSkillCatalog,
   OpenAIResponsesModel,
   OpenAIChatCompletionsModel,
@@ -23094,4 +23377,4 @@ export {
   runAzureCliLoginHook,
   renderSessionGoalContext2 as renderSessionGoalContext
 };
-//# sourceMappingURL=chunk-GJC7H2FC.js.map
+//# sourceMappingURL=chunk-SD6MDONS.js.map