@skaile/workspaces 3.18.0 → 3.20.0

package/dist/bridge/drivers/codex.js

@@ -1,14 +1,15 @@
-import { CodexAppServerClient } from '../../chunk-XKSGEYZC.js';
-import { parseCodexCredential, prepareNativePolicy, prepareCodexInstance, codexInstanceEnvironment, activateNativeApprovalPolicy, parseCodexRefreshResult, isNativeApprovalPolicyActive, allowsNativeApprovalPath } from '../../chunk-T3YLZQS4.js';
+import { CodexAppServerClient } from '../../chunk-PHBYB4XT.js';
+import { parseCodexCredential, prepareNativePolicy, prepareCodexInstance, codexInstanceEnvironment, isNativeApprovalPolicyActive, activateNativeApprovalPolicy, parseCodexRefreshResult, allowsNativeApprovalPath } from '../../chunk-T3YLZQS4.js';
 import { CodexNativeStateUnavailable } from '../../chunk-LOO5CB5M.js';
 import { fetchProviderModels } from '../../chunk-GURXUF2J.js';
 import { classifyGenericErrorMessage } from '../../chunk-GAH4YRCI.js';
-import { BUILTIN_DRIVER_CATALOG, AgentDriver, getBridgeLogger } from '../../chunk-J7VSUGGH.js';
+import { BUILTIN_DRIVER_CATALOG, AgentDriver, getBridgeLogger } from '../../chunk-6FZCQT3V.js';
 import '../../chunk-6E6PKKAD.js';
 import '../../chunk-FTG7CRFD.js';
 import '../../chunk-W4IPN3DD.js';
 import '../../chunk-NSBPE2FW.js';
 import { join, dirname, isAbsolute, relative } from 'path';
+import { isDeepStrictEqual } from 'util';
 import { existsSync, readFileSync, mkdirSync, writeFileSync, realpathSync, statSync } from 'fs';
 import { randomUUID } from 'crypto';
 import * as z from 'zod';
