@opengeni/runtime 2.5.2 → 2.5.3-canary.1

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

@@ -23,14 +23,17 @@ import {
   withRunCredentialsClient,
   withRunCredentialsSession,
   wrapCapabilityToolsForTurnCancellation
-} from "./chunk-LGLJ5PVD.js";
+} from "./chunk-46BFUGFL.js";
 import {
   MemorySession,
   connectMcpServers
-} from "./chunk-CD22I76N.js";
+} from "./chunk-FHGLYLBL.js";
 import {
   SKILL_MAX_FILES,
+  SKILL_READ_MAX_OUTPUT_BYTES,
+  SKILL_READ_MAX_PATHS,
   SkillFileError,
+  assertSkillRelativePath,
   buildPortableSkillArtifact,
   listSkillPaths,
   readSkillFiles,
@@ -108,7 +111,7 @@ import {
   tool,
   withGenerationSpan,
   withResponseSpan
-} from "./chunk-25B3EQRW.js";
+} from "./chunk-UNICCRW5.js";
 
 // src/command-read-refresh.ts
 async function executeCommandReadWithRefresh(input) {
@@ -203,6 +206,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 +424,7 @@ import {
   AGENT_INSTRUCTIONS_CORE_PLACEHOLDER,
   collectSandboxEnvironment,
   configuredProviders as configuredProviders2,
+  McpOperationRecoverySchema,
   firstPartyMcpInternalBaseUrl,
   firstPartyMcpInternalWorkspaceUrl as firstPartyMcpInternalWorkspaceUrl2,
   resolveFirstPartyDelegationSecret as resolveFirstPartyDelegationSecret2,
@@ -299,7 +465,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 +3008,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 +3929,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 +7188,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;
@@ -7160,6 +7326,8 @@ var ALWAYS_VISIBLE_BASE_TOOL_NAMES = /* @__PURE__ */ new Set([
   "apply_patch",
   // The server-backed reader needs neither sandbox setup nor tool search.
   "skill_read",
+  // Repository descriptors route to the live sandbox reader.
+  "repository_skill_read",
   "request_human_input",
   "list_models"
 ]);
@@ -7787,7 +7955,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 +8026,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 +8216,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 +8431,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";
 
@@ -8856,7 +9024,7 @@ Skills are reusable instructions supplied dynamically for the current session. W
 
 Use \`session_events\` for conversation history: its default returns user and completed assistant messages, not execution noise. Cursors only paginate. Request \`results\` for final outcomes, \`tools\` for tool receipts, or \`debug\` for explicit diagnostics; request large tool bodies only when needed. Use the returned continuation cursor rather than rereading whole pages. Audit reads do not acknowledge command completion.
 
-For a yielded command, use \`command_read\` to read available output and status, or \`command_wait\` to wait briefly using the same command interface. Keep the command ID and output cursor. A terminal read suppresses any still-pending completion notification; a running read does not. Earlier tool results and delivered messages never change. Use \`command_input\` only to send input where supported, not to poll output. An unsupported input capability does not imply output is unavailable. Give foreground commands a realistic requested wait; an internal polling slice is not a reason to return a background handle.
+For a yielded command, use \`command_read\` to read available output and status, or \`command_wait\` to wait briefly using the same command interface. Keep the command ID and output cursor. A terminal read suppresses any still-pending completion notification; a running read does not. Earlier tool results and delivered messages never change. Use \`command_input\` only to send input where supported, not to poll output. An unsupported input capability does not imply output is unavailable. Give foreground commands a realistic requested wait; default to 10 seconds (yield_time_ms: 10000). An internal polling slice is not a reason to return a background handle.
 
 If the user asks to create, inspect, continue, pause, resume, steer, rename, or otherwise manage a session, use the corresponding session tool. Pause affects the selected workstream and its descendants: pausing an ancestor also stops you, so you cannot then Resume yourself. Coordinate disjoint edits through messages instead of ancestor Pause.
 
@@ -10975,9 +11143,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) {
   }
@@ -11711,6 +11879,7 @@ function configureOpenAI(settings) {
 
 // src/workspace-skills.ts
 import { createHash as createHash4 } from "crypto";
+import { parseSkillFrontmatter } from "@opengeni/contracts";
 import { SandboxFilesystemNotFoundError } from "modal";
 var SKILL_FILE = "SKILL.md";
 var MAX_DISCOVERED_SKILLS = 256;
@@ -11729,21 +11898,84 @@ var WorkspaceSkillsCapability = class extends Capability {
   }
   type = "workspace-skills";
   discovery;
-  async instructions() {
+  bind(session) {
+    if (this._session !== session) delete this.discovery;
+    return super.bind(session);
+  }
+  discover() {
     const session = requireWorkspaceSkillSession(this._session);
-    this.discovery ??= discoverWorkspaceSkills(
+    return this.discovery ??= discoverWorkspaceSkills(
       session,
       this.searchPaths,
       this.reservedNames,
       this._runAs,
       this.shadowedNames
     );
-    const skills = await this.discovery;
+  }
+  tools() {
+    return [
+      tool({
+        name: "repository_skill_read",
+        description: "Read current repository Skill files from the bound workspace. Use the exact repository: identifier from the Repository skills index. Omit paths for SKILL.md; explicit relative paths read only those files. Set listFiles:true without paths for a bounded file inventory. This reads live files through the sandbox, including Connected Machines.",
+        parameters: external_exports.object({
+          skill: external_exports.string().min(1),
+          paths: external_exports.array(external_exports.string().min(1).max(1024)).min(1).max(SKILL_READ_MAX_PATHS).optional(),
+          listFiles: external_exports.boolean().optional()
+        }),
+        execute: async (request) => {
+          if (request.listFiles && request.paths !== void 0)
+            throw new SkillFileError(
+              "invalid_request",
+              "listFiles:true cannot be combined with paths."
+            );
+          const skill = (await this.discover()).find(
+            (entry) => repositorySkillId(entry) === request.skill
+          );
+          if (!skill)
+            throw new SkillFileError(
+              "missing_file",
+              "Repository Skill is not in this index. Use its exact repository: identifier."
+            );
+          const session = requireWorkspaceSkillSession(this._session);
+          const root = skill.path.slice(0, -SKILL_FILE.length - 1);
+          const result = request.listFiles ? listSkillPaths(
+            await repositorySkillInventory(session, root, this._runAs),
+            MAX_SKILL_ENTRIES
+          ) : readSkillFiles(
+            await repositorySkillFiles(
+              session,
+              root,
+              request.paths ?? [SKILL_FILE],
+              this._runAs
+            ),
+            request.paths
+          );
+          const output = JSON.stringify({
+            skillId: request.skill,
+            source: "repository",
+            root,
+            ...result
+          });
+          if (new TextEncoder().encode(output).byteLength > SKILL_READ_MAX_OUTPUT_BYTES) {
+            throw new SkillFileError(
+              "output_too_large",
+              "Repository Skill response exceeds the read output limit. Request fewer paths."
+            );
+          }
+          return output;
+        }
+      })
+    ];
+  }
+  async instructions() {
+    const skills = await this.discover();
     if (skills.length === 0) return null;
-    const available = skills.map((skill) => `- ${skill.name}: ${skill.description} (file: ${skill.path})`).join("\n");
+    const available = skills.map(
+      (skill) => `- ${JSON.stringify({ id: repositorySkillId(skill), name: skill.name, description: skill.description, reader: "repository_skill_read", path: skill.path })}`
+    ).join("\n");
     return `## Repository skills
 
-Repository skills are instructions already present in the live workspace. They do not need to be loaded or copied.
+Repository skills are instructions already present in the live workspace. Read them with repository_skill_read using the exact repository: id below. The reader returns current live files; ordinary filesystem tools execute referenced scripts and read binary assets. Configured Skills use their separate skill_read index.
 
 ### Available repository skills
 ${available}
@@ -11808,6 +12040,14 @@ async function discoverWorkspaceSkillsUnmeasured(session, searchPaths, reservedN
       const skillMarkdownPath = joinWorkspacePath(entry.path, SKILL_FILE);
       let markdown;
       try {
+        const skillEntries = await session.listDir({
+          path: entry.path,
+          ...runAs ? { runAs } : {}
+        });
+        if (!skillEntries.some(
+          (candidate2) => candidate2.name === SKILL_FILE && candidate2.type === "file"
+        ))
+          continue;
         const content = await session.readFile({
           path: skillMarkdownPath,
           ...runAs ? { runAs } : {}
@@ -11825,7 +12065,7 @@ async function discoverWorkspaceSkillsUnmeasured(session, searchPaths, reservedN
       const key = name.toLowerCase();
       if (shadowedNames.has(key)) continue;
       const description = frontmatter.description?.trim() || "No description provided.";
-      if (description.length > 2048 || /[\r\n]/.test(description)) {
+      if (description.length > 2048) {
         throw new Error(`Repository skill "${name}" has an invalid description`);
       }
       if (reservedNames.has(key)) {
@@ -11896,26 +12136,59 @@ async function fingerprintWorkspaceDirectory(session, root, runAs) {
   await visit(root, "");
   return hash.digest("hex");
 }
-function parseSkillFrontmatter(markdown) {
-  const lines = markdown.split(/\r?\n/);
-  if (lines[0]?.trim() !== "---") return {};
-  const end = lines.findIndex((line, index) => index > 0 && line.trim() === "---");
-  if (end === -1) return {};
-  const values = {};
-  for (const line of lines.slice(1, end)) {
-    const separator = line.indexOf(":");
-    if (separator === -1) continue;
-    const key = line.slice(0, separator).trim();
-    if (key !== "name" && key !== "description") continue;
-    values[key] = unquote(line.slice(separator + 1).trim());
-  }
-  return values;
-}
-function unquote(value) {
-  if (value.length >= 2 && value[0] === value[value.length - 1] && (value[0] === '"' || value[0] === "'")) {
-    return value.slice(1, -1);
+function repositorySkillId(skill) {
+  return `repository:${skill.path}`;
+}
+async function repositorySkillFiles(session, root, paths, runAs) {
+  readSkillFiles(
+    paths.map((path) => ({ path, content: "" })),
+    paths
+  );
+  const files = [];
+  for (const path of paths) {
+    let directory = root;
+    const segments = path.split("/");
+    for (const [index, name] of segments.entries()) {
+      const entries = await session.listDir({ path: directory, ...runAs ? { runAs } : {} });
+      const entry = entries.find((candidate) => candidate.name === name);
+      const expected = index === segments.length - 1 ? "file" : "dir";
+      if (entry?.type !== expected)
+        throw new SkillFileError("missing_file", `Repository Skill file is unavailable: ${path}`);
+      directory = joinWorkspacePath(directory, name);
+    }
+    const content = await session.readFile({ path: directory, ...runAs ? { runAs } : {} });
+    files.push({
+      path,
+      content: typeof content === "string" ? content : new TextDecoder("utf-8", { fatal: true }).decode(content)
+    });
+    readSkillFiles(
+      files,
+      files.map((file2) => file2.path)
+    );
+  }
+  return files;
+}
+async function repositorySkillInventory(session, root, runAs) {
+  const files = [];
+  let count = 0;
+  async function visit(relative) {
+    const entries = await session.listDir({
+      path: relative ? joinWorkspacePath(root, relative) : root,
+      ...runAs ? { runAs } : {}
+    });
+    for (const entry of entries) {
+      if (++count > MAX_SKILL_ENTRIES)
+        throw new SkillFileError("output_too_large", "Repository Skill inventory is too large.");
+      assertSkillRelativePath(entry.name);
+      if (entry.name.includes("/"))
+        throw new SkillFileError("invalid_path", "Invalid repository directory entry.");
+      const path = relative ? `${relative}/${entry.name}` : entry.name;
+      if (entry.type === "dir") await visit(path);
+      else if (entry.type === "file") files.push({ path, content: "" });
+    }
   }
-  return value;
+  await visit("");
+  return files;
 }
 function joinWorkspacePath(parent, child) {
   return `${parent.replace(/\/+$/, "")}/${child}`;
@@ -11933,7 +12206,7 @@ import { existsSync, readdirSync } from "fs";
 // ../sdk/package.json
 var package_default = {
   name: "@opengeni/sdk",
-  version: "5.0.3",
+  version: "5.0.5-canary.1",
   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 +12346,7 @@ var package_default = {
 // ../react/package.json
 var package_default2 = {
   name: "@opengeni/react",
-  version: "5.0.4",
+  version: "5.0.5-canary.1",
   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: {
@@ -12217,6 +12490,7 @@ var package_default2 = {
     "react-resizable-panels": "^4.11.2",
     "remark-gfm": "^4.0.1",
     "tailwind-merge": "^3.5.0",
+    "thinking-orbs": "^0.3.1",
     virtua: "^0.49.2"
   },
   devDependencies: {
@@ -12325,7 +12599,7 @@ var package_default2 = {
 // ../codemode/package.json
 var package_default3 = {
   name: "@opengeni/codemode",
-  version: "0.5.5",
+  version: "0.5.6-canary.1",
   description: "Attempt-frozen programmatic tool catalog and execution authority for OpenGeni.",
   license: "Apache-2.0",
   repository: {
@@ -12374,7 +12648,7 @@ var package_default3 = {
 // ../ogtool/package.json
 var package_default4 = {
   name: "@opengeni/ogtool",
-  version: "0.3.37",
+  version: "0.3.38-canary.1",
   description: "Codemode CLI and typed client entrypoint for an OpenGeni execution attempt.",
   license: "Apache-2.0",
   repository: {
@@ -12453,7 +12727,7 @@ var emptyNativeToolSkillSet = Object.freeze({
   videoGeneration: false
 });
 function loadNativeToolSkillArtifacts(nativeTools) {
-  const directories = [];
+  const directories = ["bundled_default_skills"];
   if (nativeTools.projects) directories.push("bundled_project_skills");
   if (nativeTools.editableArtifacts) directories.push("bundled_artifact_skills");
   if (nativeTools.sites) directories.push("bundled_site_skills");
@@ -12670,7 +12944,12 @@ function selectionForActivation({
   }
 }
 function nativeToolSkillSources(nativeTools) {
-  const sources = [];
+  const sources = [
+    {
+      names: skillDirNames(packagedSkillDirectory("bundled_default_skills")),
+      reason: "included by default"
+    }
+  ];
   if (nativeTools.editableArtifacts) {
     sources.push({
       names: skillDirNames(packagedSkillDirectory("bundled_artifact_skills")),
@@ -16788,7 +17067,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 +17511,7 @@ function buildOpenGeniAgent(settings, resources, options = {}) {
       agent2,
       options.approvedToolCallId
     );
+    installModelMcpCallIdentity(agent2);
     return agent2;
   }
   if (options.activeSandboxBackend === "selfhosted" && !options.sandboxWorkspaceRoot) {
@@ -17332,6 +17613,7 @@ function buildOpenGeniAgent(settings, resources, options = {}) {
     agent,
     options.approvedToolCallId
   );
+  installModelMcpCallIdentity(agent);
   return agent;
 }
 function maybeInstallLazyToolTransport(agent, settings, options) {
@@ -17368,6 +17650,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 +18269,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 +18365,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 +18893,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 +18939,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 +19011,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 +20014,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 +20269,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 +20292,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 +20315,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 +20340,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 +20348,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 +23237,13 @@ function sortJson(value) {
 }
 
 export {
+  hasActiveRecoverableMcpOperation,
+  McpOperationOutcomeUnknownError,
+  runRecoverableMcpOperation,
+  captureMcpOperationDispatch,
+  runMcpOperationObservationWithAuthority,
+  assertMcpOperationObservationAuthority,
+  observeMcpOperation,
   formatSkillCatalog,
   OpenAIResponsesModel,
   OpenAIChatCompletionsModel,
@@ -23094,4 +23493,4 @@ export {
   runAzureCliLoginHook,
   renderSessionGoalContext2 as renderSessionGoalContext
 };
-//# sourceMappingURL=chunk-GJC7H2FC.js.map
+//# sourceMappingURL=chunk-VUEWS4GI.js.map