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

package/dist/index.js

@@ -839,7 +839,7 @@ function temporalWorkflowExecutionNotFound(error) {
   return isGrpcServiceError(error) && error.code === 5;
 }
 async function createDefaultWorkerActivities(role, dependencies = {}) {
-  return role === "control" ? (await import("./activities-control-QSDPXLLD.js")).createControlActivities(dependencies) : (await import("./activities-turn-BMY3CDKL.js")).createTurnActivities(dependencies);
+  return role === "control" ? (await import("./activities-control-PEXBWKQJ.js")).createControlActivities(dependencies) : (await import("./activities-turn-W27A2SBO.js")).createTurnActivities(dependencies);
 }
 function resolveOpenGeniWorkflowDefinition(moduleUrl = import.meta.url) {
   const modulePath = fileURLToPath(moduleUrl).replaceAll("\\", "/");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeni/worker-bundle",
-  "version": "1.2.1-canary.37222965366001",
+  "version": "1.3.0",
   "description": "OpenGeni worker entry and reusable embedded lifecycle, shipped with a release-coherent pre-bundled Temporal workflow artifact.",
   "license": "Apache-2.0",
   "repository": {
@@ -54,26 +54,26 @@
   },
   "dependencies": {
     "@llamaindex/liteparse": "2.14.2",
-    "@opengeni/agent-proto": "1.2.1-canary.37222965366001",
-    "@opengeni/capabilities": "1.2.1-canary.37222965366001",
-    "@opengeni/codemode": "1.2.1-canary.37222965366001",
-    "@opengeni/codex": "1.2.1-canary.37222965366001",
-    "@opengeni/config": "1.2.1-canary.37222965366001",
-    "@opengeni/contracts": "1.2.1-canary.37222965366001",
-    "@opengeni/core": "1.2.1-canary.37222965366001",
-    "@opengeni/db": "1.2.1-canary.37222965366001",
-    "@opengeni/documents": "1.2.1-canary.37222965366001",
-    "@opengeni/events": "1.2.1-canary.37222965366001",
-    "@opengeni/github": "1.2.1-canary.37222965366001",
-    "@opengeni/interaction": "1.2.1-canary.37222965366001",
-    "@opengeni/jev": "1.2.1-canary.37222965366001",
-    "@opengeni/network": "1.2.1-canary.37222965366001",
-    "@opengeni/observability": "1.2.1-canary.37222965366001",
-    "@opengeni/runtime": "1.2.1-canary.37222965366001",
-    "@opengeni/sdk": "1.2.1-canary.37222965366001",
-    "@opengeni/storage": "1.2.1-canary.37222965366001",
-    "@opengeni/tool-gateway": "1.2.1-canary.37222965366001",
-    "@opengeni/xai-subscription": "1.2.1-canary.37222965366001",
+    "@opengeni/agent-proto": "1.3.0",
+    "@opengeni/capabilities": "1.3.0",
+    "@opengeni/codemode": "1.3.0",
+    "@opengeni/codex": "1.3.0",
+    "@opengeni/config": "1.3.0",
+    "@opengeni/contracts": "1.3.0",
+    "@opengeni/core": "1.3.0",
+    "@opengeni/db": "1.3.0",
+    "@opengeni/documents": "1.3.0",
+    "@opengeni/events": "1.3.0",
+    "@opengeni/github": "1.3.0",
+    "@opengeni/interaction": "1.3.0",
+    "@opengeni/jev": "1.3.0",
+    "@opengeni/network": "1.3.0",
+    "@opengeni/observability": "1.3.0",
+    "@opengeni/runtime": "1.3.0",
+    "@opengeni/sdk": "1.3.0",
+    "@opengeni/storage": "1.3.0",
+    "@opengeni/tool-gateway": "1.3.0",
+    "@opengeni/xai-subscription": "1.3.0",
     "@temporalio/activity": "^1.17.0",
     "@temporalio/client": "^1.17.0",
     "@temporalio/worker": "^1.17.0",

package/src/activities/agent-turn/agent-build.ts

@@ -757,8 +757,8 @@ export async function buildTurnAgent(deps: BuildTurnAgentDeps) {
               // 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 } : {}),
             }

package/src/activities/agent-turn/stream-attempt.ts

@@ -7,6 +7,7 @@ import {
   getHumanInputResumeForEvent,
   getSessionHumanInputRequest,
   getWorkspace,
+  listTurnCodemodeApprovals,
   recordUsageEvent,
   registerPendingSessionToolCall,
   recordPendingSessionToolCallResult,
@@ -77,6 +78,7 @@ import {
   generatedImageFromSdkEvent,
   isCompletedGeneratedImageSdkEvent,
 } from "../generated-images";
+import { programmaticApproval, programmaticContinuationNote } from "../programmatic-approvals";
 import { ToolResultSpill } from "./tool-result-spill";
 import { ownedTurnSandboxForAgent } from "./turn-sandbox-access";
 import { createTurnCredentialLeases } from "./credential-leases";
@@ -449,6 +451,8 @@ export async function runTurnStreamAttempt(
     await parallelSessionTitle?.cancel();
   };
   let runInput: Awaited<ReturnType<typeof turnInput>>["input"] | null = null;
+  let codemodeContinuationNote: string | undefined;
+  let programmaticApprovalAcknowledged = false;
   const prepareRunAttemptInput = async () => {
     const historyPreparationStartedAt = performance.now();
     let historyPreparationOutcome: "completed" | "failed" = "completed";
@@ -461,6 +465,8 @@ export async function runTurnStreamAttempt(
           subjectId: fileAuthoritySubjectId,
         },
         recovering: turn.executionGeneration > 1,
+        programmaticApprovalAcknowledged,
+        ...(codemodeContinuationNote ? { codemodeContinuationNote } : {}),
         ...(unavailableSandboxFilesNote ? { unavailableSandboxFilesNote } : {}),
         ...(runCredentialsNote ? { runCredentialsNote } : {}),
         ...(mcpAvailabilityNote ? { mcpAvailabilityNote } : {}),
@@ -1656,10 +1662,21 @@ export async function runTurnStreamAttempt(
         });
       }
     }
-    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 =
@@ -1739,28 +1756,34 @@ export async function runTurnStreamAttempt(
       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, {
-        accountId: input.accountId,
-        workspaceId: input.workspaceId,
-        sessionId: input.sessionId,
-        turnId: activeTurnId,
-        executionGeneration: attempt.executionGeneration,
-        attemptId: input.attemptId,
-        members: interruptionCallIds.map((callId) => {
-          const member = suffixByCallId.get(callId)!;
-          return {
-            callId,
-            interruptionKind: interruptionKindForCallItem(
-              member.callItem as Record<string, unknown>,
-            ),
-            reasoningItems: member.reasoningItems as Array<Record<string, unknown>>,
-          };
-        }),
-      });
+      const attached =
+        interruptionCallIds.length === 0
+          ? { accepted: true }
+          : await attachOpenSuffixToPendingToolCalls(db, {
+              accountId: input.accountId,
+              workspaceId: input.workspaceId,
+              sessionId: input.sessionId,
+              turnId: activeTurnId,
+              executionGeneration: attempt.executionGeneration,
+              attemptId: input.attemptId,
+              members: interruptionCallIds.map((callId) => {
+                const member = suffixByCallId.get(callId)!;
+                return {
+                  callId,
+                  interruptionKind: interruptionKindForCallItem(
+                    member.callItem as Record<string, unknown>,
+                  ),
+                  reasoningItems: member.reasoningItems as Array<Record<string, unknown>>,
+                };
+              }),
+            });
       if (!attached.accepted) {
         return claimedResult({ status: "cancelled" });
       }
@@ -1935,7 +1958,29 @@ export async function runTurnStreamAttempt(
     return claimedResult({ status: "idle" });
   };
 
+  // Recover committed waits/results before any model dispatch, including crash replacement.
+  // A new attempt uses its own signed caller; origin provenance never changes.
+  await eventing.toolPreparationReady;
+  const codemodeOperations =
+    (await eventing.codemodeDispatcher?.resumeApproved(
+      `sandbox:${input.attemptId}`,
+      trigger.type === "user.approvalDecision"
+        ? (trigger.payload as { approvalId: string }).approvalId
+        : undefined,
+    )) ?? [];
+  codemodeContinuationNote = programmaticContinuationNote(codemodeOperations);
+  programmaticApprovalAcknowledged =
+    trigger.type === "user.approvalDecision" &&
+    codemodeOperations.some(
+      (operation) =>
+        operation.operationId === (trigger.payload as { approvalId?: unknown }).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,

package/src/activities/agent-turn/tool-environment.ts

@@ -1234,6 +1234,7 @@ export async function prepareTurnToolRuntime(deps: PrepareTurnToolRuntimeDeps) {
       {},
       (name) => mcpToolDisplayMetadata(tools.mcpServers, name),
       (entry) => toolFamilyForCatalogIdentity(entry, runSettings.mcpServers),
+      tools.inputWaitYield,
     );
     eventing.codemodeDispatcher.start();
   };

package/src/activities/agent-turn/tool-policy.ts

@@ -294,12 +294,8 @@ export function modelAttachmentInputPolicyForTurn(
     };
   } | null,
 ): ModelAttachmentInputPolicy {
-  const typedTransport =
-    resolvedModel === null ||
-    resolvedModel.provider.api === "responses" ||
-    resolvedModel.provider.api === "anthropic-messages";
   return {
-    supportsImageInput: typedTransport && modelSupportsImageInputForTurn(resolvedModel),
+    supportsImageInput: modelSupportsImageInputForTurn(resolvedModel),
     inputFileMediaTypes: [],
   };
 }

