@opengeni/worker-bundle 2.0.3 → 2.1.0-canary.36239117573001

package/dist/observability-metrics.d.ts

@@ -1,6 +1,6 @@
 import { type SessionEventType } from "@opengeni/contracts";
 import type { SessionEventAppendPhaseObservation } from "@opengeni/db";
-import type { EventLogger } from "@opengeni/events";
+import { type EventBusOptions, type EventLogger } from "@opengeni/events";
 import type { Observability } from "@opengeni/observability";
 import type { CompanyBrainContributionReceipt } from "./model-context-contributions.js";
 import { type OpenSandboxKubernetesInventory } from "./opensandbox-kubernetes-inventory.js";
@@ -39,6 +39,8 @@ export type TemporalTurnTaskQueueStats = {
 } | null;
 declare const CONTEXT_COMPACTION_TRIGGERS: readonly ["auto", "operator", "proactive", "overflow"];
 export type ContextCompactionTrigger = (typeof CONTEXT_COMPACTION_TRIGGERS)[number];
+/** Logger plus the closed-label subscription-termination counter for NATS connections. */
+export declare function observabilityEventBusOptions(observability: Observability): Pick<EventBusOptions, "logger" | "onSubscriptionTerminated">;
 export declare function observabilityEventLogger(observability: Observability): EventLogger;
 export declare function runtimeMetricsHooksForObservability(observability: Observability): RuntimeMetricsHooks;
 /**
@@ -422,4 +424,12 @@ export declare function modelCallAccountContext(input: {
     servingAccountHash: string;
     accountChangedFromPrevCall: boolean;
 };
+export type CodeSearchCallOutcome = "completed" | "jev_unavailable" | "jev_rejected" | "workspace_unavailable" | "invalid_arguments" | "breaker_open" | "cancelled" | "failed";
+/** One `code_search` tool call: outcome, wall time and the Jev work it used. */
+export declare function recordCodeSearchCall(observability: Observability, input: {
+    outcome: CodeSearchCallOutcome;
+    durationSeconds: number;
+    jevRequests: number;
+    jevCostUsd: number;
+}): void;
 export {};

package/dist/sandbox-resume.d.ts

@@ -43,6 +43,23 @@ export type SandboxResumeServices = {
     /** Test seam for the bounded command-readiness proof performed before an
      * attached provider box is handed to the agent. */
     verifyAttachedSandboxReadiness?: (established: EstablishedSandboxSession) => Promise<void>;
+    /** Test seam for the bounded command-readiness proof the elected spawner runs
+     * on its freshly created box before publishing the lease warm. Production
+     * uses {@link waitForSandboxExecReadiness} with the shared 60 s budget. */
+    verifySpawnedSandboxReadiness?: (established: EstablishedSandboxSession, identity: {
+        sandboxGroupId: string;
+    }) => Promise<void>;
+    /** Test seam for the jittered pause before the single fresh-box readiness
+     * replacement. Production uses {@link freshSandboxReadinessReplacementDelayMs}.
+     * It may be async so a test can observe the rolled-back lease in between. */
+    freshSandboxReadinessReplacementDelayMs?: () => number | Promise<number>;
+    /**
+     * The turn attempt's fresh-box readiness replacement budget. The lazy
+     * provisioner may call resumeBoxForTurn again after a typed lease
+     * supersession, so the turn creates the budget once and shares it with every
+     * call. Absent, the call gets its own single replacement.
+     */
+    freshSandboxReadinessReplacementBudget?: FreshSandboxReadinessReplacementBudget;
     /** Called only by the observer that wins the exact warm->cold loss CAS. */
     onSandboxLost?: (input: {
         sandboxGroupId: string;
@@ -145,6 +162,23 @@ export declare class SandboxSiblingWarmingTimeoutError extends SandboxWarmingTim
         instanceId?: string | null;
     });
 }
+/** True only for a spawner readiness timeout whose unready fresh box is proven gone. */
+export declare function isReplaceableFreshSandboxReadinessTimeout(error: unknown): boolean;
+/**
+ * A burst of simultaneous turn starts can leave many freshly created provider
+ * boxes command-unready at once. The single replacement re-enters admission
+ * after a jittered pause so the replacement creates do not re-synchronize into
+ * the same burst. Bounded to [2 s, 10 s).
+ */
+export declare const FRESH_SANDBOX_READINESS_REPLACEMENT_BASE_DELAY_MS = 2000;
+export declare const FRESH_SANDBOX_READINESS_REPLACEMENT_JITTER_MS = 8000;
+export declare function freshSandboxReadinessReplacementDelayMs(random?: () => number): number;
+/** Replacements allowed per turn attempt, across every resumeBoxForTurn call. */
+export declare const FRESH_SANDBOX_READINESS_REPLACEMENTS_PER_TURN_ATTEMPT = 1;
+export type FreshSandboxReadinessReplacementBudget = {
+    remaining: number;
+};
+export declare function createFreshSandboxReadinessReplacementBudget(): FreshSandboxReadinessReplacementBudget;
 /** The exact attached caller that won warm->cold after proving the provider
  * instance gone. It is a lease supersession (the same logical turn recovers),
  * plus the lost id needed for one durable observability event. */
@@ -235,5 +269,17 @@ export declare function maybePersistWarmWorkspaceSnapshot(services: SandboxResum
  * holderId is the globally unique durable turn-attempt id. It must not be a
  * Temporal activity id, because activity ids are only workflow-local and
  * collide when sibling sessions share one sandbox group.
+ *
+ * A freshly created box that misses its bounded command-readiness budget is
+ * replaced at most once per turn attempt (the budget is shared by every call
+ * the turn's provisioner makes). The first establish has already terminated that exact
+ * unpublished box, rolled its exact warming epoch back to cold (advancing the
+ * epoch), and released its holder, so the replacement is an ordinary new
+ * admission: it re-runs the cold->warming CAS, persists its own provider
+ * instance before readiness, and may instead attach to a sibling that won the
+ * CAS first. Nothing model- or tool-visible ran on the discarded box, so no
+ * side effect is replayed. A second readiness timeout fails the turn exactly
+ * as before; attached/resumed boxes and unconfirmed terminations never
+ * replace.
  */
 export declare function resumeBoxForTurn(services: SandboxResumeServices, ids: ResumeBoxIds, kind: "turn", holderId: TurnSandboxLeaseHolderId): Promise<ResumedTurnSandbox>;