@@ -54,8 +55,8 @@ function codexPromptInput(input, cwd, skills) {
 // bridge/src/codex/native-approvals.ts
 function createCodexNativeApprovalHandlers(options) {
   const active = (signal, threadId) => !signal.aborted && isNativeApprovalPolicyActive(options.getPolicy(), threadId);
-  const text = (value) => typeof value === "string" && value.length > 0 && value.length <= 8192;
-  const scoped = async (path, access, signal, threadId) => active(signal, threadId) && text(path) && allowsNativeApprovalPath(options.getPolicy(), path, access) && active(signal, threadId);
+  const text2 = (value) => typeof value === "string" && value.length > 0 && value.length <= 8192;
+  const scoped = async (path, access, signal, threadId) => active(signal, threadId) && text2(path) && allowsNativeApprovalPath(options.getPolicy(), path, access) && active(signal, threadId);
   const permissions = async (value, signal, threadId) => {
     if (value.network?.enabled || value.network != null && Object.keys(value.network).some((key) => key !== "enabled") || Object.keys(value).some((key) => !["network", "fileSystem"].includes(key)))
       return false;
@@ -83,7 +84,7 @@ function createCodexNativeApprovalHandlers(options) {
   return {
     "item/commandExecution/requestApproval": async (input, signal) => {
       const params = structuredClone(input);
-      const allowed = async () => active(signal, params.threadId) && text(params.command) && (params.kind == null || params.kind === "command") && !params.environmentId && !params.networkApprovalContext && (params.availableDecisions == null || params.availableDecisions.includes("accept")) && await scoped(params.cwd, "read", signal, params.threadId) && (!params.additionalPermissions || await permissions(params.additionalPermissions, signal, params.threadId));
+      const allowed = async () => active(signal, params.threadId) && text2(params.command) && (params.kind == null || params.kind === "command") && !params.environmentId && !params.networkApprovalContext && (params.availableDecisions == null || params.availableDecisions.includes("accept")) && await scoped(params.cwd, "read", signal, params.threadId) && (!params.additionalPermissions || await permissions(params.additionalPermissions, signal, params.threadId));
       if (!await allowed()) return { decision: "decline" };
       const details = [`Command: ${params.command}`, `Directory: ${params.cwd}`];
       for (const access of ["read", "write"])
@@ -105,7 +106,7 @@ function createCodexNativeApprovalHandlers(options) {
         if (params.grantRoot != null && !await scoped(params.grantRoot, "write", signal, params.threadId))
           return false;
         for (const change of changes) {
-          if (!text(change.diff) || !await scoped(change.path, "write", signal, params.threadId))
+          if (!text2(change.diff) || !await scoped(change.path, "write", signal, params.threadId))
             return false;
           if (!["add", "delete", "update"].includes(change.kind.type)) return false;
           if (change.kind.type === "update" && change.kind.move_path != null && !await scoped(change.kind.move_path, "write", signal, params.threadId))
@@ -138,6 +139,48 @@ function createCodexNativeApprovalHandlers(options) {
     }
   };
 }
+
+// bridge/src/codex/native-mcp-approval.ts
+var record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var text = (value) => typeof value === "string" && value.length > 0 && Buffer.byteLength(value) <= 8192;
+function createCodexMcpApprovalHandler(options) {
+  return async (input, signal) => {
+    const decline = { action: "decline", content: null, _meta: null };
+    try {
+      const params = structuredClone(input);
+      const active = () => !signal.aborted && options.bindingActive() && isNativeApprovalPolicyActive(options.getPolicy(), params.threadId);
+      if (!active() || !text(options.serverName) || params.serverName !== options.serverName || !text(params.threadId) || !text(params.turnId) || params.mode !== "form" || !text(params.message) || Object.keys(params).some(
+        (key) => ![
+          "threadId",
+          "turnId",
+          "serverName",
+          "mode",
+          "message",
+          "requestedSchema",
+          "_meta"
+        ].includes(key)
+      ) || !record(params._meta) || params._meta.codex_approval_kind !== "mcp_tool_call" || !record(params.requestedSchema) || params.requestedSchema.type !== "object" || !record(params.requestedSchema.properties) || Object.keys(params.requestedSchema.properties).length !== 0 || Object.keys(params.requestedSchema).some(
+        (key) => !["type", "properties", "required"].includes(key)
+      ) || params.requestedSchema.required !== void 0 && (!Array.isArray(params.requestedSchema.required) || params.requestedSchema.required.length !== 0) || Buffer.byteLength(JSON.stringify(params._meta)) > 65536)
+        return decline;
+      const accepted = await options.questions.requestApproval(
+        void 0,
+        {
+          kind: "mcp",
+          details: [
+            `Configured MCP server: ${options.serverName}`,
+            params.message,
+            "This is native request presentation, not an independently verified tool identity. Tool permissions are checked again when dispatched."
+          ]
+        },
+        signal
+      );
+      return accepted && active() ? { action: "accept", content: null, _meta: null } : decline;
+    } catch {
+      return decline;
+    }
+  };
+}
 var CodexQuestions = class {
   constructor(emit) {
     this.emit = emit;
@@ -145,7 +188,7 @@ var CodexQuestions = class {
   emit;
   pending;
   request = async (params, signal) => this.park(params, signal);
-  /** Park one explicit native consent request in the same slot as ordinary questions. */
+  /** Park native consent; MCP uses only local correlation because it supplies no native item ID. */
   async requestApproval(identity, approval, signal) {
     const result = await this.park(
       {
@@ -155,7 +198,7 @@ var CodexQuestions = class {
           {
             id: "native-approval",
             header: "Approval",
-            question: approval.kind === "permissions" ? "Allow these permissions for the current turn?" : "Allow this native action once?",
+            question: approval.kind === "permissions" ? "Allow these permissions for the current turn?" : approval.kind === "mcp" ? "Allow this native MCP request once?" : "Allow this native action once?",
             options: [
               {
                 label: "Approve once",
@@ -175,7 +218,10 @@ var CodexQuestions = class {
     signal.throwIfAborted();
     if (this.pending || !params.isBlocking || !Array.isArray(params.questions) || params.questions.length === 0 || params.questions.length > 16 || params.questions.some((q) => !q.id || !q.question || q.isSecret) || new Set(params.questions.map((q) => q.id)).size !== params.questions.length || new Set(params.questions.map((q) => q.question)).size !== params.questions.length)
       throw new Error("CODEX_INPUT_UNSUPPORTED");
+    params = structuredClone(params);
+    approval = approval ? structuredClone(approval) : void 0;
     const id = randomUUID();
+    const eventId = params.itemId ?? `local-consent:${id}`;
     return new Promise((resolve, reject) => {
       const abort = () => finish();
       const finish = (result) => {
@@ -194,8 +240,8 @@ var CodexQuestions = class {
       };
       const input = {
         requestId: id,
-        questions: params.questions,
-        ...approval ? { approval } : {}
+        questions: structuredClone(params.questions),
+        ...approval ? { approval: structuredClone(approval) } : {}
       };
       signal.addEventListener("abort", abort, { once: true });
       if (signal.aborted) {
@@ -210,17 +256,18 @@ var CodexQuestions = class {
             {
               type: "tool_use",
               name: "AskUserQuestion",
-              id: params.itemId,
+              id: eventId,
               input
             }
           ]
         }
       });
+      if (this.pending?.id !== id || signal.aborted) return;
       this.emit({
         type: "tool_call",
         name: "AskUserQuestion",
         tool: { name: "AskUserQuestion" },
-        toolCallId: params.itemId,
+        toolCallId: eventId,
         input
       });
     });
@@ -243,7 +290,7 @@ var CodexQuestions = class {
 };
 
 // bridge/src/codex/managed-driver.ts
-var record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var record2 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 var failure = (code = "CODEX_RUNTIME_UNSUPPORTED") => new Error(code);
 var nativeUsage = (value) => ({
   ...typeof value.inputTokens === "number" ? { inputTokens: value.inputTokens } : {},
@@ -415,6 +462,7 @@ var ManagedCodexDriver = class extends AgentDriver {
     });
     this.instance = prepareCodexInstance(this.config, options, this.credential);
     const generation = ++this.generation;
+    const mcpReplies = /* @__PURE__ */ new WeakMap();
     this.controller = new AbortController();
     this.startupRefreshUsed = false;
     this.startupAuthAttempted = false;
@@ -475,6 +523,10 @@ var ManagedCodexDriver = class extends AgentDriver {
         requestTimeoutMs: timeout,
         serverRequestTimeoutMs: Math.min(limit(options.interactionTimeoutMs, 3e5), 3e5),
         onServerRequest: handlers,
+        canReplyToServerRequest: (method, params) => {
+          if (method !== "mcpServer/elicitation/request") return true;
+          return record2(params) && (mcpReplies.get(params)?.() ?? false);
+        },
         onNotification: (method, params) => {
           if (generation === this.generation) this.notification(method, params);
         },
@@ -510,7 +562,7 @@ var ManagedCodexDriver = class extends AgentDriver {
     } catch {
       throw failure("CODEX_REQUIRED_TOOL_UNAVAILABLE");
     }
-    if (!this.tools || !record(this.tools.mcpServers) || typeof this.tools.dispose !== "function" || Object.keys(this.tools.mcpServers).length === 0 && Object.keys(this.tools.onServerRequest ?? {}).length === 0)
+    if (!this.tools || !record2(this.tools.mcpServers) || typeof this.tools.dispose !== "function" || Object.keys(this.tools.mcpServers).length === 0 && Object.keys(this.tools.onServerRequest ?? {}).length === 0)
       throw failure("CODEX_REQUIRED_TOOL_UNAVAILABLE");
     if (this.tools.onServerRequest?.["item/tool/requestUserInput"])
       throw failure("AI_PROFILE_INVALID");
@@ -525,21 +577,40 @@ var ManagedCodexDriver = class extends AgentDriver {
         return snapshot ? JSON.parse(snapshot) : void 0;
       }
     });
+    const approvalTools = this.tools;
+    const approvalServerName = approvalTools.approvalServerName;
+    const approvalServer = approvalServerName ? approvalTools.mcpServers[approvalServerName] : void 0;
+    const approvalServerSnapshot = structuredClone(approvalServer);
+    const mcpBindingActive = () => this.tools === approvalTools && approvalTools.approvalServerName === approvalServerName && Boolean(approvalServerName) && Object.hasOwn(approvalTools.mcpServers, approvalServerName) && record2(approvalServer) && approvalTools.mcpServers[approvalServerName] === approvalServer && isDeepStrictEqual(approvalServer, approvalServerSnapshot);
+    const mcpPolicy = () => tuning.approvalPolicy === "never" ? void 0 : this.nativeApprovalPolicy;
+    const mcpApproval = createCodexMcpApprovalHandler({
+      serverName: approvalServerName,
+      questions: this.questions,
+      getPolicy: mcpPolicy,
+      bindingActive: mcpBindingActive
+    });
     for (const [method, handler] of Object.entries({
       ...this.tools.onServerRequest,
       ...nativeApprovals,
-      "item/tool/requestUserInput": this.questions.request
+      "item/tool/requestUserInput": this.questions.request,
+      "mcpServer/elicitation/request": mcpApproval
     })) {
       if (method === "account/chatgptAuthTokens/refresh" || !handler)
         throw failure("AI_PROFILE_INVALID");
       handlers[method] = async (params, signal) => {
         const active = this.active;
-        if (generation !== this.generation || !active || !record(params)) throw failure();
+        if (generation !== this.generation || !active || !record2(params)) throw failure();
         await active.ready;
         if (generation !== this.generation || this.active !== active || params.threadId !== this.threadId || params.turnId !== active.id)
           throw failure();
         const cancellation = AbortSignal.any([signal, active.controller.signal]);
         if (cancellation.aborted) throw failure();
+        if (method === "mcpServer/elicitation/request") {
+          mcpReplies.set(
+            params,
+            () => generation === this.generation && this.active === active && !cancellation.aborted && params.threadId === this.threadId && params.turnId === active.id && mcpBindingActive() && isNativeApprovalPolicyActive(mcpPolicy(), this.threadId ?? "")
+          );
+        }
         const result = await handler(params, cancellation);
         if (generation !== this.generation || cancellation.aborted || this.active !== active)
           throw failure();
@@ -571,14 +642,14 @@ var ManagedCodexDriver = class extends AgentDriver {
       ...threadParams,
       allowProviderModelFallback: false
     });
-    if (!record(response) || response.model !== this.config.model)
+    if (!record2(response) || response.model !== this.config.model)
       throw failure("CODEX_MODEL_UNAVAILABLE");
-    if (!record(response.thread) || typeof response.thread.id !== "string" || resuming && response.thread.id !== this.config.resumeSessionId || resuming && !Array.isArray(response.thread.turns) || response.reasoningEffort !== (this.config.effort ?? tuning.reasoningEffort) || response.modelProvider !== "openai" || response.approvalPolicy !== tuning.approvalPolicy)
+    if (!record2(response.thread) || typeof response.thread.id !== "string" || resuming && response.thread.id !== this.config.resumeSessionId || resuming && !Array.isArray(response.thread.turns) || response.reasoningEffort !== (this.config.effort ?? tuning.reasoningEffort) || response.modelProvider !== "openai" || response.approvalPolicy !== tuning.approvalPolicy)
       throw failure("AI_PROFILE_INVALID");
     if (generation !== this.generation || this.killed) throw failure();
     this.resumeUsageTurnIds = new Set(
       resuming && Array.isArray(response.thread.turns) ? response.thread.turns.flatMap(
-        (turn) => record(turn) && typeof turn.id === "string" ? [turn.id] : []
+        (turn) => record2(turn) && typeof turn.id === "string" ? [turn.id] : []
       ) : []
     );
     this.nativeApprovalPolicy = activateNativeApprovalPolicy(
@@ -623,7 +694,7 @@ var ManagedCodexDriver = class extends AgentDriver {
   }
   async refresh(params, signal) {
     const credential = this.credential;
-    if (!record(params) || params.reason !== "unauthorized" || !credential || credential.kind !== "codex-subscription" || params.previousAccountId != null && params.previousAccountId !== credential.chatgptAccountId || !this.options?.refreshCredential || (this.active ? this.active.refreshUsed : this.startupRefreshUsed))
+    if (!record2(params) || params.reason !== "unauthorized" || !credential || credential.kind !== "codex-subscription" || params.previousAccountId != null && params.previousAccountId !== credential.chatgptAccountId || !this.options?.refreshCredential || (this.active ? this.active.refreshUsed : this.startupRefreshUsed))
       throw failure("CODEX_AUTH_UNAVAILABLE");
     if (this.active) this.active.refreshUsed = true;
     else this.startupRefreshUsed = true;
@@ -741,7 +812,7 @@ var ManagedCodexDriver = class extends AgentDriver {
         effort: this.config.effort ?? this.config.driverOptions.codex.reasoningEffort
       });
       if (this.active !== active) return;
-      if (!record(response.turn) || typeof response.turn.id !== "string") throw failure();
+      if (!record2(response.turn) || typeof response.turn.id !== "string") throw failure();
       active.id = response.turn.id;
       active.readyNow();
       for (const event of active.events.splice(0)) this.notification(event.method, event.params);
@@ -812,7 +883,8 @@ var ManagedCodexDriver = class extends AgentDriver {
     this.pendingPatch = { ...this.pendingPatch, ...patch };
   }
   closeGeneration() {
-    ++this.generation;
+    const generation = ++this.generation;
+    const finalMcp = { ...this.mcpDiagnostics };
     this.mcpStartup = "unknown";
     this.pendingMcpStartup = void 0;
     this.controller.abort();
@@ -835,14 +907,19 @@ var ManagedCodexDriver = class extends AgentDriver {
         if (pendingClient && pendingClient !== client) await pendingClient.dispose();
         if (client && !client.terminationConfirmed || pendingClient && !pendingClient.terminationConfirmed)
           this.cleanupUncertain = true;
-        if (tools)
-          await bounded(
-            Promise.resolve().then(() => tools.dispose()),
-            new AbortController().signal,
-            1e3
-          ).catch(() => {
+        if (tools) {
+          try {
+            await bounded(
+              Promise.resolve().then(() => tools.dispose()),
+              new AbortController().signal,
+              1e3
+            );
+            if (generation === this.generation && !this.cleanupUncertain)
+              this.observeClosedMcp(tools, finalMcp);
+          } catch {
             this.cleanupUncertain = true;
-          });
+          }
+        }
       } finally {
         instance?.release();
       }
@@ -852,7 +929,7 @@ var ManagedCodexDriver = class extends AgentDriver {
     return this.closing;
   }
   notification(method, params) {
-    if (!record(params)) return;
+    if (!record2(params)) return;
     if (method === "mcpServer/startupStatus/updated") {
       const serverName = this.tools?.diagnostics?.serverName;
       if (!serverName || params.name !== serverName || typeof params.threadId !== "string" || params.threadId.length > 512 || typeof params.status !== "string" || !["starting", "ready", "failed", "cancelled"].includes(params.status))
@@ -869,7 +946,7 @@ var ManagedCodexDriver = class extends AgentDriver {
       return;
     }
     const active = this.active;
-    if ((!active || !active.usageCursor && this.resumeUsageTurnIds.has(String(params.turnId))) && method === "thread/tokenUsage/updated" && params.threadId === (this.threadId ?? this.config.resumeSessionId) && record(params.tokenUsage) && record(params.tokenUsage.total)) {
+    if ((!active || !active.usageCursor && this.resumeUsageTurnIds.has(String(params.turnId))) && method === "thread/tokenUsage/updated" && params.threadId === (this.threadId ?? this.config.resumeSessionId) && record2(params.tokenUsage) && record2(params.tokenUsage.total)) {
       this.threadUsageTotal = nativeUsage(params.tokenUsage.total);
       if (active) active.usageBaseline = this.threadUsageTotal;
       return;
@@ -883,12 +960,12 @@ var ManagedCodexDriver = class extends AgentDriver {
       } else active.events.push({ method, params });
       return;
     }
-    const turnId = record(params.turn) ? params.turn.id : params.turnId;
+    const turnId = record2(params.turn) ? params.turn.id : params.turnId;
     if (turnId !== active.id) return;
-    if (method === "thread/tokenUsage/updated" && record(params.tokenUsage)) {
+    if (method === "thread/tokenUsage/updated" && record2(params.tokenUsage)) {
       const last = params.tokenUsage.last;
       const total = params.tokenUsage.total;
-      const cumulativeUsage = record(total) ? nativeUsage(total) : void 0;
+      const cumulativeUsage = record2(total) ? nativeUsage(total) : void 0;
       if (cumulativeUsage) {
         active.usageBaseline ??= {};
         this.resumeUsageTurnIds.clear();
@@ -900,7 +977,7 @@ var ManagedCodexDriver = class extends AgentDriver {
         active.usageCursor = cumulativeUsage;
         this.threadUsageTotal = cumulativeUsage;
       }
-      if (record(last)) {
+      if (record2(last)) {
         if (typeof last.totalTokens === "number") active.contextTokens = last.totalTokens;
       }
       if (typeof params.tokenUsage.modelContextWindow === "number")
@@ -908,7 +985,7 @@ var ManagedCodexDriver = class extends AgentDriver {
     } else if (method === "model/rerouted") {
       active.actualModel = typeof params.toModel === "string" ? params.toModel : active.actualModel;
       active.failureCode = "CODEX_MODEL_UNAVAILABLE";
-    } else if (method === "turn/completed" && record(params.turn)) this.complete(params.turn);
+    } else if (method === "turn/completed" && record2(params.turn)) this.complete(params.turn);
     else if (method === "error" && params.willRetry !== true)
       active.failureCode = this.nativeErrorCode(params.error);
     else if (method === "item/agentMessage/delta" && typeof params.itemId === "string" && typeof params.delta === "string") {
@@ -918,14 +995,14 @@ var ManagedCodexDriver = class extends AgentDriver {
           type: "message_start",
           message: { role: "assistant", content: [{ type: "text", text: "" }] }
         });
-      const text = (previous ?? "") + params.delta;
-      active.messages.set(params.itemId, text);
+      const text2 = (previous ?? "") + params.delta;
+      active.messages.set(params.itemId, text2);
       this.event({
         type: "message_update",
-        message: { role: "assistant", content: [{ type: "text", text }] },
+        message: { role: "assistant", content: [{ type: "text", text: text2 }] },
         _textDelta: params.delta
       });
-    } else if ((method === "item/started" || method === "item/completed") && record(params.item) && typeof params.item.id === "string") {
+    } else if ((method === "item/started" || method === "item/completed") && record2(params.item) && typeof params.item.id === "string") {
       this.item(
         params.item,
         method === "item/completed"
@@ -1009,11 +1086,11 @@ var ManagedCodexDriver = class extends AgentDriver {
       this.finishTurn(this.active?.failureCode ?? this.nativeErrorCode(turn.error));
   }
   nativeErrorCode(error) {
-    const info = record(error) ? error.codexErrorInfo : void 0;
+    const info = record2(error) ? error.codexErrorInfo : void 0;
     if (info === "unauthorized") return "CODEX_RECONNECT_REQUIRED";
     if (info === "usageLimitExceeded" || info === "rateLimitExceeded" || info === "serverOverloaded")
       return "CODEX_RATE_LIMITED";
-    if (record(info) && [
+    if (record2(info) && [
       "httpConnectionFailed",
       "responseStreamConnectionFailed",
       "responseStreamDisconnected",
@@ -1039,9 +1116,31 @@ var ManagedCodexDriver = class extends AgentDriver {
     this.mcpDiagnostics.startupAtEnd = this.mcpStartup;
     this.mcpDiagnostics.toolsListTotal = Math.max(this.mcpDiagnostics.toolsListBeforeTurn, listed);
     this.mcpDiagnostics.toolsCallTotal = beforeTurn ? called : Math.max(this.mcpDiagnostics.toolsCallTotal, called);
+    this.publishMcp(this.mcpDiagnostics);
+  }
+  observeClosedMcp(tools, snapshot) {
+    try {
+      const counts = tools.diagnostics?.requestCounts();
+      if (!counts || ![counts.toolsListTotal, counts.toolsCallTotal].every(
+        (value) => Number.isSafeInteger(value) && value >= 0
+      ))
+        return;
+      snapshot.toolsListTotal = Math.max(
+        snapshot.toolsListTotal,
+        Math.min(512, counts.toolsListTotal)
+      );
+      snapshot.toolsCallTotal = Math.max(
+        snapshot.toolsCallTotal,
+        Math.min(512, counts.toolsCallTotal)
+      );
+      this.publishMcp(snapshot);
+    } catch {
+    }
+  }
+  publishMcp(snapshot) {
     try {
       void Promise.resolve(
-        this.options?.onNativeMcpDiagnostics?.(Object.freeze({ ...this.mcpDiagnostics }))
+        this.options?.onNativeMcpDiagnostics?.(Object.freeze({ ...snapshot }))
       ).catch(() => {
       });
     } catch {
@@ -1056,10 +1155,10 @@ var ManagedCodexDriver = class extends AgentDriver {
     active.controller.abort();
     active.fileChanges.clear();
     active.readyNow();
-    for (const text of active.messages.values())
+    for (const text2 of active.messages.values())
       this.event({
         type: "message_end",
-        message: { role: "assistant", content: [{ type: "text", text }] }
+        message: { role: "assistant", content: [{ type: "text", text: text2 }] }
       });
     this.event({ type: "turn_end", toolResults: active.toolResults });
     const modelUsage = active.usage ? {
@@ -1546,10 +1645,10 @@ var CodexDriver = class extends AgentDriver {
     });
     this.pendingToolResults = [];
   }
-  buildAssistantMessage(text) {
+  buildAssistantMessage(text2) {
     return {
       role: "assistant",
-      content: [{ type: "text", text }]
+      content: [{ type: "text", text: text2 }]
     };
   }
   toObject(value) {