@opengeni/worker-bundle 1.2.1-canary.37222177070001 → 1.3.0

package/dist/activities/codemode-dispatcher.d.ts

@@ -1,5 +1,5 @@
 import { type AttemptToolCatalogEntry, type AttemptToolEnvironment } from "@opengeni/codemode";
-import { type ToolDisplayMetadata, type ToolFamily } from "@opengeni/contracts";
+import { CodemodeOperation, type ToolDisplayMetadata, type ToolFamily } from "@opengeni/contracts";
 import { type Database } from "@opengeni/db";
 import { type EventBus } from "@opengeni/events";
 export type CodemodeDispatcherScope = {
@@ -29,6 +29,7 @@ export declare class CodemodeAttemptDispatcher {
     private readonly toolDisplayMetadata?;
     /** Content-free analytics family for a catalog entry; event enrichment only. */
     private readonly toolFamily?;
+    private readonly approvalWait?;
     private readonly stopController;
     private readonly inFlight;
     private pendingClaims;
@@ -38,8 +39,11 @@ export declare class CodemodeAttemptDispatcher {
     private readonly claimHeartbeatMs;
     constructor(db: Database, bus: EventBus, environment: AttemptToolEnvironment, scope: CodemodeDispatcherScope, turnSignal?: AbortSignal | undefined, maxConcurrentCalls?: number, timings?: CodemodeDispatcherTimings, toolDisplayMetadata?: ((modelName: string) => ToolDisplayMetadata | undefined) | undefined, 
     /** Content-free analytics family for a catalog entry; event enrichment only. */
-    toolFamily?: ((entry: AttemptToolCatalogEntry) => ToolFamily | null) | undefined);
+    toolFamily?: ((entry: AttemptToolCatalogEntry) => ToolFamily | null) | undefined, approvalWait?: {
+        beginWait(): (accepted: boolean) => void;
+    } | undefined);
     start(): void;
+    resumeApproved(callerSubjectId: string, decisionOperationId?: string): Promise<CodemodeOperation[]>;
     close(reason?: string): Promise<void>;
     private execute;
     private executeClaimed;

package/dist/activities/open-suffix-resume.d.ts

@@ -54,6 +54,8 @@ export declare function resultItemForOpenSuffixMember(input: {
     eventOutput: unknown;
 }>;
 export declare function settleOpenSuffixResumeIfNeeded(input: {
+    additionalApprovals?: unknown[];
+    programmaticApprovalAcknowledged?: boolean;
     db: Database;
     agent: Agent<any, any>;
     accountId: string;

package/dist/activities/programmatic-approvals.d.ts

@@ -0,0 +1,10 @@
+import type { CodemodeOperation } from "@opengeni/contracts";
+/** Programmatic receipts are not open SDK calls. Exact arguments stay in protected storage. */
+export declare function programmaticApproval(operation: CodemodeOperation): {
+    id: string;
+    name: string;
+    source: "codemode";
+    operationId: string;
+    requestId: string | undefined;
+};
+export declare function programmaticContinuationNote(operations: readonly CodemodeOperation[]): string | undefined;

package/dist/activities/run-input.d.ts

@@ -32,6 +32,8 @@ export type TurnInputOptions = {
     unavailableSandboxFilesNote?: string;
     runCredentialsNote?: string;
     mcpAvailabilityNote?: string;
+    codemodeContinuationNote?: string;
+    programmaticApprovalAcknowledged?: boolean;
     knowledgeSourcePreparationNote?: string;
     providerApi: HistoryProviderApi;
     projectCanonicalHistory?: ModelHistoryAttachmentProjector;

package/dist/{activities-control-QSDPXLLD.js → activities-control-PEXBWKQJ.js}

@@ -34,7 +34,7 @@ import {
   warnDrainSnapshotFailure,
   withFirstPartyTools,
   workflowIdForSession
-} from "./chunk-JKMG5ZHH.js";
+} from "./chunk-QUX5LT2B.js";
 import {
   inspectOpenSandboxKubernetesInventory,
   recordActiveUserGauges,
@@ -8813,4 +8813,4 @@ export {
   createControlActivities,
   createControlActivitiesFromServices
 };
-//# sourceMappingURL=activities-control-QSDPXLLD.js.map
+//# sourceMappingURL=activities-control-PEXBWKQJ.js.map

package/dist/{activities-turn-BMY3CDKL.js → activities-turn-W27A2SBO.js}

@@ -99,7 +99,7 @@ import {
   withFirstPartyTools,
   wrapLazyTurnBoxWithRouting,
   wrapTurnBoxWithRouting
-} from "./chunk-JKMG5ZHH.js";
+} from "./chunk-QUX5LT2B.js";
 import {
   StreamTimingMetrics,
   makeMachineOpObserver,
@@ -7654,6 +7654,7 @@ import {
   sessionTurnHasFinalReplyNudge,
   getSessionHumanInputRequest,
   getWorkspace,
+  listTurnCodemodeApprovals,
   recordUsageEvent as recordUsageEvent3,
   registerPendingSessionToolCall,
   recordPendingSessionToolCallResult as recordPendingSessionToolCallResult2,
@@ -8080,6 +8081,27 @@ async function retentionTokenCounts(items, project2) {
   return counts;
 }
 
+// src/activities/programmatic-approvals.ts
+function programmaticApproval(operation) {
+  return {
+    id: operation.operationId,
+    name: operation.identity.toolName,
+    source: "codemode",
+    operationId: operation.operationId,
+    requestId: operation.approvalRequestId
+  };
+}
+function programmaticContinuationNote(operations) {
+  if (operations.length === 0) return void 0;
+  return [
+    "Stored programmatic operations (durable server receipts):",
+    ...operations.map(
+      (operation) => `${operation.operationId}: ${operation.state}${operation.errorCode ? ` (${operation.errorCode})` : ""}`
+    ),
+    "Approval resumes the stored operation, not the earlier program's JavaScript stack. Read results with the current Codemode client's status/resume handle. Do not resubmit arguments for completed, running, waiting, or uncertain operations."
+  ].join("\n");
+}
+
 // src/activities/agent-turn/turn-sandbox-access.ts
 function ownedTurnSandboxForAgent(sandboxState) {
   return sandboxState.lazyOwnedSandbox ?? sandboxState.resolvedSandbox?.established;
@@ -8263,7 +8285,7 @@ async function resultItemForOpenSuffixMember(input) {
   }
 }
 async function settleOpenSuffixResumeIfNeeded(input) {
-  if (input.trigger.type !== "user.approvalDecision" && input.trigger.type !== "user.humanInputResponse") {
+  if (input.trigger.type !== "user.approvalDecision" && input.trigger.type !== "user.humanInputResponse" && !input.additionalApprovals?.length) {
     return { action: "continue" };
   }
   const rows = await listTurnOpenSuffixToolCalls(
@@ -8272,7 +8294,7 @@ async function settleOpenSuffixResumeIfNeeded(input) {
     input.sessionId,
     input.turnId
   );
-  if (rows.length === 0) {
+  if (rows.length === 0 && !input.additionalApprovals?.length) {
     return { action: "continue" };
   }
   const callId = matchingOpenSuffixCallId({
@@ -8280,96 +8302,108 @@ async function settleOpenSuffixResumeIfNeeded(input) {
     humanInputToolCallId: input.humanInputResume?.toolCallId
   });
   const target = resolveOpenSuffixResumeTarget(rows, callId);
-  if (!target || !callId) {
+  if ((!target || !callId) && !input.programmaticApprovalAcknowledged && (input.trigger.type === "user.approvalDecision" || input.trigger.type === "user.humanInputResponse" || !input.additionalApprovals?.length)) {
     throw new Error("Open suffix resume event does not match an interruption");
   }
-  const truncationTokens = input.modelToolOutputTruncationTokens ?? target.modelToolOutputTruncationTokens ?? void 0;
-  let resultItem = target.resultItem;
-  let eventOutput = resultItem?.output;
-  if (!resultItem) {
-    const member = await resultItemForOpenSuffixMember({
-      agent: input.agent,
-      row: target,
-      trigger: input.trigger,
-      humanInputResume: input.humanInputResume
-    });
-    resultItem = member.resultItem;
-    eventOutput = member.eventOutput;
-    const recorded = await recordPendingSessionToolCallResult(input.db, {
-      accountId: input.accountId,
-      workspaceId: input.workspaceId,
-      sessionId: input.sessionId,
-      turnId: input.turnId,
-      executionGeneration: input.executionGeneration,
-      attemptId: input.attemptId,
-      callId: target.callId,
-      ...truncationTokens !== void 0 ? { modelToolOutputTruncationTokens: truncationTokens } : {},
-      resultItem,
-      eventOutput
-    });
-    if (!recorded.accepted) {
-      return { action: "cancelled" };
-    }
-    if (!recorded.recorded) {
-      const latest = resolveOpenSuffixResumeTarget(
-        await listTurnOpenSuffixToolCalls(
-          input.db,
-          input.workspaceId,
-          input.sessionId,
-          input.turnId
-        ),
-        callId
-      );
-      resultItem = latest?.resultItem ?? resultItem;
-    } else if (input.publish) {
-      await input.publish([
-        {
-          type: "agent.toolCall.output",
-          payload: { id: target.callId, output: eventOutput }
-        }
-      ]);
+  if (target && callId) {
+    const truncationTokens = input.modelToolOutputTruncationTokens ?? target.modelToolOutputTruncationTokens ?? void 0;
+    let resultItem = target.resultItem;
+    let eventOutput = resultItem?.output;
+    if (!resultItem) {
+      const member = await resultItemForOpenSuffixMember({
+        agent: input.agent,
+        row: target,
+        trigger: input.trigger,
+        humanInputResume: input.humanInputResume
+      });
+      resultItem = member.resultItem;
+      eventOutput = member.eventOutput;
+      const recorded = await recordPendingSessionToolCallResult(input.db, {
+        accountId: input.accountId,
+        workspaceId: input.workspaceId,
+        sessionId: input.sessionId,
+        turnId: input.turnId,
+        executionGeneration: input.executionGeneration,
+        attemptId: input.attemptId,
+        callId: target.callId,
+        ...truncationTokens !== void 0 ? { modelToolOutputTruncationTokens: truncationTokens } : {},
+        resultItem,
+        eventOutput
+      });
+      if (!recorded.accepted) {
+        return { action: "cancelled" };
+      }
+      if (!recorded.recorded) {
+        const latest = resolveOpenSuffixResumeTarget(
+          await listTurnOpenSuffixToolCalls(
+            input.db,
+            input.workspaceId,
+            input.sessionId,
+            input.turnId
+          ),
+          callId
+        );
+        resultItem = latest?.resultItem ?? resultItem;
+      } else if (input.publish) {
+        await input.publish([
+          {
+            type: "agent.toolCall.output",
+            payload: { id: target.callId, output: eventOutput }
+          }
+        ]);
+      }
     }
-  }
-  if (!resultItem) {
-    throw new Error(`Open suffix resume for ${target.callId} has no result item`);
-  }
-  const history = await getActiveSessionHistoryItems(input.db, input.workspaceId, input.sessionId);
-  if (!openSuffixPairPresentInHistory(
-    history.map((row) => row.item),
-    callId
-  )) {
-    const historyItems = openSuffixHistoryItems(target, resultItem);
-    if (historyItems.length === 0) {
-      throw new Error(`Open suffix resume for ${target.callId} produced no paired history`);
+    if (!resultItem) {
+      throw new Error(`Open suffix resume for ${target.callId} has no result item`);
     }
-    const nextPosition = await nextSessionHistoryPosition(
+    const history = await getActiveSessionHistoryItems(
       input.db,
       input.workspaceId,
       input.sessionId
     );
-    const appended = await appendSessionHistoryItems2(input.db, {
-      accountId: input.accountId,
-      workspaceId: input.workspaceId,
-      sessionId: input.sessionId,
-      turnId: input.turnId,
-      expectedExecutionGeneration: input.executionGeneration,
-      expectedAttemptId: input.attemptId,
-      ...truncationTokens !== void 0 ? { modelToolOutputTruncationTokens: truncationTokens } : {},
-      items: historyItems.map((item, offset) => ({
-        position: nextPosition + offset,
-        item
-      }))
-    });
-    if (!appended) {
-      return { action: "cancelled" };
+    if (!openSuffixPairPresentInHistory(
+      history.map((row) => row.item),
+      callId
+    )) {
+      const historyItems = openSuffixHistoryItems(target, resultItem);
+      if (historyItems.length === 0) {
+        throw new Error(`Open suffix resume for ${target.callId} produced no paired history`);
+      }
+      const nextPosition = await nextSessionHistoryPosition(
+        input.db,
+        input.workspaceId,
+        input.sessionId
+      );
+      const appended = await appendSessionHistoryItems2(input.db, {
+        accountId: input.accountId,
+        workspaceId: input.workspaceId,
+        sessionId: input.sessionId,
+        turnId: input.turnId,
+        expectedExecutionGeneration: input.executionGeneration,
+        expectedAttemptId: input.attemptId,
+        ...truncationTokens !== void 0 ? { modelToolOutputTruncationTokens: truncationTokens } : {},
+        items: historyItems.map((item, offset) => ({
+          position: nextPosition + offset,
+          item
+        }))
+      });
+      if (!appended) {
+        return { action: "cancelled" };
+      }
     }
   }
   const remaining = (await listTurnOpenSuffixToolCalls(input.db, input.workspaceId, input.sessionId, input.turnId)).filter((row) => row.resultItem == null);
-  if (remaining.length === 0) {
+  if (remaining.length === 0 && !input.additionalApprovals?.length) {
     return { action: "continue" };
   }
-  const requiresActionApprovals = remainingPendingApprovalsFromSuffix(remaining);
-  const pendingApprovals = remainingRunStatePendingApprovalsFromSuffix(remaining);
+  const requiresActionApprovals = [
+    ...remainingPendingApprovalsFromSuffix(remaining),
+    ...input.additionalApprovals ?? []
+  ];
+  const pendingApprovals = [
+    ...remainingRunStatePendingApprovalsFromSuffix(remaining),
+    ...input.additionalApprovals ?? []
+  ];
   const settled = await input.settle({
     events: [
       ...requiresActionApprovals.length > 0 ? [
@@ -8997,6 +9031,8 @@ async function runTurnStreamAttempt(deps) {
     await parallelSessionTitle?.cancel();
   };
   let runInput = null;
+  let codemodeContinuationNote;
+  let programmaticApprovalAcknowledged = false;
   const prepareRunAttemptInput = async () => {
     const historyPreparationStartedAt = performance.now();
     let historyPreparationOutcome = "completed";
@@ -9009,6 +9045,8 @@ async function runTurnStreamAttempt(deps) {
           subjectId: fileAuthoritySubjectId
         },
         recovering: turn.executionGeneration > 1,
+        programmaticApprovalAcknowledged,
+        ...codemodeContinuationNote ? { codemodeContinuationNote } : {},
         ...unavailableSandboxFilesNote ? { unavailableSandboxFilesNote } : {},
         ...runCredentialsNote ? { runCredentialsNote } : {},
         ...mcpAvailabilityNote ? { mcpAvailabilityNote } : {},
@@ -9967,10 +10005,17 @@ async function runTurnStreamAttempt(deps) {
         });
       }
     }
-    if (eventing.stream.interruptions.length > 0) {
+    const programmaticPending = (await listTurnCodemodeApprovals(db, {
+      accountId: input.accountId,
+      workspaceId: input.workspaceId,
+      sessionId: input.sessionId,
+      turnId: activeTurnId
+    })).filter((operation) => operation.state === "waiting_for_approval").map(programmaticApproval);
+    if (eventing.stream.interruptions.length > 0 || programmaticPending.length > 0) {
       await eventing.preparedTools?.inputWaitYield?.sealForSettlement(runtimeCancellationSignal);
       await historySink.reconcileConversationTruth({ requireDurable: true });
-      const approvals = runtime.serializeApprovals(eventing.stream.interruptions);
+      const sdkApprovals = runtime.serializeApprovals(eventing.stream.interruptions);
+      const approvals = [...sdkApprovals, ...programmaticPending];
       const humanInputInterruptions = runtime.serializeHumanInputRequests?.(eventing.stream.interruptions) ?? [];
       const interactionInterventionInterruptions = runtime.serializeInteractionInterventionRequests?.(eventing.stream.interruptions) ?? [];
       const latestWorkspace = await getWorkspace(db, input.workspaceId);
@@ -10042,11 +10087,14 @@ async function runTurnStreamAttempt(deps) {
       const interruptionCallIds = interruptionCallIdsFromPause({
         humanInputRequests,
         interactionInterventionRequests,
-        pendingApprovals
+        pendingApprovals: [
+          ...sdkApprovals,
+          ...interactionInterventionInterruptions.map((interruption) => interruption.approval)
+        ]
       });
       assertOpenSuffixResumable(suffixMembers, interruptionCallIds);
       const suffixByCallId = new Map(suffixMembers.map((member) => [member.callId, member]));
-      const attached = await attachOpenSuffixToPendingToolCalls(db, {
+      const attached = interruptionCallIds.length === 0 ? { accepted: true } : await attachOpenSuffixToPendingToolCalls(db, {
         accountId: input.accountId,
         workspaceId: input.workspaceId,
         sessionId: input.sessionId,
@@ -10203,7 +10251,19 @@ async function runTurnStreamAttempt(deps) {
     control.activityStatus = "idle";
     return claimedResult({ status: "idle" });
   };
+  await eventing.toolPreparationReady;
+  const codemodeOperations = await eventing.codemodeDispatcher?.resumeApproved(
+    `sandbox:${input.attemptId}`,
+    trigger.type === "user.approvalDecision" ? trigger.payload.approvalId : void 0
+  ) ?? [];
+  codemodeContinuationNote = programmaticContinuationNote(codemodeOperations);
+  programmaticApprovalAcknowledged = trigger.type === "user.approvalDecision" && codemodeOperations.some(
+    (operation) => operation.operationId === trigger.payload.approvalId
+  );
+  const pendingProgrammaticApprovals = codemodeOperations.filter((operation) => operation.state === "waiting_for_approval").map(programmaticApproval);
   const openSuffixResume = await settleOpenSuffixResumeIfNeeded({
+    additionalApprovals: pendingProgrammaticApprovals,
+    programmaticApprovalAcknowledged,
     db,
     agent,
     accountId: input.accountId,
@@ -12486,9 +12546,8 @@ function modelSupportsImageInputForTurn(resolvedModel) {
   return resolvedModel === null || resolvedModel.configured.capabilities?.inputModalities.includes("image") !== false;
 }
 function modelAttachmentInputPolicyForTurn(resolvedModel) {
-  const typedTransport = resolvedModel === null || resolvedModel.provider.api === "responses" || resolvedModel.provider.api === "anthropic-messages";
   return {
-    supportsImageInput: typedTransport && modelSupportsImageInputForTurn(resolvedModel),
+    supportsImageInput: modelSupportsImageInputForTurn(resolvedModel),
     inputFileMediaTypes: []
   };
 }
@@ -32894,7 +32953,12 @@ import { allowedFirstPartyMcpToolsForSession } from "@opengeni/config";
 
 // src/activities/codemode-dispatcher.ts
 import { randomUUID as randomUUID3 } from "crypto";
-import { bindMcpTelemetry, measureMcpPhase as measureMcpPhase2, withMcpCallIdentity as withMcpCallIdentity2 } from "@opengeni/observability";
+import {
+  bindMcpTelemetry,
+  measureMcpPhase as measureMcpPhase2,
+  withMcpCallIdentity as withMcpCallIdentity2,
+  recordToolApproval
+} from "@opengeni/observability";
 import {
   AttemptToolApprovalRequiredError,
   AttemptToolCatalogStaleError,
@@ -32907,10 +32971,16 @@ import {
 import {
   CODEMODE_CLAIM_LEASE_MS,
   CODEMODE_CLAIM_HEARTBEAT_MS,
-  CODEMODE_MAX_CONCURRENT_CALLS_PER_ATTEMPT
+  CODEMODE_MAX_CONCURRENT_CALLS_PER_ATTEMPT,
+  CodemodeOperation
 } from "@opengeni/contracts";
 import {
   cancelQueuedCodemodeOperationsForAttempt,
+  waitForCodemodeApproval,
+  bindCodemodePreparation,
+  listTurnCodemodeApprovals as listTurnCodemodeApprovals2,
+  adoptCodemodeApprovalWithOutput,
+  readTurnCodemodeOperation,
   claimCodemodeOperation,
   failCodemodeOperation,
   getSessionEventByClientEventId,
@@ -32924,7 +32994,7 @@ import {
   publishDurableSessionEvents as publishDurableSessionEvents8
 } from "@opengeni/events";
 var CodemodeAttemptDispatcher = class {
-  constructor(db, bus, environment, scope, turnSignal, maxConcurrentCalls = CODEMODE_MAX_CONCURRENT_CALLS_PER_ATTEMPT, timings = {}, toolDisplayMetadata, toolFamily) {
+  constructor(db, bus, environment, scope, turnSignal, maxConcurrentCalls = CODEMODE_MAX_CONCURRENT_CALLS_PER_ATTEMPT, timings = {}, toolDisplayMetadata, toolFamily, approvalWait) {
     this.db = db;
     this.bus = bus;
     this.environment = environment;
@@ -32933,6 +33003,7 @@ var CodemodeAttemptDispatcher = class {
     this.maxConcurrentCalls = maxConcurrentCalls;
     this.toolDisplayMetadata = toolDisplayMetadata;
     this.toolFamily = toolFamily;
+    this.approvalWait = approvalWait;
     if (environment.catalog.accountId !== scope.accountId || environment.catalog.workspaceId !== scope.workspaceId || environment.catalog.sessionId !== scope.sessionId || environment.catalog.turnId !== scope.turnId || environment.catalog.attemptId !== scope.attemptId || environment.catalog.executionGeneration !== scope.executionGeneration) {
       throw new Error("Codemode dispatcher scope does not match its tool environment");
     }
@@ -33022,6 +33093,76 @@ var CodemodeAttemptDispatcher = class {
       })
     );
   }
+  async resumeApproved(callerSubjectId, decisionOperationId) {
+    const operations = await listTurnCodemodeApprovals2(this.db, this.scope);
+    if (decisionOperationId && // Model-tool approval IDs are opaque strings. Only programmatic UUIDs
+    // can address the Codemode operation journal.
+    CodemodeOperation.shape.operationId.safeParse(decisionOperationId).success && !operations.some((operation) => operation.operationId === decisionOperationId)) {
+      const decided = await readTurnCodemodeOperation(this.db, {
+        ...this.scope,
+        callerSubjectId,
+        operationId: decisionOperationId
+      });
+      if (decided) operations.push(decided);
+    }
+    for (const operation of operations) {
+      if (!["waiting_for_approval", "queued", "running"].includes(operation.state)) continue;
+      let effectDigest = null;
+      try {
+        effectDigest = this.environment.effectDigest(operation.identity);
+      } catch {
+      }
+      const continuation = await adoptCodemodeApprovalWithOutput(this.db, {
+        ...this.scope,
+        operationId: operation.operationId,
+        callerSubjectId,
+        catalogDigest: this.environment.catalog.digest,
+        effectDigest
+      });
+      await publishDurableSessionEvents8(
+        this.bus,
+        this.scope.workspaceId,
+        this.scope.sessionId,
+        continuation.events
+      );
+      const adopted = continuation.operation;
+      if (adopted && adopted.state !== operation.state) {
+        const outcome = adopted.state === "queued" ? "resumed" : adopted.state === "outcome_unknown" ? "unknown" : adopted.errorCode === "approval_stale" ? "stale" : "rejected";
+        recordToolApproval(
+          outcome,
+          "continuation",
+          operation.state === "waiting_for_approval" ? Math.max(0, Date.now() - Date.parse(operation.updatedAt)) : void 0
+        );
+      }
+      if (adopted?.state !== "queued") continue;
+      const claim = await claimCodemodeOperation(this.db, {
+        ...this.scope,
+        operationId: adopted.operationId,
+        claimId: randomUUID3(),
+        catalogDigest: this.environment.catalog.digest,
+        claimLeaseMs: this.claimLeaseMs
+      });
+      if (claim.status === "claimed") {
+        const execution = this.execute(claim.operation, claim.claimId, true);
+        this.inFlight.set(adopted.operationId, execution);
+        try {
+          await execution;
+        } finally {
+          this.inFlight.delete(adopted.operationId);
+        }
+      }
+    }
+    const receipts = [];
+    for (const operation of operations) {
+      const receipt = await readTurnCodemodeOperation(this.db, {
+        ...this.scope,
+        callerSubjectId,
+        operationId: operation.operationId
+      });
+      if (receipt) receipts.push(receipt);
+    }
+    return receipts;
+  }
   async close(reason = "Execution attempt ended") {
     if (this.closing) {
       await Promise.allSettled([...this.inFlight.values()]);
@@ -33102,18 +33243,51 @@ var CodemodeAttemptDispatcher = class {
       return;
     }
     let preparedCall;
+    let releaseWait;
     try {
+      if (operation.durableApproval) {
+        if (!this.approvalWait) throw new Error("Durable approval yield is unavailable");
+        releaseWait = this.approvalWait.beginWait();
+        if (!await bindCodemodePreparation(this.db, {
+          ...this.scope,
+          operationId: operation.operationId,
+          claimId,
+          effectDigest: this.environment.effectDigest(operation.identity)
+        }))
+          throw new Error("Operation preparation is stale");
+      }
       preparedCall = await this.environment.prepareCall(
         {
           operationId: operation.operationId,
-          catalogDigest: operation.catalogDigest,
+          catalogDigest: this.environment.catalog.digest,
           identity: operation.identity,
           arguments: operation.arguments,
-          caller: operation.caller
+          caller: {
+            kind: "codemode",
+            subjectId: operation.caller.subjectId === `sandbox:${operation.attemptId}` ? `sandbox:${this.scope.attemptId}` : operation.caller.subjectId
+          }
         },
-        { signal }
+        {
+          signal,
+          ...operation.durableApproval ? { transportMeta: { durableApproval: true } } : {}
+        }
       );
+      if (preparedCall.waitingForApproval) {
+        const waiting = await waitForCodemodeApproval(this.db, {
+          ...this.scope,
+          operationId: operation.operationId,
+          claimId,
+          ...preparedCall.waitingForApproval,
+          effectDigest: preparedCall.effectDigest
+        });
+        if (!waiting) throw new Error("Approval could not be bound to the operation");
+        recordToolApproval("waiting");
+        releaseWait?.(true);
+        return;
+      }
+      releaseWait?.(false);
     } catch (error51) {
+      releaseWait?.(false);
       await this.settleWithOutput(operation, claimId, {
         state: "failed",
         errorCode: errorCode(error51, signal, false),
@@ -33244,6 +33418,7 @@ var CodemodeAttemptDispatcher = class {
       settlement
     });
     if (!result.committed || result.events.length === 0) return;
+    recordToolApproval(settlement.state === "outcome_unknown" ? "unknown" : settlement.state);
     await publishDurableSessionEvents8(
       this.bus,
       this.scope.workspaceId,
@@ -33270,7 +33445,7 @@ function codemodeToolCallCreatedClientEventId(operationId) {
 function assertMatchingCodemodeToolCallCreated(event, operation, entry, scope) {
   const payload = recordValue(event.payload);
   const raw = recordValue(payload?.raw);
-  if (event.type !== "agent.toolCall.created" || event.turnId !== scope.turnId || event.turnGeneration !== scope.executionGeneration || event.turnAttemptId !== scope.attemptId || event.turnAssociation !== "current" || payload?.id !== operation.operationId || payload?.name !== entry.modelName || payload?.origin !== "codemode" || payload?.subjectId !== operation.caller.subjectId || raw?.type !== "codemode_call" || raw?.serverId !== operation.identity.serverId || raw?.toolName !== operation.identity.toolName || raw?.catalogDigest !== operation.catalogDigest) {
+  if (event.type !== "agent.toolCall.created" || event.turnId !== scope.turnId || event.turnGeneration !== operation.executionGeneration || event.turnAttemptId !== operation.attemptId || event.turnAssociation !== "current" || payload?.id !== operation.operationId || payload?.name !== entry.modelName || payload?.origin !== "codemode" || payload?.subjectId !== operation.caller.subjectId || raw?.type !== "codemode_call" || raw?.serverId !== operation.identity.serverId || raw?.toolName !== operation.identity.toolName || raw?.catalogDigest !== operation.catalogDigest) {
     throw new Error("Codemode tool-call creation id is bound to incompatible durable evidence");
   }
 }
@@ -35634,7 +35809,8 @@ async function prepareTurnToolRuntime(deps) {
       void 0,
       {},
       (name) => mcpToolDisplayMetadata(tools.mcpServers, name),
-      (entry) => toolFamilyForCatalogIdentity(entry, runSettings.mcpServers)
+      (entry) => toolFamilyForCatalogIdentity(entry, runSettings.mcpServers),
+      tools.inputWaitYield
     );
     eventing.codemodeDispatcher.start();
   };
@@ -37668,8 +37844,8 @@ async function buildTurnAgent(deps) {
           // tool. Gateway Responses routes likewise expose ordinary function
           // tools, not OpenAI-hosted sandbox tools. Tell buildAgent to use
           // function apply_patch and wrap successful view_image results as
-          // typed input_image content. Chat wires have no proven typed image
-          // result transport and therefore receive no view_image tool.
+          // typed input_image content. The Chat adapter projects tool images
+          // into a labelled image envelope after the paired tool results.
           structuredToolTransport: structuredToolTransportForTurn(resolvedModel),
           ...promptCacheKey ? { promptCacheKey } : {}
         } : (
@@ -40507,4 +40683,4 @@ export {
   createTurnActivities,
   createTurnActivitiesFromServices
 };
-//# sourceMappingURL=activities-turn-BMY3CDKL.js.map
+//# sourceMappingURL=activities-turn-W27A2SBO.js.map