package/src/activities/codemode-dispatcher.ts

@@ -1,5 +1,10 @@
 import { randomUUID } from "node:crypto";
-import { bindMcpTelemetry, measureMcpPhase, withMcpCallIdentity } from "@opengeni/observability";
+import {
+  bindMcpTelemetry,
+  measureMcpPhase,
+  withMcpCallIdentity,
+  recordToolApproval,
+} from "@opengeni/observability";
 import {
   AttemptToolApprovalRequiredError,
   AttemptToolCatalogStaleError,
@@ -15,13 +20,18 @@ import {
   CODEMODE_CLAIM_LEASE_MS,
   CODEMODE_CLAIM_HEARTBEAT_MS,
   CODEMODE_MAX_CONCURRENT_CALLS_PER_ATTEMPT,
-  type CodemodeOperation,
+  CodemodeOperation,
   type SessionEvent,
   type ToolDisplayMetadata,
   type ToolFamily,
 } from "@opengeni/contracts";
 import {
   cancelQueuedCodemodeOperationsForAttempt,
+  waitForCodemodeApproval,
+  bindCodemodePreparation,
+  listTurnCodemodeApprovals,
+  adoptCodemodeApprovalWithOutput,
+  readTurnCodemodeOperation,
   claimCodemodeOperation,
   failCodemodeOperation,
   getSessionEventByClientEventId,
@@ -76,6 +86,7 @@ export class CodemodeAttemptDispatcher {
     private readonly toolDisplayMetadata?: (modelName: string) => ToolDisplayMetadata | undefined,
     /** Content-free analytics family for a catalog entry; event enrichment only. */
     private readonly toolFamily?: (entry: AttemptToolCatalogEntry) => ToolFamily | null,
+    private readonly approvalWait?: { beginWait(): (accepted: boolean) => void },
   ) {
     if (
       environment.catalog.accountId !== scope.accountId ||
@@ -179,6 +190,94 @@ export class CodemodeAttemptDispatcher {
     );
   }
 
+  async resumeApproved(
+    callerSubjectId: string,
+    decisionOperationId?: string,
+  ): Promise<CodemodeOperation[]> {
+    const operations = await listTurnCodemodeApprovals(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: string | null = null;
+      try {
+        effectDigest = this.environment.effectDigest(operation.identity);
+      } catch {
+        /* Removed tool: stale. */
+      }
+      const continuation = await adoptCodemodeApprovalWithOutput(this.db, {
+        ...this.scope,
+        operationId: operation.operationId,
+        callerSubjectId,
+        catalogDigest: this.environment.catalog.digest,
+        effectDigest,
+      });
+      await publishDurableSessionEvents(
+        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))
+            : undefined,
+        );
+      }
+      if (adopted?.state !== "queued") continue;
+      const claim = await claimCodemodeOperation(this.db, {
+        ...this.scope,
+        operationId: adopted.operationId,
+        claimId: randomUUID(),
+        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: CodemodeOperation[] = [];
+    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"): Promise<void> {
     if (this.closing) {
       await Promise.allSettled([...this.inFlight.values()]);
@@ -277,18 +376,56 @@ export class CodemodeAttemptDispatcher {
     }
 
     let preparedCall: Awaited<ReturnType<AttemptToolEnvironment["prepareCall"]>>;
+    let releaseWait: ((accepted: boolean) => void) | undefined;
     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,
+          ...(operation.durableApproval ? { transportMeta: { durableApproval: true } } : {}),
         },
-        { signal },
       );
+      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 (error) {
+      releaseWait?.(false);
       await this.settleWithOutput(operation, claimId, {
         state: "failed",
         errorCode: errorCode(error, signal, false),
@@ -448,6 +585,7 @@ export class CodemodeAttemptDispatcher {
       settlement,
     });
     if (!result.committed || result.events.length === 0) return;
+    recordToolApproval(settlement.state === "outcome_unknown" ? "unknown" : settlement.state);
     await publishDurableSessionEvents(
       this.bus,
       this.scope.workspaceId,
@@ -490,8 +628,8 @@ function assertMatchingCodemodeToolCallCreated(
   if (
     event.type !== "agent.toolCall.created" ||
     event.turnId !== scope.turnId ||
-    event.turnGeneration !== scope.executionGeneration ||
-    event.turnAttemptId !== scope.attemptId ||
+    event.turnGeneration !== operation.executionGeneration ||
+    event.turnAttemptId !== operation.attemptId ||
     event.turnAssociation !== "current" ||
     payload?.id !== operation.operationId ||
     payload?.name !== entry.modelName ||