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

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/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/web-search.d.ts

@@ -0,0 +1,33 @@
+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[];
+};
+/**
+ * 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: Pick<Observability, "warn">;
+    fetch?: typeof fetch;
+}): AttemptToolDefinition[];

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

@@ -1,5 +1,5 @@
 import { type AttemptToolCatalogEntry, type AttemptToolEnvironment } from "@opengeni/codemode";
-import { type ToolDisplayMetadata, type ToolFamily } from "@opengeni/contracts";
+import { CodemodeOperation, type ToolDisplayMetadata, type ToolFamily } from "@opengeni/contracts";
 import { type Database } from "@opengeni/db";
 import { type EventBus } from "@opengeni/events";
 export type CodemodeDispatcherScope = {
@@ -29,6 +29,7 @@ export declare class CodemodeAttemptDispatcher {
     private readonly toolDisplayMetadata?;
     /** Content-free analytics family for a catalog entry; event enrichment only. */
     private readonly toolFamily?;
+    private readonly approvalWait?;
     private readonly stopController;
     private readonly inFlight;
     private pendingClaims;
@@ -38,8 +39,11 @@ export declare class CodemodeAttemptDispatcher {
     private readonly claimHeartbeatMs;
     constructor(db: Database, bus: EventBus, environment: AttemptToolEnvironment, scope: CodemodeDispatcherScope, turnSignal?: AbortSignal | undefined, maxConcurrentCalls?: number, timings?: CodemodeDispatcherTimings, toolDisplayMetadata?: ((modelName: string) => ToolDisplayMetadata | undefined) | undefined, 
     /** Content-free analytics family for a catalog entry; event enrichment only. */
-    toolFamily?: ((entry: AttemptToolCatalogEntry) => ToolFamily | null) | undefined);
+    toolFamily?: ((entry: AttemptToolCatalogEntry) => ToolFamily | null) | undefined, approvalWait?: {
+        beginWait(): (accepted: boolean) => void;
+    } | undefined);
     start(): void;
+    resumeApproved(callerSubjectId: string, decisionOperationId?: string): Promise<CodemodeOperation[]>;
     close(reason?: string): Promise<void>;
     private execute;
     private executeClaimed;

package/dist/activities/open-suffix-resume.d.ts

@@ -54,6 +54,8 @@ export declare function resultItemForOpenSuffixMember(input: {
     eventOutput: unknown;
 }>;
 export declare function settleOpenSuffixResumeIfNeeded(input: {
+    additionalApprovals?: unknown[];
+    programmaticApprovalAcknowledged?: boolean;
     db: Database;
     agent: Agent<any, any>;
     accountId: string;

package/dist/activities/programmatic-approvals.d.ts

@@ -0,0 +1,27 @@
+import type { CodemodeOperation } from "@opengeni/contracts";
+/** Programmatic receipts are not open SDK calls. Exact arguments stay in protected storage. */
+export declare function programmaticApproval(operation: CodemodeOperation): {
+    id: string;
+    name: string;
+    source: "codemode";
+    operationId: string;
+    requestId: string | undefined;
+};
+export declare function programmaticContinuationNote(operations: readonly CodemodeOperation[]): string | undefined;
+/**
+ * Recover committed programmatic approval waits/results before the first model
+ * request without turning lazy MCP preparation into a first-request barrier.
+ *
+ * Only eager servers may gate the first request. Resuming a stored operation
+ * needs the prepared attempt tool environment, so this waits for full tool
+ * preparation only when there is something to resume: an approval decision
+ * trigger, or a cheap durable read showing unfinished operations for this
+ * logical turn (which covers every recovery that has stored work). Every other
+ * turn sends its first request without waiting on any lazy server.
+ */
+export declare function recoverProgrammaticOperationsBeforeFirstRequest(input: {
+    approvalDecisionId: string | undefined;
+    hasUnfinishedOperations: () => Promise<boolean>;
+    toolPreparationReady: Promise<void> | null;
+    resumeApproved: (decisionOperationId: string | undefined) => Promise<CodemodeOperation[]> | undefined;
+}): Promise<CodemodeOperation[]>;

package/dist/activities/run-input.d.ts

@@ -32,6 +32,8 @@ export type TurnInputOptions = {
     unavailableSandboxFilesNote?: string;
     runCredentialsNote?: string;
     mcpAvailabilityNote?: string;
+    codemodeContinuationNote?: string;
+    programmaticApprovalAcknowledged?: boolean;
     knowledgeSourcePreparationNote?: string;
     providerApi: HistoryProviderApi;
     projectCanonicalHistory?: ModelHistoryAttachmentProjector;

package/dist/{activities-control-QSDPXLLD.js → activities-control-D5KVEPHI.js}

@@ -34,7 +34,7 @@ import {
   warnDrainSnapshotFailure,
   withFirstPartyTools,
   workflowIdForSession
-} from "./chunk-JKMG5ZHH.js";
+} from "./chunk-BMTWULF7.js";
 import {
   inspectOpenSandboxKubernetesInventory,
   recordActiveUserGauges,
@@ -62,7 +62,7 @@ import {
   recordVerifiedSignupTrialSwitchGauge,
   recordWorkerDeathRecoveryMetrics,
   runtimeMetricsHooksForObservability
-} from "./chunk-XONQEVAD.js";
+} from "./chunk-FF4HPY7L.js";
 import "./chunk-PZ5AY32C.js";
 
 // src/activities/knowledge-indexing.ts
@@ -8813,4 +8813,4 @@ export {
   createControlActivities,
   createControlActivitiesFromServices
 };
-//# sourceMappingURL=activities-control-QSDPXLLD.js.map
+//# sourceMappingURL=activities-control-D5KVEPHI.js.map