@opengeni/worker-bundle 1.0.1 → 2.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeni/worker-bundle",
-  "version": "1.0.1",
+  "version": "2.0.0",
   "description": "OpenGeni worker entry and reusable embedded lifecycle, shipped with a release-coherent pre-bundled Temporal workflow artifact.",
   "license": "Apache-2.0",
   "repository": {
@@ -56,21 +56,21 @@
     "@llamaindex/liteparse": "2.14.2",
     "@opengeni/agent-proto": "^0.6.0",
     "@opengeni/capabilities": "^0.3.4",
-    "@opengeni/codemode": "^0.5.9",
-    "@opengeni/codex": "^0.2.23",
-    "@opengeni/config": "^1.2.2",
-    "@opengeni/contracts": "^4.1.0",
-    "@opengeni/core": "^3.0.1",
-    "@opengeni/db": "^5.0.1",
-    "@opengeni/documents": "^0.8.30",
-    "@opengeni/events": "^0.4.28",
-    "@opengeni/github": "^0.7.13",
+    "@opengeni/codemode": "^0.6.0",
+    "@opengeni/codex": "^0.2.24",
+    "@opengeni/config": "^2.0.0",
+    "@opengeni/contracts": "^5.0.0",
+    "@opengeni/core": "^4.0.0",
+    "@opengeni/db": "^6.0.0",
+    "@opengeni/documents": "^0.8.31",
+    "@opengeni/events": "^0.4.29",
+    "@opengeni/github": "^0.7.14",
     "@opengeni/network": "^0.3.1",
-    "@opengeni/observability": "^0.8.29",
-    "@opengeni/runtime": "^3.0.1",
-    "@opengeni/sdk": "^6.1.0",
-    "@opengeni/storage": "^0.2.130",
-    "@opengeni/tool-gateway": "^0.1.10",
+    "@opengeni/observability": "^0.8.30",
+    "@opengeni/runtime": "^4.0.0",
+    "@opengeni/sdk": "^7.0.0",
+    "@opengeni/storage": "^0.2.131",
+    "@opengeni/tool-gateway": "^0.1.11",
     "@opengeni/xai-subscription": "^0.1.4",
     "@temporalio/activity": "^1.17.0",
     "@temporalio/client": "^1.17.0",

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

@@ -8,7 +8,10 @@ import {
   loadWorkspaceVercelAiGatewayCredentialLease,
   getExternalLinkTurnAuthorization,
   getSessionTurnForAttempt,
+  ensureSessionReasoningConfiguration,
+  ensureSessionSkillCatalog,
 } from "@opengeni/db";
+import { recoveryAwareSessionInstructions } from "./recovery-warning";
 import {
   formatSkillCatalog,
   type AttemptConnectorActionBinding,
@@ -24,7 +27,7 @@ import {
   resolveModelProvider,
   type Settings,
 } from "@opengeni/config";
-import { type CodexRequestContext } from "@opengeni/codex";
+import { type CodexRequestContext, supportsReasoningConfiguration } from "@opengeni/codex";
 import { executeXaiSubscriptionImageGeneration } from "../xai-image-generation";
 import { rigProviderImageContentHash, videoGenerationCapabilitiesForPolicy } from "@opengeni/core";
 import {
@@ -34,7 +37,7 @@ import {
   type VideoGenerationCredentialLease,
 } from "../video-generation-admission";
 import { VideoReferenceInputError } from "../video-reference-staging";
-import { rigProviderImageSourceImage } from "../packs";
+import { rigProviderImageSourceImage } from "../sandbox-images";
 import type { TurnActivityServices as ActivityServices, RunAgentTurnInput } from "../types";
 import { recordTurnStartupPhase } from "../../observability-metrics";
 import { summarizeCompanyBrainContributions } from "../../model-context-contributions";
@@ -191,6 +194,13 @@ export async function buildTurnAgent(deps: BuildTurnAgentDeps) {
     codexContext,
   } = deps;
   const preparedTools = eventing.preparedTools!;
+  // Durable recovery truth is read for every attempt, including reconstruction
+  // after compaction. It is never inferred from transcript tool successes.
+  const sessionInstructions = await recoveryAwareSessionInstructions(
+    db,
+    input.workspaceId,
+    session,
+  );
 
   const missingSessionTitleHint = preparationIndependentToolNames.includes(
     SESSION_TITLE_MODEL_TOOL_NAME,
@@ -556,7 +566,15 @@ export async function buildTurnAgent(deps: BuildTurnAgentDeps) {
     turnExecutionPolicy.latencyMode,
   );
   const approvedToolCallId = approvedConnectorActionCallId(trigger);
-  const modelVisibleSkillCatalogText = formatSkillCatalog(deps.skillCatalog);
+  const modelVisibleSkillCatalogText = await ensureSessionSkillCatalog(db, {
+    accountId: input.accountId,
+    workspaceId: input.workspaceId,
+    sessionId: input.sessionId,
+    turnId: turn.id,
+    expectedExecutionGeneration: turn.executionGeneration,
+    expectedAttemptId: input.attemptId,
+    catalog: formatSkillCatalog(deps.skillCatalog),
+  });
   try {
     eventing.companyBrainContextContributions = summarizeCompanyBrainContributions(
       buildCompanyBrainContributionReceiptFor(modelVisibleSkillCatalogText),
@@ -581,6 +599,24 @@ export async function buildTurnAgent(deps: BuildTurnAgentDeps) {
   );
   if (linkedToolAuthority && !linkedToolAuthority.authorized)
     throw new Error("Native identity link was revoked");
+  const useReasoningUpdates =
+    eventing.modelRunSettings.reasoningConfigurationUpdatesEnabled &&
+    resolvedModel?.provider.api === "responses" &&
+    (resolvedModel.provider.id === "codex" || resolvedModel.provider.id === "openai") &&
+    supportsReasoningConfiguration(turnExecutionPolicy.upstreamModelId, turn.reasoningEffort);
+  const requestReasoningEffort =
+    useReasoningUpdates &&
+    supportsReasoningConfiguration(turnExecutionPolicy.upstreamModelId, turn.reasoningEffort)
+      ? await ensureSessionReasoningConfiguration(db, {
+          accountId: input.accountId,
+          workspaceId: input.workspaceId,
+          sessionId: input.sessionId,
+          turnId: turn.id,
+          expectedExecutionGeneration: turn.executionGeneration,
+          expectedAttemptId: input.attemptId,
+          effort: turn.reasoningEffort,
+        })
+      : turn.reasoningEffort;
   const agent = (() => {
     const agentConstructionStartedAt = performance.now();
     let agentConstructionOutcome: "completed" | "failed" = "completed";
@@ -605,7 +641,7 @@ export async function buildTurnAgent(deps: BuildTurnAgentDeps) {
             }
           : {}),
         ...(preparedTools.inputWaitYield ? { inputWaitYield: preparedTools.inputWaitYield } : {}),
-        reasoningEffort: turn.reasoningEffort,
+        reasoningEffort: requestReasoningEffort,
         latencyMode: turnExecutionPolicy.latencyMode,
         ...(serviceTier ? { serviceTier } : {}),
         ...(humanInputResume ? { humanInputResponse: humanInputResume } : {}),
@@ -707,6 +743,7 @@ export async function buildTurnAgent(deps: BuildTurnAgentDeps) {
             }),
         onRetainableSessionImageOutput: media.retainSessionImageAtToolBoundary,
         skillCatalog: deps.skillCatalog,
+        skillCatalogInHistory: true,
         ...(!structuredWorkspacePolicyActive && workspaceAgentInstructions
           ? { instructionsTemplate: workspaceAgentInstructions }
           : {}),
@@ -715,7 +752,7 @@ export async function buildTurnAgent(deps: BuildTurnAgentDeps) {
         // Per-session persona tier (session > workspace > deployment default).
         // Composed system-level AFTER the workspace persona so it refines it for
         // this one session; absent ⇒ byte-identical to today's composition.
-        ...(session.instructions ? { sessionInstructions: session.instructions } : {}),
+        ...(sessionInstructions ? { sessionInstructions } : {}),
         ...workspaceEnvironmentOption,
         // RIG RUNTIME (M3): the doctrine block, the setup-script hook (only when
         // the frozen version carries a non-empty script), and the rig credential

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

@@ -1,3 +1,4 @@
+import { FILESYSTEM_DISCONTINUITY_PROTOCOL } from "./recovery-warning";
 import {
   applySessionTurnSettlement,
   claimSessionWorkForAttempt,
@@ -14,6 +15,7 @@ import {
   type SessionTurnForExecution,
 } from "@opengeni/db";
 import { appendAndPublishTurnEventsFenced, publishDurableSessionEvents } from "@opengeni/events";
+import { linkCurrentSpanToAdmission, turnExecutionTelemetryKey } from "@opengeni/observability";
 import { deliverChildRequiresActionToParent } from "../parent-wake";
 import {
   assertTurnExecutionPolicyMatchesConfigV1,
@@ -192,6 +194,7 @@ export async function claimTurnAttempt(deps: ClaimTurnDeps): Promise<ClaimTurnOu
       update,
     });
   const claim = await claimSessionWorkForAttempt(db, input.workspaceId, {
+    filesystemDiscontinuityProtocol: FILESYSTEM_DISCONTINUITY_PROTOCOL,
     sessionId: input.sessionId,
     workflowId: input.workflowId,
     workflowRunId: input.workflowRunId,
@@ -249,6 +252,7 @@ export async function claimTurnAttempt(deps: ClaimTurnDeps): Promise<ClaimTurnOu
     db,
     mcpSettings,
     input.workspaceId,
+    turn.id,
   );
   const codexSettings = await settingsWithCodexCredential(
     db,
@@ -321,6 +325,7 @@ export async function claimTurnAttempt(deps: ClaimTurnDeps): Promise<ClaimTurnOu
   if (!trigger) {
     throw new Error(`Trigger event not found: ${attempt.triggerEventId}`);
   }
+  if (trigger.type === "user.message") linkCurrentSpanToAdmission(trigger.id);
   const humanInputResume = await getHumanInputResumeForEvent(
     db,
     input.workspaceId,
@@ -336,6 +341,7 @@ export async function claimTurnAttempt(deps: ClaimTurnDeps): Promise<ClaimTurnOu
   attempt.triggerType = trigger.type;
   const attachPendingUpdatesAfterOpenSuffix = async (): Promise<boolean> => {
     const attached = await claimSessionWorkForAttempt(db, input.workspaceId, {
+      filesystemDiscontinuityProtocol: FILESYSTEM_DISCONTINUITY_PROTOCOL,
       sessionId: input.sessionId,
       workflowId: input.workflowId,
       workflowRunId: input.workflowRunId,
@@ -387,6 +393,7 @@ export async function claimTurnAttempt(deps: ClaimTurnDeps): Promise<ClaimTurnOu
     turnId: attempt.turnId,
     opAcks: {},
   };
+  eventing.heartbeatDetails = heartbeatDetails;
   const opJournal = makeTurnOpJournal(activityContext, heartbeatDetails);
   eventing.heartbeatTimer = startActivityHeartbeat(activityContext, heartbeatDetails);
   let producerSeq = 0;
@@ -547,6 +554,11 @@ export async function claimTurnAttempt(deps: ClaimTurnDeps): Promise<ClaimTurnOu
   throwIfTurnCancelled();
   recordTurnStartupPhase(observability, {
     phase: "claim_and_policy",
+    executionCorrelationId: turnExecutionTelemetryKey(
+      input.workspaceId,
+      input.sessionId,
+      input.attemptId,
+    ),
     provider: turnExecutionPolicy.providerId,
     backend: turn.sandboxBackend,
     outcome: "completed",

package/src/activities/agent-turn/codex-capacity.ts

@@ -173,10 +173,17 @@ export async function selectCodexTurnCapacity(
         );
       if (leased.decision.kind === "allCapped") {
         // Bounded self-heal of stale usage cache, then ONE new atomic selection.
-        await refreshCappedCodexUsageRows(db, settings, input.workspaceId, leased.accounts, {
-          signalCodexCapacityWorkflow,
-          wakeSessionWorkflow,
-        });
+        await refreshCappedCodexUsageRows(
+          db,
+          settings,
+          input.workspaceId,
+          leased.accounts,
+          {
+            signalCodexCapacityWorkflow,
+            wakeSessionWorkflow,
+          },
+          turn.id,
+        );
         leaseAcquisitionStartedAtMs = performance.now();
         leased = await acquireCodexCredentialLease(
           db,
@@ -466,6 +473,11 @@ export async function selectCodexTurnCapacity(
             },
           },
         );
+        if (evaluated.action === "stopped") {
+          control.turnMetricOutcome = "failed";
+          control.activityStatus = evaluated.sessionStatus === "queued" ? "idle" : "failed";
+          return { exit: claimedResult({ status: control.activityStatus }) };
+        }
         if (evaluated.action === "resumed") {
           control.turnMetricOutcome = "recovering";
           control.activityStatus = "recovering";
@@ -583,6 +595,11 @@ export async function selectCodexTurnCapacity(
             },
           },
         );
+        if (evaluated.action === "stopped") {
+          control.turnMetricOutcome = "failed";
+          control.activityStatus = evaluated.sessionStatus === "queued" ? "idle" : "failed";
+          return { exit: claimedResult({ status: control.activityStatus }) };
+        }
         if (evaluated.action === "resumed") {
           control.turnMetricOutcome = "recovering";
           control.activityStatus = "recovering";
@@ -682,6 +699,11 @@ export async function selectCodexTurnCapacity(
             failurePayload,
           },
         );
+        if (evaluated.action === "stopped") {
+          control.turnMetricOutcome = "failed";
+          control.activityStatus = evaluated.sessionStatus === "queued" ? "idle" : "failed";
+          return { exit: claimedResult({ status: control.activityStatus }) };
+        }
         if (evaluated.action === "resumed") {
           control.turnMetricOutcome = "recovering";
           control.activityStatus = "recovering";

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

@@ -61,6 +61,7 @@ export async function refreshCappedCodexUsageRows(
     signalCodexCapacityWorkflow?: ActivityServices["signalCodexCapacityWorkflow"] | undefined;
     wakeSessionWorkflow: ActivityServices["wakeSessionWorkflow"];
   },
+  acceptedTurnId?: string,
 ): Promise<
   Array<
     Pick<
@@ -82,10 +83,13 @@ export async function refreshCappedCodexUsageRows(
     return accounts;
   }
   await refreshCodexUsageAndRepairCapacityWaiters(
-    stale.map((account) => () => fetchCodexUsageForAccount(db, settings, workspaceId, account.id)),
+    stale.map(
+      (account) => () =>
+        fetchCodexUsageForAccount(db, settings, workspaceId, account.id, undefined, acceptedTurnId),
+    ),
     () => signalPendingCodexCapacityWakeTargets({ db, ...capacitySignals }, workspaceId),
   );
-  return listCodexAccountStatuses(db, workspaceId).catch(() => accounts);
+  return listCodexAccountStatuses(db, workspaceId, acceptedTurnId).catch(() => accounts);
 }
 
 /**

package/src/activities/agent-turn/compaction-prep.ts

@@ -6,8 +6,11 @@ import {
   appendWorkspaceMemory,
   composeAgentInstructions,
   requestRemoteCompactionV2,
-  serializedToolsForRemoteCompaction,
-  EmptyCompactionSummaryError,
+  preparedCompactionRequest,
+  queuePreparedCompaction,
+  compactionThresholdTokens,
+  CompactionNeededError,
+  compactionProviderRejection,
   SUMMARY_BUFFER_TOKENS,
   type ModelResponseUsage,
 } from "@opengeni/runtime";
@@ -31,7 +34,7 @@ import { type SessionEvent } from "@opengeni/contracts";
 import { acceptsPromptCacheKeyForTurn } from "./codex";
 import {
   safeErrorDiagnostic,
-  compactionFailureReasonFromError,
+  compactionFailureTurnEventPayload,
   isCompactionSummaryFailure,
   shouldRecoverCompactionProviderFailure,
 } from "./errors";
@@ -53,10 +56,7 @@ import type {
 } from "./turn-context";
 
 export type RemoteCompactionPrefix = {
-  tools: Awaited<ReturnType<typeof serializedToolsForRemoteCompaction>>;
-  instructions: string;
-  toolsReady: boolean;
-  agent: Parameters<typeof serializedToolsForRemoteCompaction>[0] | null;
+  agent: ReturnType<ActivityServices["runtime"]["buildAgent"]> | null;
 };
 
 export type CompactionPrepDeps = {
@@ -166,9 +166,6 @@ export async function prepareCompaction(deps: CompactionPrepDeps): Promise<Compa
   } = deps;
 
   const remotePrefix: RemoteCompactionPrefix = {
-    tools: [],
-    instructions: "",
-    toolsReady: false,
     agent: null,
   };
 
@@ -234,45 +231,16 @@ export async function prepareCompaction(deps: CompactionPrepDeps): Promise<Compa
     resolvedModel && billingState.isCodexTurn
       ? (s: Settings, m: Array<Record<string, unknown>>) =>
           withCodexRemoteCompaction(async () => {
-            // Lazily serialize tools here so EmptyCompactionSummaryError is
-            // thrown inside the compaction try/settlement handlers, not as a
-            // raw activity failure before maybeCompactContext runs.
-            if (!remotePrefix.instructions.trim()) {
-              throw new EmptyCompactionSummaryError({
-                stage: "remote_v2_instructions",
-                reason: "agent_missing_system_instructions",
-              });
-            }
-            if (!remotePrefix.toolsReady) {
-              if (!remotePrefix.agent) {
-                throw new EmptyCompactionSummaryError({
-                  stage: "remote_v2_tools",
-                  reason: "agent_missing_for_tools",
-                });
-              }
-              try {
-                remotePrefix.tools = await serializedToolsForRemoteCompaction(remotePrefix.agent);
-              } catch (error) {
-                // Tool schemas sit before instructions in the cache prefix.
-                // Failing open to [] would reintroduce a massive pre-compact
-                // cache bust — fail closed so we never send a tools mismatch
-                // on purpose.
-                throw new EmptyCompactionSummaryError({
-                  stage: "remote_v2_tools",
-                  reason: "serialize_tools_failed",
-                  error: String(error),
-                });
-              }
-              remotePrefix.toolsReady = true;
-            }
+            if (!remotePrefix.agent) throw new Error("Compaction agent is unavailable");
+            const preparedRequest = preparedCompactionRequest(remotePrefix.agent);
             return requestRemoteCompactionV2(s, m, {
               client: resolvedModel.client,
               provider: resolvedModel.provider,
               model: turnExecutionPolicy.upstreamModelId,
-              systemInstructions: remotePrefix.instructions,
+              preparedRequest,
+              captureAgent: remotePrefix.agent,
+              signal: cancellationSignal,
               onUsage: recordCompactionUsage,
-              tools: remotePrefix.tools,
-              ...(promptCacheKey ? { promptCacheKey } : {}),
             });
           })
       : undefined;
@@ -409,22 +377,16 @@ export async function prepareCompaction(deps: CompactionPrepDeps): Promise<Compa
           {
             clearRequestedCompaction: true,
             publishLiveEvents: publishCompactionLiveEvents,
+            providerRejection: compactionProviderRejection(error),
           },
         );
         if (!isCompactionSummaryFailure(error)) throw error;
-        const errorMessage = String(compactionFailureReasonFromError(error));
         if (
           !(await eventing.settle!({
             events: [
               {
                 type: "turn.failed",
-                payload: {
-                  error: errorMessage,
-                  code: "context_compaction_failed",
-                  retryable: false,
-                  recovery: "user_message",
-                  compacted: false,
-                },
+                payload: compactionFailureTurnEventPayload(error),
               },
               {
                 type: "session.status.changed",
@@ -522,16 +484,25 @@ export async function runPostAgentCompaction(
     agentInstructions.trim() ? agentInstructions : undefined,
   );
   if (remoteCompactionRequester) {
-    // Exact byte match with the ordinary turn prefix (CLI base_instructions).
-    // Tools serialize lazily inside the requester so setup failures settle as
-    // compaction failures rather than raw activity crashes.
-    remotePrefix.instructions = agentInstructions;
+    // The prefix is captured only after this agent passes normal SDK preparation.
     remotePrefix.agent = agent;
   }
 
   if (compactionOnlyTurn) {
     const requested = await isSessionCompactionRequested(db, input.workspaceId, input.sessionId);
     let outcome: Awaited<ReturnType<typeof maybeCompactContext>> | null = null;
+    if (requested && remoteCompactionRequester && session.codexCompactionMode === "remote_v2") {
+      queuePreparedCompaction(
+        agent,
+        new CompactionNeededError({
+          trigger: "operator",
+          signalSource: "operator",
+          signalTokens: session.lastInputTokens ?? 0,
+          thresholdTokens: compactionThresholdTokens(eventing.modelRunSettings),
+        }),
+      );
+      return { ok: { compactSummarizer } };
+    }
     if (requested) {
       try {
         outcome = await waitForTurnOperation(
@@ -579,22 +550,16 @@ export async function runPostAgentCompaction(
           {
             clearRequestedCompaction: true,
             publishLiveEvents: publishCompactionLiveEvents,
+            providerRejection: compactionProviderRejection(error),
           },
         );
         if (!isCompactionSummaryFailure(error)) throw error;
-        const errorMessage = String(compactionFailureReasonFromError(error));
         if (
           !(await eventing.settle!({
             events: [
               {
                 type: "turn.failed",
-                payload: {
-                  error: errorMessage,
-                  code: "context_compaction_failed",
-                  retryable: false,
-                  recovery: "user_message",
-                  compacted: false,
-                },
+                payload: compactionFailureTurnEventPayload(error),
               },
               {
                 type: "session.status.changed",
@@ -645,6 +610,28 @@ export async function runPostAgentCompaction(
     return { exit: claimedResult({ status: "idle" }) };
   }
 
+  if (remoteCompactionRequester && session.codexCompactionMode === "remote_v2") {
+    const forced = await isSessionCompactionRequested(db, input.workspaceId, input.sessionId);
+    const thresholdTokens = compactionThresholdTokens(eventing.modelRunSettings);
+    if (
+      forced ||
+      ((attempt.triggerType === "user.message" ||
+        attempt.triggerType === "system.update.delivered") &&
+        (session.lastInputTokens ?? 0) >= thresholdTokens)
+    ) {
+      queuePreparedCompaction(
+        agent,
+        new CompactionNeededError({
+          trigger: forced ? "operator" : "threshold",
+          signalSource: forced ? "operator" : "provider",
+          signalTokens: session.lastInputTokens ?? 0,
+          thresholdTokens,
+        }),
+      );
+    }
+    return { ok: { compactSummarizer } };
+  }
+
   // Pre-turn durable context compaction. When the single Codex-parity
   // threshold is crossed, this summarizes active history and rebuilds active
   // history as [user messages..., summary] BEFORE the model input is read.
@@ -731,12 +718,12 @@ export async function runPostAgentCompaction(
         {
           clearRequestedCompaction: forced,
           publishLiveEvents: publishCompactionLiveEvents,
+          providerRejection: compactionProviderRejection(compactError),
         },
       );
       if (!isCompactionSummaryFailure(compactError)) throw compactError;
       const deferredSteer = await settleDeferredSteerAfterCompaction();
       if (deferredSteer) return { exit: deferredSteer };
-      const errorMessage = String(compactionFailureReasonFromError(compactError));
       observability.error("context compaction failed", {
         sessionId: input.sessionId,
         turnId: attempt.turnId,
@@ -747,13 +734,7 @@ export async function runPostAgentCompaction(
           events: [
             {
               type: "turn.failed",
-              payload: {
-                error: errorMessage,
-                code: "context_compaction_failed",
-                retryable: false,
-                recovery: "user_message",
-                compacted: false,
-              },
+              payload: compactionFailureTurnEventPayload(compactError),
             },
             { type: "session.status.changed", payload: { status: "idle" } },
           ],