@opengeni/worker-bundle 1.2.1-canary.37222965366001 → 1.4.0

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

@@ -99,7 +99,7 @@ import {
   withFirstPartyTools,
   wrapLazyTurnBoxWithRouting,
   wrapTurnBoxWithRouting
-} from "./chunk-JKMG5ZHH.js";
+} from "./chunk-BMTWULF7.js";
 import {
   StreamTimingMetrics,
   makeMachineOpObserver,
@@ -132,7 +132,7 @@ import {
   runtimeMetricsHooksForObservability,
   sandboxAutomaticRecoveryOutcome,
   turnLifecycleMetricsFor
-} from "./chunk-XONQEVAD.js";
+} from "./chunk-FF4HPY7L.js";
 import {
   __export
 } from "./chunk-PZ5AY32C.js";
@@ -1193,12 +1193,14 @@ import {
 } from "@opengeni/db";
 
 // src/activities/agent-turn/subscription-lease.ts
+var HEARTBEAT_INTERVAL_MS = 6e4;
 var SubscriptionTurnLease = class {
   constructor(leaseDeps) {
     this.leaseDeps = leaseDeps;
     if (!Number.isFinite(leaseDeps.ttlMs) || leaseDeps.ttlMs <= 0)
       throw new Error("Subscription lease TTL must be positive");
     this.now = leaseDeps.now ?? (() => performance.now());
+    this.renewalIntervalMs = Math.min(HEARTBEAT_INTERVAL_MS, leaseDeps.ttlMs / 5);
   }
   held = false;
   lost = false;
@@ -1209,6 +1211,7 @@ var SubscriptionTurnLease = class {
   heartbeatInFlight = false;
   heartbeatTimer;
   now;
+  renewalIntervalMs;
   expired = (deadline) => deadline === null || !Number.isFinite(deadline) || this.now() >= deadline;
   markLost = (reason) => {
     if (this.lost) return;
@@ -1231,6 +1234,8 @@ var SubscriptionTurnLease = class {
       return;
     }
     if (this.heartbeatInFlight) return;
+    const renewAt = this.confirmedUntilMs - this.leaseDeps.ttlMs + this.renewalIntervalMs;
+    if (this.now() < renewAt) return;
     this.heartbeatInFlight = true;
     const priorDeadline = this.confirmedUntilMs;
     const startedAt = this.now();
@@ -1257,7 +1262,7 @@ var SubscriptionTurnLease = class {
   };
   startHeartbeat = () => {
     if (!this.leaseDeps.getTurnId() || this.heartbeatTimer) return;
-    this.heartbeatTimer = setInterval(() => void this.renew("timer"), 6e4);
+    this.heartbeatTimer = setInterval(() => void this.renew("timer"), HEARTBEAT_INTERVAL_MS);
     this.heartbeatTimer.unref?.();
   };
   stopHeartbeat = () => {
@@ -7654,6 +7659,7 @@ import {
   sessionTurnHasFinalReplyNudge,
   getSessionHumanInputRequest,
   getWorkspace,
+  listTurnCodemodeApprovals,
   recordUsageEvent as recordUsageEvent3,
   registerPendingSessionToolCall,
   recordPendingSessionToolCallResult as recordPendingSessionToolCallResult2,
@@ -8080,6 +8086,34 @@ 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");
+}
+async function recoverProgrammaticOperationsBeforeFirstRequest(input) {
+  if (input.approvalDecisionId === void 0 && !await input.hasUnfinishedOperations()) {
+    return [];
+  }
+  await input.toolPreparationReady;
+  return await input.resumeApproved(input.approvalDecisionId) ?? [];
+}
+
 // src/activities/agent-turn/turn-sandbox-access.ts
 function ownedTurnSandboxForAgent(sandboxState) {
   return sandboxState.lazyOwnedSandbox ?? sandboxState.resolvedSandbox?.established;
@@ -8263,7 +8297,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 +8306,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 +8314,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 +9043,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 +9057,8 @@ async function runTurnStreamAttempt(deps) {
           subjectId: fileAuthoritySubjectId
         },
         recovering: turn.executionGeneration > 1,
+        programmaticApprovalAcknowledged,
+        ...codemodeContinuationNote ? { codemodeContinuationNote } : {},
         ...unavailableSandboxFilesNote ? { unavailableSandboxFilesNote } : {},
         ...runCredentialsNote ? { runCredentialsNote } : {},
         ...mcpAvailabilityNote ? { mcpAvailabilityNote } : {},
@@ -9967,10 +10017,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 +10099,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 +10263,41 @@ async function runTurnStreamAttempt(deps) {
     control.activityStatus = "idle";
     return claimedResult({ status: "idle" });
   };
+  const programmaticRecoveryStartedAt = performance.now();
+  let programmaticRecoveryOutcome = "failed";
+  const codemodeOperations = await recoverProgrammaticOperationsBeforeFirstRequest({
+    approvalDecisionId: trigger.type === "user.approvalDecision" ? trigger.payload.approvalId : void 0,
+    hasUnfinishedOperations: async () => (await listTurnCodemodeApprovals(db, {
+      accountId: input.accountId,
+      workspaceId: input.workspaceId,
+      sessionId: input.sessionId,
+      turnId: activeTurnId
+    })).length > 0,
+    toolPreparationReady: eventing.toolPreparationReady,
+    resumeApproved: (decisionOperationId) => eventing.codemodeDispatcher?.resumeApproved(
+      `sandbox:${input.attemptId}`,
+      decisionOperationId
+    )
+  }).then((operations) => {
+    programmaticRecoveryOutcome = "completed";
+    return operations;
+  }).finally(() => {
+    recordTurnStartupPhase(observability, {
+      phase: "programmatic_operation_recovery",
+      provider: turnExecutionPolicy.providerId,
+      backend: activeSandboxBackend ?? groupBoxBackend,
+      outcome: programmaticRecoveryOutcome,
+      durationSeconds: (performance.now() - programmaticRecoveryStartedAt) / 1e3
+    });
+  });
+  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,
@@ -12187,6 +12281,7 @@ import {
   desktopCapableBackend
 } from "@opengeni/runtime";
 import {
+  configuredModelForAcceptedTurnExecutionPolicy,
   isDirectOpenAiApiBaseUrl
 } from "@opengeni/config";
 
@@ -12463,6 +12558,16 @@ function shouldDeferNonEagerToolPreparation(args) {
     args.lazyToolTransport && args.progressiveDisclosureEnabled && args.triggerKind === "next" && (args.triggerType === "user.message" || args.triggerType === "system.update.delivered")
   );
 }
+function resolveAcceptedTurnModel(runtime, settings, policy) {
+  const current = runtime.resolveTurnModel(settings, policy.productModelId);
+  if (!current) return null;
+  const configured = configuredModelForAcceptedTurnExecutionPolicy(
+    current.configured,
+    current.provider,
+    policy
+  );
+  return configured === current.configured ? current : { ...current, configured };
+}
 function hostedWebSearchForTurn(resolvedModel, deploymentWebSearchEnabled) {
   return resolvedModel?.configured.hostedWebSearch ?? deploymentWebSearchEnabled;
 }
@@ -12486,9 +12591,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: []
   };
 }
@@ -12654,10 +12758,7 @@ async function prepareGovernanceAndModel(deps) {
       baseRunSettings
     )
   );
-  const resolvedModel = runtime.resolveTurnModel(
-    capabilitySettings,
-    turnExecutionPolicy.productModelId
-  );
+  const resolvedModel = resolveAcceptedTurnModel(runtime, capabilitySettings, turnExecutionPolicy);
   const providerApi = resolvedModel?.provider.api ?? "responses";
   const nativeImageProviderBinding = providerApi === "responses" ? openAiHostedImageProviderBindingForTurn(capabilitySettings, resolvedModel) : null;
   const lazyToolTransport = lazyToolTransportForTurn(resolvedModel);
@@ -13417,6 +13518,7 @@ import {
   readLease as readLease2,
   accrueWarmSeconds,
   SandboxWorkspaceMutationFencedError,
+  SandboxWorkspaceMutationOutputRejectedError,
   retainWorkspaceMutationProcess,
   retainedProviderCommandPersistence,
   SandboxRetainedProcessPromotionFencedError
@@ -13424,6 +13526,7 @@ import {
 import { createProviderCommandRetainer } from "@opengeni/db/retained-provider-commands";
 import {
   RoutingMutationOutcomeUnknownError,
+  RoutingMutationOutputRejectedError,
   ProviderCommandStartOutcomeUnknownError,
   ProviderCommandObservationUnavailableError,
   isModalCommandStartOutcomeUnknownError as isModalCommandStartOutcomeUnknownError2,
@@ -13836,6 +13939,17 @@ function createSandboxTurnRuntime(deps) {
     try {
       await settleMutation("resolved");
     } catch (settlementError) {
+      if (settlementError instanceof SandboxWorkspaceMutationOutputRejectedError && settlementError.matchesPhysicalSettlement({
+        accountId: identity.accountId,
+        workspaceId: identity.workspaceId,
+        admission,
+        operation,
+        outcome: "resolved"
+      })) {
+        throw new RoutingMutationOutputRejectedError(operation, settlementError.code, {
+          cause: settlementError
+        });
+      }
       throw new RoutingMutationOutcomeUnknownError(
         operation,
         `Platform workspace mutation "${operation}" returned from the provider but lost its durable settlement fence; its outcome is unknown and it was not replayed`,
@@ -32710,7 +32824,8 @@ import {
 } from "@opengeni/runtime";
 import {
   ChannelAPartialMutationError as ChannelAPartialMutationError2,
-  RoutingMutationOutcomeUnknownError as RoutingMutationOutcomeUnknownError2
+  RoutingMutationOutcomeUnknownError as RoutingMutationOutcomeUnknownError2,
+  isRoutingMutationOutputRejectedError
 } from "@opengeni/runtime/sandbox";
 import { connectorAttachmentSandboxPath as connectorAttachmentSandboxPath2 } from "@opengeni/runtime";
 var ConnectorAttachmentMaterializationError = class extends Error {
@@ -32819,7 +32934,7 @@ async function materializeConnectorAttachmentsInChannel(channel, request, option
       attachments: receipts
     });
   } catch (error51) {
-    if (error51 instanceof ChannelAPartialMutationError2 || error51 instanceof RoutingMutationOutcomeUnknownError2) {
+    if (error51 instanceof ChannelAPartialMutationError2 || error51 instanceof RoutingMutationOutcomeUnknownError2 || isRoutingMutationOutputRejectedError(error51)) {
       throw error51;
     }
     throw new ConnectorAttachmentMaterializationError();
@@ -32894,7 +33009,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 +33027,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 +33050,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 +33059,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 +33149,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 +33299,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 +33474,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 +33501,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");
   }
 }
@@ -33317,7 +33548,8 @@ import {
   resolveTurnToolPolicy,
   scheduledTurnMcpServerIds,
   hasPermission as hasPermission2,
-  requireExplicitPermissionDelegation
+  requireExplicitPermissionDelegation,
+  createWebSearchBilling
 } from "@opengeni/core";
 import { SandboxChannelAService as SandboxChannelAService3 } from "@opengeni/runtime/sandbox";
 import { sandboxRunAs as sandboxRunAs4 } from "@opengeni/runtime";
@@ -33639,6 +33871,200 @@ function codeSearchToolDefinitions(input) {
   ];
 }
 
+// src/activities/agent-turn/web-search.ts
+import {
+  WEB_FETCH_TOOL_NAME,
+  WEB_SEARCH_TOOL_NAME,
+  webSearchCallPricing,
+  webSearchCreditMicros,
+  webSearchProviderConfig,
+  webSearchToolPlan
+} from "@opengeni/config";
+import {
+  WebSearchBillingRefusedError
+} from "@opengeni/core";
+import {
+  WEB_FETCH_TOOL_DESCRIPTION,
+  WEB_FETCH_RETAINED_MAX_CHARS,
+  WEB_SEARCH_TOOL_DESCRIPTION,
+  WebSearchProviderError,
+  WebToolArgumentError,
+  createWebFetchProvider,
+  createWebSearchProvider,
+  parseWebFetchArguments,
+  parseWebSearchArguments,
+  renderWebPageWindow,
+  renderWebSearchResults,
+  webFetchInputSchema,
+  webSearchInputSchema
+} from "@opengeni/runtime/web-search";
+function turnWebSearchPlan(resolvedModel, settings) {
+  return webSearchToolPlan(settings, {
+    hostedWebSearch: hostedWebSearchForTurn(resolvedModel, settings.webSearchEnabled),
+    // SuperGrok's native search is added by its transport, not as an agent
+    // tool, so provider tools would only duplicate it.
+    transportHostedSearch: resolvedModel?.provider.kind === "xai-subscription"
+  });
+}
+var PAGE_CACHE_ENTRIES = 16;
+function textResult2(text, isError) {
+  return { isError, content: [{ type: "text", text }] };
+}
+function settledCost(operationId, operation, provider, pricing, reportedCostMicros) {
+  const basis = pricing.explicit ? "configured_price" : reportedCostMicros !== void 0 ? "provider_reported" : "list_price";
+  const providerMicros = basis === "provider_reported" ? reportedCostMicros : pricing.providerMicros;
+  return {
+    operationId,
+    operation,
+    provider,
+    providerMicros,
+    creditMicros: webSearchCreditMicros(providerMicros, pricing.marginBps),
+    marginBps: pricing.marginBps,
+    basis
+  };
+}
+function providerFailure(error51) {
+  return `${error51.message}${error51.retryable ? ". You may retry shortly." : "."}`;
+}
+function webSearchToolDefinitions(input) {
+  const config2 = webSearchProviderConfig(input.settings);
+  if (!config2 || input.tools.length === 0) return [];
+  const adapterInput = {
+    timeoutMs: config2.timeoutMs,
+    ...input.fetch ? { fetch: input.fetch } : {}
+  };
+  const settle = async (cost) => {
+    try {
+      await input.billing.settle(input.scope, cost);
+    } catch (error51) {
+      input.observability.warn("web search usage settlement failed", {
+        operation: cost.operation,
+        provider: cost.provider,
+        error: error51 instanceof Error ? error51.message : String(error51)
+      });
+    }
+  };
+  const definitions = [];
+  if (input.tools.includes(WEB_SEARCH_TOOL_NAME)) {
+    const provider = createWebSearchProvider({ ...adapterInput, endpoint: config2.search });
+    const pricing = webSearchCallPricing(config2, "search");
+    definitions.push({
+      identity: { serverId: "opengeni", toolName: WEB_SEARCH_TOOL_NAME },
+      modelName: WEB_SEARCH_TOOL_NAME,
+      codemodePath: ["opengeni", WEB_SEARCH_TOOL_NAME],
+      title: "Search the web",
+      description: WEB_SEARCH_TOOL_DESCRIPTION,
+      inputSchema: webSearchInputSchema,
+      annotations: {
+        title: "Search the web",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      source: "opengeni",
+      approval: "none",
+      execute: async (args, context) => {
+        let request;
+        try {
+          request = parseWebSearchArguments(args);
+          await input.billing.admit(input.scope, pricing.providerMicros);
+        } catch (error51) {
+          if (error51 instanceof WebToolArgumentError || error51 instanceof WebSearchBillingRefusedError)
+            return textResult2(error51.message, true);
+          throw error51;
+        }
+        try {
+          const response = await provider.search(request, { signal: context.signal });
+          await settle(
+            settledCost(
+              context.operationId,
+              "search",
+              config2.search.provider,
+              pricing,
+              response.reportedCostMicros
+            )
+          );
+          return textResult2(renderWebSearchResults(request.query, response.results), false);
+        } catch (error51) {
+          if (context.signal?.aborted) throw error51;
+          if (error51 instanceof WebSearchProviderError) {
+            return textResult2(`Web search failed: ${providerFailure(error51)}`, true);
+          }
+          throw error51;
+        }
+      }
+    });
+  }
+  if (input.tools.includes(WEB_FETCH_TOOL_NAME) && config2.fetch) {
+    const fetchEndpoint = config2.fetch;
+    const provider = createWebFetchProvider({ ...adapterInput, endpoint: fetchEndpoint });
+    const pricing = webSearchCallPricing(config2, "fetch");
+    const pages = /* @__PURE__ */ new Map();
+    definitions.push({
+      identity: { serverId: "opengeni", toolName: WEB_FETCH_TOOL_NAME },
+      modelName: WEB_FETCH_TOOL_NAME,
+      codemodePath: ["opengeni", WEB_FETCH_TOOL_NAME],
+      title: "Read a web page",
+      description: WEB_FETCH_TOOL_DESCRIPTION,
+      inputSchema: webFetchInputSchema,
+      annotations: {
+        title: "Read a web page",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      source: "opengeni",
+      approval: "none",
+      execute: async (args, context) => {
+        let request;
+        try {
+          request = parseWebFetchArguments(args);
+        } catch (error51) {
+          if (error51 instanceof WebToolArgumentError) return textResult2(error51.message, true);
+          throw error51;
+        }
+        const cached2 = pages.get(request.url);
+        if (cached2) return textResult2(renderWebPageWindow(cached2, request), false);
+        try {
+          await input.billing.admit(input.scope, pricing.providerMicros);
+        } catch (error51) {
+          if (error51 instanceof WebSearchBillingRefusedError) return textResult2(error51.message, true);
+          throw error51;
+        }
+        try {
+          const page = await provider.fetch({ url: request.url }, { signal: context.signal });
+          await settle(
+            settledCost(
+              context.operationId,
+              "fetch",
+              fetchEndpoint.provider,
+              pricing,
+              page.reportedCostMicros
+            )
+          );
+          if (pages.size >= PAGE_CACHE_ENTRIES) {
+            pages.delete(pages.keys().next().value);
+          }
+          pages.set(request.url, {
+            ...page,
+            content: page.content.slice(0, WEB_FETCH_RETAINED_MAX_CHARS + 1)
+          });
+          return textResult2(renderWebPageWindow(page, request), false);
+        } catch (error51) {
+          if (context.signal?.aborted) throw error51;
+          if (error51 instanceof WebSearchProviderError) {
+            return textResult2(`Web fetch failed: ${providerFailure(error51)}`, true);
+          }
+          throw error51;
+        }
+      }
+    });
+  }
+  return definitions;
+}
+
 // src/activities/agent-turn/skill-tools.ts
 import { createHash as createHash13 } from "crypto";
 import {
@@ -33808,14 +34234,14 @@ async function readResult(files, identity, args, context, activeHistory) {
   if (args.listFiles === true) {
     return {
       kind: "list",
-      result: textResult2({ ...identity, ...listSkillPaths(files, PORTABLE_SKILL_MAX_FILES) })
+      result: textResult3({ ...identity, ...listSkillPaths(files, PORTABLE_SKILL_MAX_FILES) })
     };
   }
   const selected = readSkillFiles(files, args.paths);
   if (args.paths === void 0 && context.caller.kind === "model" && activeHistory && await inActiveHistory(activeHistory, identity, selected.files[0])) {
     return {
       kind: "already_in_context",
-      result: textResult2({
+      result: textResult3({
         ...identity,
         alreadyInContext: true,
         message: `Already in context: SKILL.md of ${JSON.stringify(args.skill)}${identity.revisionId ? ` revision ${identity.revisionId}` : ""} was returned earlier in this conversation and is unchanged. Use that copy. Re-read only if you need a fresh copy: call skill_read with paths ["SKILL.md"].`
@@ -33823,12 +34249,12 @@ async function readResult(files, identity, args, context, activeHistory) {
     };
   }
   if (args.paths !== void 0) {
-    return { kind: "files", result: textResult2({ ...identity, ...selected }) };
+    return { kind: "files", result: textResult3({ ...identity, ...selected }) };
   }
   const scripts = skillScriptIndex(files);
   return {
     kind: "full",
-    result: textResult2({ ...identity, ...selected, ...scripts ?? {} })
+    result: textResult3({ ...identity, ...selected, ...scripts ?? {} })
   };
 }
 function observe(telemetry, read) {
@@ -33865,7 +34291,7 @@ function withSkillUse(read, origin, identity, telemetry) {
     return read.result;
   }
 }
-function textResult2(output) {
+function textResult3(output) {
   return {
     isError: false,
     content: [{ type: "text", text: JSON.stringify(output) }],
@@ -35329,6 +35755,19 @@ async function prepareTurnToolRuntime(deps) {
   const attemptToolFamilies = resolveAgentToolFamilies(session.agent, {
     hasSkills: skillCatalog.length > 0
   });
+  const webSearchTools = webSearchToolDefinitions({
+    settings: runSettings,
+    tools: turnWebSearchPlan(resolvedModel, runSettings).providerTools,
+    scope: {
+      accountId: input.accountId,
+      workspaceId: input.workspaceId,
+      sessionId: input.sessionId,
+      turnId: turn.id,
+      attemptId: input.attemptId
+    },
+    billing: createWebSearchBilling({ db, settings: runSettings }),
+    observability
+  });
   const attemptToolDefinitions = [
     ...operationReadStore ? [
       createOperationReadAttemptToolDefinition({
@@ -35407,7 +35846,8 @@ async function prepareTurnToolRuntime(deps) {
       ...interactionInterventionResume ? { interventionResume: interactionInterventionResume } : {}
     }),
     ...googleDrivePublicationTool && googleDrivePublicationAllowed ? [googleDrivePublicationTool] : [],
-    ...codeSearchTools
+    ...codeSearchTools,
+    ...webSearchTools
   ].filter((tool) => attemptToolFamilies.allowsFunctionTool(tool.modelName));
   recordTurnStartupPhase(observability, {
     phase: "tool_context_preparation",
@@ -35634,7 +36074,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();
   };
@@ -37225,7 +37666,7 @@ async function buildTurnAgent(deps) {
       variableNames: Object.keys(workspaceVariableSet.values)
     }
   } : {};
-  const hostedWebSearch = hostedWebSearchForTurn(resolvedModel, runSettings.webSearchEnabled);
+  const hostedWebSearch = turnWebSearchPlan(resolvedModel, runSettings).hostedWebSearch;
   const resolveImageReferences = async (references) => await resolveImageGenerationReferencesForTool({
     db,
     objectStorage,
@@ -37668,8 +38109,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 +40948,4 @@ export {
   createTurnActivities,
   createTurnActivitiesFromServices
 };
-//# sourceMappingURL=activities-turn-BMY3CDKL.js.map
+//# sourceMappingURL=activities-turn-4Z3M7Z3F.js.map