@opengeni/worker-bundle 1.3.0 → 1.4.2

package/dist/activities/agent-turn/errors.d.ts

@@ -131,19 +131,7 @@ export declare function modelPreparationFailureEventPayload(error: unknown, dura
     failureCode?: "capture_in_progress" | "provider_recovery_in_progress" | "rotation_in_progress";
     retryable?: boolean;
 };
-/**
- * Recognize active-route transitions that cannot finish inside their
- * originating attempt. A Modal-home session may start on a Connected Machine
- * without creating or leasing its managed home box. When an explicit attach
- * clears the active pointer back to home, the pointer commit is authoritative,
- * but this attempt has no home session to serve the next sandbox operation.
- *
- * The Agents SDK may retain the typed routing error directly, through `cause`,
- * or inside an AggregateError from a parallel function-tool batch. Traverse
- * only those structural error links with a strict bound; never classify from
- * message text, which could originate in model or tool content.
- */
-export declare function sandboxRouteTransitionCode(error: unknown): "home_unavailable_this_turn" | "workspace_root_changed_this_turn" | "native_capabilities_changed_this_attempt" | null;
+export declare function sandboxRouteTransitionCode(error: unknown): "home_unavailable_this_turn" | "workspace_root_changed_this_turn" | "native_capabilities_changed_this_attempt" | "home_backend_recovery_pending" | null;
 export declare function isSandboxRouteTransitionError(error: unknown): boolean;
 /** Backward-compatible name for callers/tests that only exercised the original
  * machine-to-home transition. */

package/dist/activities/agent-turn/sandbox-provision.d.ts

@@ -48,6 +48,28 @@ export declare class SandboxDeadlineRotationError extends Error {
 export declare function turnOperationCancellationFailure(error: unknown): CancelledFailure | null;
 export declare function throwIfTurnOperationCancelled(signal: AbortSignal | undefined): void;
 export declare function waitForTurnOperation<T>(operation: Promise<T>, signal: AbortSignal | undefined, disposeLateResult: ((result: T) => Promise<void> | void) | undefined): Promise<T>;
+/**
+ * Upper bound for joining a cancelled attempt's in-flight provider establish.
+ * Worker shutdown cancels activities 5s after SIGTERM and force-stops 100s
+ * after it; this leaves room for the remaining finalization steps.
+ */
+export declare const PHYSICAL_SANDBOX_RESUME_DRAIN_TIMEOUT_MS = 60000;
+/** Register the PHYSICAL lease acquire/provider establish promise, not the
+ * cancellable wrapper awaiting it. */
+export declare function trackPhysicalSandboxResume<T>(inFlight: Set<Promise<unknown>>, operation: Promise<T>): Promise<T>;
+/**
+ * Join every lease acquire/provider establish this attempt started, even after
+ * the turn-facing wrapper rejected on cancellation. An establish has no
+ * portable abort: after cancellation it still finishes its own exact cleanup
+ * (terminate an unpublished box and roll warming back to cold, or keep a
+ * published box and drop its holder). If the activity returned first, a
+ * shutting-down worker exited mid-cleanup and stranded a warming lease naming a
+ * terminated box; the replacement attempt then waited out the warming TTL and
+ * inherited a lost-workspace verdict. This wait is deliberately independent of
+ * the finalizer cancellation signal (cancellation is what started it) and is
+ * bounded so an uncooperative provider call cannot pin the activity.
+ */
+export declare function drainPhysicalSandboxResumes(inFlight: Set<Promise<unknown>>, timeoutMs?: number): Promise<"none" | "settled" | "timed_out">;
 export declare function sleep(ms: number): Promise<void>;
 export declare function sandboxProvisionErrorChain(error: unknown): unknown[];
 export declare function firstProvisionError<T>(chain: readonly unknown[], constructor: abstract new (...args: never[]) => T): T | null;

package/dist/activities/agent-turn/subscription-lease.d.ts

@@ -27,6 +27,7 @@ export declare class SubscriptionTurnLease {
     private heartbeatInFlight;
     private heartbeatTimer;
     private readonly now;
+    private readonly renewalIntervalMs;
     constructor(leaseDeps: SubscriptionLeaseDeps);
     private expired;
     markLost: (reason: LeaseLossReason) => void;

package/dist/activities/agent-turn/tool-policy.d.ts

@@ -1,4 +1,5 @@
-import { type ComputerToolMode, type LazyToolTransport } from "@opengeni/runtime";
+import { type ComputerToolMode, type LazyToolTransport, type OpenGeniRuntime } from "@opengeni/runtime";
+import type { TurnExecutionPolicyV1 } from "@opengeni/contracts";
 import { type ModelProviderApi, type ResolvedModelProvider, type Settings } from "@opengeni/config";
 import { type ModelAttachmentInputPolicy } from "../run-input.js";
 export declare function shouldStartOnTurnRecording(params: {
@@ -112,6 +113,14 @@ export declare function shouldDeferNonEagerToolPreparation(args: {
     triggerKind: "next" | "approval";
     triggerType: string;
 }): boolean;
+/**
+ * Resolve the provider routing/gating shape for an accepted turn. The current
+ * definition is projected back onto the verified frozen policy: a turn
+ * accepted before hosted web search was enabled keeps its frozen tool set on
+ * every recovery attempt (stable tool prefix, exact accepted definition); the
+ * next accepted logical turn resolves the newly enabled tool.
+ */
+export declare function resolveAcceptedTurnModel(runtime: Pick<OpenGeniRuntime, "resolveTurnModel">, settings: Settings, policy: TurnExecutionPolicyV1): ReturnType<OpenGeniRuntime["resolveTurnModel"]>;
 /**
  * Native web search is a runtime capability, not part of the session's MCP
  * allow-list. Attach it whenever the resolved provider advertises runnable

package/dist/activities/agent-turn/turn-context.d.ts

@@ -78,6 +78,9 @@ export type SandboxRuntimeState = {
     }>;
     turnSandboxProvisioner: TurnSandboxProvisioner<ResumedTurnSandbox> | null;
     resumeManagedGroupBox: (() => Promise<ResumedTurnSandbox>) | null;
+    /** Physical resumeBoxForTurn promises still running for this attempt; the
+     * finalizer joins them so a cancelled establish completes its own cleanup. */
+    inFlightSandboxResumes: Set<Promise<unknown>>;
     prefetchedManagedBox: Promise<ResumedTurnSandbox> | null;
     prefetchedManagedBoxResult: ResumedTurnSandbox | null;
     setupBoxSession: unknown;
@@ -127,6 +130,9 @@ export type EventingState = {
     firstModelRequestPreparationRecorded: boolean;
     firstModelRequestCheckpointAt: number | null;
     initialModelWireDispatch: InitialModelWireDispatchClock;
+    /** Diagnostic only: the current stream's timing hook for a native transport's
+     *  literal provider dispatch. Never joins, fences or fails the request. */
+    providerDispatchObserver: (() => void) | null;
     companyBrainContextContributions: readonly ModelContextContributionSummary[] | null;
     /** Skill ids in this turn's frozen, model-visible Skill index; telemetry only. */
     modelVisibleSkillIds: ReadonlySet<string> | null;

package/dist/activities/agent-turn/web-search.d.ts

@@ -0,0 +1,37 @@
+import type { AttemptToolDefinition } from "@opengeni/codemode";
+import { type WebSearchProviderToolName, type WebSearchSettings } from "@opengeni/config";
+import { type WebSearchBilling, type WebSearchCallScope } from "@opengeni/core";
+import type { Observability } from "@opengeni/observability";
+/**
+ * Which web search one turn gets: the provider's hosted tool, Opengeni's
+ * provider tools, or neither. Tool preparation and agent construction both
+ * call this with the same accepted model and settings, so they agree.
+ */
+export declare function turnWebSearchPlan(resolvedModel: {
+    configured: {
+        hostedWebSearch: boolean;
+    };
+    provider: {
+        kind?: string;
+    };
+} | null, settings: WebSearchSettings): {
+    hostedWebSearch: boolean;
+    providerTools: WebSearchProviderToolName[];
+};
+/** Closed outcome set for `opengeni_web_search_calls_total`. */
+export type WebSearchCallOutcome = "ok" | "provider_error" | "provider_retryable" | "billing_refused" | "error";
+type WebSearchObservability = Pick<Observability, "warn" | "incrementCounter" | "observeHistogram">;
+/**
+ * The `web_search` and `web_fetch` attempt tools for one turn. The caller
+ * decides which names the turn gets ({@link webSearchToolPlan}); this only
+ * builds them. Provider keys stay in the worker and never reach a sandbox.
+ */
+export declare function webSearchToolDefinitions(input: {
+    settings: WebSearchSettings;
+    tools: readonly WebSearchProviderToolName[];
+    scope: WebSearchCallScope;
+    billing: WebSearchBilling;
+    observability: WebSearchObservability;
+    fetch?: typeof fetch;
+}): AttemptToolDefinition[];
+export {};

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

@@ -43,7 +43,15 @@ export declare class CodemodeAttemptDispatcher {
         beginWait(): (accepted: boolean) => void;
     } | undefined);
     start(): void;
+    /**
+     * Join-on-use recovery before the first model request. The journal read needs
+     * no tool environment, so a turn with nothing unfinished returns at once and
+     * never waits on lazy MCP preparation. Only a stored waiting/queued/running
+     * operation awaits the prepared dispatcher to adopt and execute it.
+     */
+    static resumeApproved(db: Database, scope: CodemodeDispatcherScope, callerSubjectId: string, decisionOperationId: string | undefined, prepared: () => Promise<CodemodeAttemptDispatcher | null>): Promise<CodemodeOperation[]>;
     resumeApproved(callerSubjectId: string, decisionOperationId?: string): Promise<CodemodeOperation[]>;
+    private resumeOperations;
     close(reason?: string): Promise<void>;
     private execute;
     private executeClaimed;

package/dist/activities/sandbox-lease.d.ts

@@ -209,6 +209,10 @@ export declare function probeRetainedProcessAtProvider(settings: ActivityService
 export declare function classifyRetainedProcessPollResult(result: unknown, providerSessionId: number, source?: object): RetainedProcessProbeResult;
 export declare function reconcileModalProviderCreates(db: ActivityServices["db"], settings: ActivityServices["settings"], observability: ActivityServices["observability"], discover?: typeof findModalProviderCreateReceipt): Promise<void>;
 export declare function modalOrphanTerminationStillEligible(latest: Awaited<ReturnType<typeof listLiveModalSandboxLeaseAttributions>>, candidate: ModalOrphanSweepTermination): boolean;
+/** Whether no live lease owns the candidate box by exact instance or by its
+ * attribution tags. Unlike termination eligibility this ignores the pending
+ * create postponement: a postponed orphan is still running without a lease. */
+export declare function modalOrphanCandidateStillUnowned(latest: Awaited<ReturnType<typeof listLiveModalSandboxLeaseAttributions>>, candidate: ModalOrphanSweepTermination): boolean;
 export type SandboxDrainReason = "idle" | "provider_deadline" | "operator" | "teardown_claim" | "rotation_requested";
 /** The bounded drain reason carried on `sandbox.box.terminated`: the lease's
  * rotation reason when a rotation was requested, otherwise the ordinary idle

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

@@ -34,7 +34,7 @@ import {
   warnDrainSnapshotFailure,
   withFirstPartyTools,
   workflowIdForSession
-} from "./chunk-QUX5LT2B.js";
+} from "./chunk-WVZQJBGD.js";
 import {
   inspectOpenSandboxKubernetesInventory,
   recordActiveUserGauges,
@@ -42,7 +42,9 @@ import {
   recordCreditGrantGauges,
   recordCreditMicros,
   recordExpiredDrainingSandboxLeaseGauges,
+  recordInteractionOnlyLeaseGauges,
   recordManagedAuthNewSignupsSwitchGauge,
+  recordModalSandboxInventoryGauges,
   recordOpenSandboxKubernetesInventoryGauges,
   recordRetainedProcessInventoryGauges,
   recordRetainedProcessReconciliation,
@@ -62,7 +64,7 @@ import {
   recordVerifiedSignupTrialSwitchGauge,
   recordWorkerDeathRecoveryMetrics,
   runtimeMetricsHooksForObservability
-} from "./chunk-XONQEVAD.js";
+} from "./chunk-DCQ7XTXW.js";
 import "./chunk-PZ5AY32C.js";
 
 // src/activities/knowledge-indexing.ts
@@ -2790,6 +2792,7 @@ import {
   recordRecoveredModalProviderCreate,
   markWarmBillingStopCutoff,
   listMeterableWarmLeases,
+  countInteractionOnlyWarmLeasesByIdle,
   listSandboxViewerForceDrainWorkspaceIds,
   markSandboxCheckpointArtifactDeletePending as markSandboxCheckpointArtifactDeletePending2,
   persistDrainSnapshot,
@@ -4599,6 +4602,17 @@ async function refreshQueueLeaseAndCreditGauges(db, settings, observability, ins
         );
       }
     ),
+    refreshSandboxInventoryGauge(
+      observability,
+      "interaction_idle",
+      "interaction-only-lease",
+      async () => {
+        recordInteractionOnlyLeaseGauges(
+          observability,
+          await countInteractionOnlyWarmLeasesByIdle(db, await listMeterableWarmLeases(db))
+        );
+      }
+    ),
     refreshSandboxInventoryGauge(observability, "expired_drains", "expired-draining", async () => {
       recordExpiredDrainingSandboxLeaseGauges(
         observability,
@@ -4751,6 +4765,9 @@ function modalOrphanTerminationStillEligible(latest, candidate) {
   if (latest.some((lease) => lease.liveness === "warming" && lease.instanceId === null)) {
     return false;
   }
+  return modalOrphanCandidateStillUnowned(latest, candidate);
+}
+function modalOrphanCandidateStillUnowned(latest, candidate) {
   if (latest.some((lease) => lease.instanceId === candidate.sandboxId)) {
     return false;
   }
@@ -4786,6 +4803,26 @@ async function sweepModalOrphansForConfiguredBackend(settings, db, observability
       return modalOrphanTerminationStillEligible(latest, candidate);
     }
   });
+  if (result.inventory.complete) {
+    try {
+      const latest = await listLiveModalSandboxLeaseAttributions(db);
+      recordModalSandboxInventoryGauges(observability, {
+        running: result.inventory.running,
+        unleased: result.inventory.unterminated.filter(
+          (candidate) => modalOrphanCandidateStillUnowned(latest, candidate)
+        ).length,
+        liveLeaseInstancesMissing: result.inventory.missingLiveLeaseInstanceIds.filter(
+          (instanceId) => latest.some((lease) => lease.instanceId === instanceId)
+        ).length
+      });
+      recordSandboxInventoryProjectionSuccess(observability, "modal_provider");
+    } catch (error) {
+      recordSandboxInventoryProjectionFailure(observability, "modal_provider");
+      observability.warn("sandbox reaper: Modal inventory ownership re-read failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
   for (const terminated of result.terminated) {
     observability.warn("sandbox reaper: terminated Modal orphan sandbox", {
       sandboxId: terminated.sandboxId,
@@ -5174,15 +5211,18 @@ async function terminateDrainableBox(db, settings, row, observability, terminate
     }
   }
   const providerMissing = providerMissingBeforeCapture || (typeof termination === "boolean" ? false : termination.providerMissingBeforeCapture);
-  const { wentCold, backgroundCommandEvents } = await confirmDrainCold(db, {
-    accountId,
-    workspaceId: row.workspaceId,
-    sandboxGroupId: row.sandboxGroupId,
-    expectedEpoch: row.leaseEpoch,
-    ...captureClaim ? { expectedCaptureId: captureClaim.id } : {},
-    providerMissingBeforeCapture: providerMissing,
-    idleCommandContainmentMs: settings.sandboxIdleCommandContainmentMs
-  });
+  const { wentCold, unpublishedProviderLost, backgroundCommandEvents } = await confirmDrainCold(
+    db,
+    {
+      accountId,
+      workspaceId: row.workspaceId,
+      sandboxGroupId: row.sandboxGroupId,
+      expectedEpoch: row.leaseEpoch,
+      ...captureClaim ? { expectedCaptureId: captureClaim.id } : {},
+      providerMissingBeforeCapture: providerMissing,
+      idleCommandContainmentMs: settings.sandboxIdleCommandContainmentMs
+    }
+  );
   await publishDurableSessionEvents(bus, row.workspaceId, backgroundCommandEvents, (error) => {
     observability.warn("sandbox reaper: contained command event fanout failed", {
       sandboxGroupId: row.sandboxGroupId,
@@ -5190,7 +5230,7 @@ async function terminateDrainableBox(db, settings, row, observability, terminate
     });
   });
   if (wentCold) {
-    if (providerMissing) {
+    if (providerMissing && !unpublishedProviderLost) {
       recordSandboxProviderMissingBeforeCapture(observability, backend);
     }
     if (lease.unobservableCommandDrainIds?.length) {
@@ -8813,4 +8853,4 @@ export {
   createControlActivities,
   createControlActivitiesFromServices
 };
-//# sourceMappingURL=activities-control-PEXBWKQJ.js.map
+//# sourceMappingURL=activities-control-AKJZHDTY.js.map