@opengeni/worker-bundle 4.2.1-canary.39593846423001 → 4.3.1

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

@@ -3,8 +3,9 @@ import { type Settings } from "@opengeni/config";
 import { JevCircuitBreaker, type CodeSearchWorkspace } from "@opengeni/jev";
 import type { Observability } from "@opengeni/observability";
 import { type SandboxChannelAService } from "@opengeni/runtime/sandbox";
+import { type WorkerDecisionSettings } from "./decision-model.js";
 /**
- * One breaker per worker process. Repeated Jev outages (including an exhausted
+ * One breaker per worker process. Repeated decision-provider outages (including an exhausted
  * account) make `code_search` calls on this worker fail at once for a cooldown
  * instead of each running a full retry cycle. The breaker never changes which
  * tools a turn is offered: the tool list and instructions are the start of the
@@ -15,40 +16,44 @@ export declare const codeSearchCircuitBreaker: JevCircuitBreaker;
 type CodeSearchChannel = Pick<SandboxChannelAService, "codeSearchRipgrep" | "codeSearchPathKinds" | "fsRead">;
 /** Adapt the turn's sandbox or Connected Machine to the code search engine. */
 export declare function codeSearchWorkspaceFromChannel(channel: CodeSearchChannel): CodeSearchWorkspace;
-/** Jev work done by one completed `code_search` call, for per-workspace usage records. */
+/** Typed inference used by one code-search call, owned by the deployment. */
 export type CodeSearchUsage = {
     operationId: string;
-    jevRequests: number;
-    jevInputTokens: number;
-    jevCostUsd: number;
+    decisionRequests: number;
+    decisionInputTokens: number | null;
+    decisionCostUsd: number | null;
+    model: string | null;
+    provider: string | null;
+    costSources: Array<"provider-reported" | "estimate" | "unknown">;
 };
 /**
- * The model-facing `code_search` tool. Jev scores candidates inside the worker;
- * the sandbox only runs read-only ripgrep and file reads, so the Jev key never
- * leaves this process. A Jev failure is reported to the model instead of
+ * The model-facing `code_search` tool. A typed decision model scores candidates
+ * inside the worker; the sandbox only runs read-only ripgrep and file reads, so
+ * provider credentials never leave this process. A provider failure is reported instead of
  * degrading to keyword-only ranking, which lowered answer quality in testing.
  */
 export declare function createCodeSearchAttemptToolDefinition(input: {
-    settings: Pick<Settings, "jevApiKey" | "jevBaseUrl" | "jevModel" | "jevRequestTimeoutMs">;
-    apiKey: string;
+    settings: WorkerDecisionSettings;
+    /** Compatibility for existing direct Jev constructor callers. */
+    apiKey?: string;
     workspace: () => Promise<CodeSearchWorkspace>;
     observability: Observability;
-    /** Records Jev usage against the workspace. Failures are logged, never surfaced. */
+    /** Records decision usage against the workspace. Persistence failures are logged. */
     recordUsage?: (usage: CodeSearchUsage) => Promise<void>;
     breaker?: JevCircuitBreaker;
     fetch?: typeof fetch;
 }): AttemptToolDefinition;
 /**
  * The `code_search` definition for one turn, or none. It is offered only when
- * the session's frozen decision and the deployment enable it, a usable Jev key
+ * the session's frozen decision and the deployment enable it, a usable typed model
  * exists, and the turn has compute that can run its POSIX shell commands (not
  * a Windows Connected Machine). Every input is durable, so the tool list stays
- * the same from turn to turn and on every worker. Transient Jev health never
+ * the same from turn to turn and on every worker. Transient provider health never
  * hides the tool; the breaker only refuses calls.
  */
 export declare function codeSearchToolDefinitions(input: {
     enabled: boolean;
-    settings: Pick<Settings, "jevApiKey" | "jevBaseUrl" | "jevModel" | "jevRequestTimeoutMs">;
+    settings: WorkerDecisionSettings;
     backend: Settings["sandboxBackend"];
     /** The turn's Connected Machine workspace root, when a machine is primary. */
     machineWorkspaceRoot?: string | null;

package/dist/activities/agent-turn/decision-model.d.ts

@@ -0,0 +1,11 @@
+import { type DecisionModelSettings, type Settings } from "@opengeni/config";
+import { type DecisionModel } from "@opengeni/decisions";
+export type WorkerDecisionSettings = DecisionModelSettings & Partial<Pick<Settings, "jevApiKey" | "jevBaseUrl" | "jevModel" | "jevRequestTimeoutMs">>;
+/** One deployment-owned category, consumed by code search and tool discovery. */
+export declare function configuredDecisionModel(settings: WorkerDecisionSettings, options?: {
+    allowLegacyCodeSearch?: boolean;
+    fetch?: typeof fetch;
+}): {
+    id: string;
+    model: DecisionModel;
+} | undefined;

package/dist/activities/agent-turn/provider-dispatch-barrier.d.ts

@@ -4,16 +4,44 @@ export declare class SandboxCapabilitiesChangedError extends Error {
     readonly code = "native_capabilities_changed_this_attempt";
     constructor();
 }
+type ActiveRoutePointer = {
+    activeSandboxId: string | null;
+    activeEpoch: number;
+};
+/**
+ * Ends an attempt between tool batches when its route moved somewhere it can
+ * no longer serve. A swap to a machine with another workspace root (or back
+ * to a home this attempt cannot reach) used to surface only on the first
+ * sandbox call of the following batch: the model's whole next response was
+ * discarded with the attempt, including sibling calls that had already run.
+ * Checking before the next model request ends the attempt at a clean point
+ * instead: the batch that moved the route is complete and durable, and the
+ * next attempt starts on the new route.
+ */
+export declare class ActiveRouteDispatchBoundary {
+    private readonly deps;
+    private observed;
+    constructor(deps: {
+        /** The attempt's routed sandbox session, once one is established. */
+        session: () => {
+            assertActiveRouteContinuable?: () => Promise<void>;
+        } | null | undefined;
+        /** True for a typed transition that must continue in a fresh attempt. */
+        isRouteTransition: (error: unknown) => boolean;
+    });
+    check(active: ActiveRoutePointer | null): Promise<void>;
+}
 /**
  * Persist the SDK's complete prior model/tool history before another provider
  * request can start. The first request has no prior model/tool rows to append.
  * Follow-up requests run only after the preceding complete call/result batch is
- * replay-safe.
+ * replay-safe. A route that moved during that batch to somewhere this attempt
+ * cannot serve ends the attempt here, after the batch is durable.
  */
 export declare function checkpointHistoryBeforeProviderDispatch(historySink: Pick<TurnHistorySink, "reconcileConversationTruth">, route?: {
     effectiveSandboxBackend: Settings["sandboxBackend"];
     routingEnabled: boolean;
-    readActiveSandbox: () => Promise<{
-        activeSandboxId: string | null;
-    } | null>;
+    readActiveSandbox: () => Promise<ActiveRoutePointer | null>;
+    activeRoute?: ActiveRouteDispatchBoundary;
 }): Promise<void>;
+export {};

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

@@ -0,0 +1,21 @@
+import type { Settings } from "@opengeni/config";
+import { type Database } from "@opengeni/db";
+import type { DecisionUsage, DecisionModel } from "@opengeni/decisions";
+/** Explicitly configured typed inference, never a borrowed customer key/subscription. */
+export declare function configuredToolDecisionModel(input: {
+    settings: Settings;
+    recordUsage: (modelId: string, usage: DecisionUsage, requestId: string) => Promise<void>;
+    onUnavailable: () => void;
+    fetch?: typeof fetch;
+}): DecisionModel | undefined;
+export declare function recordToolDecisionUsage(input: {
+    db: Database;
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    turnId: string;
+    turnAttemptId: string;
+    modelId: string;
+    usage: DecisionUsage;
+    requestId: string;
+}): Promise<void>;

package/dist/activities/model-call-fact-reconciler.d.ts

@@ -11,7 +11,7 @@ export type ReconcileRecentModelCallFactsResult = {
     missing: number;
     repaired: number;
     unrepaired: number;
-    /** Workspaces with more missing facts than one bounded pass examines. */
+    /** Workspaces with a durable scan still unfinished at the end of this run. */
     truncatedWorkspaces: number;
     failedWorkspaces: number;
     budgetExhausted: boolean;
@@ -22,6 +22,7 @@ export type ModelCallFactReconcilerOptions = {
     startAfterWorkspaceId?: () => string;
     reconcile?: typeof reconcileModelCallFacts;
     listWorkspaces?: typeof listWorkspaceIdsAfter;
+    signal?: AbortSignal;
 };
 /**
  * Rebuild missing Insights call facts for recently charged model calls. Each

package/dist/{activities-control-KP6WCM3S.js → activities-control-7ZHF4LES.js}

@@ -23,7 +23,7 @@ import {
   withFirstPartyTools,
   workflowIdForSession,
   writeSessionUsageReceipts
-} from "./chunk-3LJG6QJL.js";
+} from "./chunk-5KOLEDGM.js";
 import "./chunk-K225DMA7.js";
 import {
   agentRunAdmissionDenial,
@@ -32,13 +32,13 @@ import {
 import {
   createBrowserDeadlineCheckpointActivities,
   createSandboxLeaseActivities
-} from "./chunk-L5XPJLGD.js";
+} from "./chunk-WGFH4MZV.js";
 import "./chunk-IGTC55IK.js";
 import "./chunk-24GP3BX5.js";
 import {
   recordTurnsQueuedGauge,
   recordWorkerDeathRecoveryMetrics
-} from "./chunk-6AZ2MKJC.js";
+} from "./chunk-AICMJ5A2.js";
 import {
   deliverFailedChildTurnToParent,
   notifyParentOfChildIdle,
@@ -973,6 +973,7 @@ function createFileUploadReaperActivities(services, options = {}) {
 
 // src/activities/model-call-fact-reconciler.ts
 import { randomUUID as randomUUID2 } from "crypto";
+import { Context } from "@temporalio/activity";
 import { listWorkspaceIdsAfter, reconcileModelCallFacts } from "@opengeni/db";
 var MODEL_CALL_FACT_RECONCILE_LOOKBACK_MS = 2 * 60 * 60 * 1e3;
 var MODEL_CALL_FACT_RECONCILE_SETTLE_MS = 10 * 60 * 1e3;
@@ -988,64 +989,127 @@ function createModelCallFactReconcilerActivities(services, options = {}) {
   async function reconcileRecentModelCallFacts() {
     const { db, observability } = await services();
     const startedAt = now();
-    const until = new Date(startedAt - MODEL_CALL_FACT_RECONCILE_SETTLE_MS);
-    const since = new Date(until.getTime() - MODEL_CALL_FACT_RECONCILE_LOOKBACK_MS);
-    const result = {
-      workspaces: 0,
-      missing: 0,
-      repaired: 0,
-      unrepaired: 0,
-      truncatedWorkspaces: 0,
-      failedWorkspaces: 0,
-      budgetExhausted: false
-    };
-    const start = startAfterWorkspaceId();
-    let cursor = start;
-    let wrapped = false;
-    while (true) {
-      const page = await listWorkspaces(db, { afterId: cursor, limit: WORKSPACE_PAGE_SIZE });
-      const ids = wrapped ? page.filter((id) => id <= start) : page;
-      for (const workspaceId of ids) {
-        if (now() - startedAt >= runBudgetMs) {
+    let activity;
+    try {
+      activity = Context.current();
+    } catch {
+    }
+    const callerSignal = options.signal ?? activity?.cancellationSignal;
+    callerSignal?.throwIfAborted();
+    const deadlineAtMs = Date.now() + runBudgetMs;
+    const deadlineError = new Error("Model fact reconciliation run budget exhausted");
+    const deadline = new AbortController();
+    const signal = callerSignal ? AbortSignal.any([callerSignal, deadline.signal]) : deadline.signal;
+    const timer = setTimeout(() => deadline.abort(deadlineError), Math.max(0, runBudgetMs));
+    timer.unref();
+    try {
+      const until = new Date(startedAt - MODEL_CALL_FACT_RECONCILE_SETTLE_MS);
+      const since = new Date(until.getTime() - MODEL_CALL_FACT_RECONCILE_LOOKBACK_MS);
+      const result = {
+        workspaces: 0,
+        missing: 0,
+        repaired: 0,
+        unrepaired: 0,
+        truncatedWorkspaces: 0,
+        failedWorkspaces: 0,
+        budgetExhausted: false
+      };
+      const start = startAfterWorkspaceId();
+      let cursor = start;
+      let wrapped = false;
+      const pending = /* @__PURE__ */ new Set();
+      const exhausted = () => {
+        callerSignal?.throwIfAborted();
+        if (deadline.signal.aborted || now() - startedAt >= runBudgetMs) {
           result.budgetExhausted = true;
-          break;
+          return true;
         }
-        result.workspaces += 1;
+        return false;
+      };
+      const advance = async (workspaceId) => {
         try {
+          signal.throwIfAborted();
+          activity?.heartbeat({ workspaceId });
           const outcome = await reconcile(db, {
             workspaceId,
             since,
             until,
-            limit: MODEL_CALL_FACT_RECONCILE_WORKSPACE_LIMIT
+            limit: MODEL_CALL_FACT_RECONCILE_WORKSPACE_LIMIT,
+            signal,
+            deadlineAtMs
           });
           result.missing += outcome.missing;
           result.repaired += outcome.repaired;
           result.unrepaired += outcome.unrepaired;
-          if (outcome.truncated) result.truncatedWorkspaces += 1;
+          if (outcome.truncated) pending.add(workspaceId);
+          else pending.delete(workspaceId);
         } catch (error) {
-          result.failedWorkspaces += 1;
+          if (signal.aborted && signal.reason === deadlineError) {
+            pending.add(workspaceId);
+            result.budgetExhausted = true;
+            return;
+          }
+          signal?.throwIfAborted();
+          pending.delete(workspaceId);
+          result.failedWorkspaces++;
           observability.warn("model call fact reconciliation failed for a workspace", {
             workspaceId,
             errorName: error instanceof Error ? error.name : "unknown"
           });
         }
+      };
+      while (true) {
+        if (exhausted()) break;
+        let page;
+        try {
+          page = await listWorkspaces(db, {
+            afterId: cursor,
+            limit: WORKSPACE_PAGE_SIZE,
+            signal,
+            deadlineAtMs
+          });
+        } catch (error) {
+          callerSignal?.throwIfAborted();
+          if (deadline.signal.aborted) {
+            result.budgetExhausted = true;
+            break;
+          }
+          throw error;
+        }
+        const ids = wrapped ? page.filter((id) => id <= start) : page;
+        for (const workspaceId of ids) {
+          if (exhausted()) break;
+          result.workspaces += 1;
+          await advance(workspaceId);
+          if (result.budgetExhausted) break;
+        }
+        if (result.budgetExhausted) break;
+        if (wrapped && ids.length < page.length) break;
+        if (page.length < WORKSPACE_PAGE_SIZE) {
+          if (wrapped) break;
+          wrapped = true;
+          cursor = null;
+          continue;
+        }
+        cursor = page[page.length - 1];
       }
-      if (result.budgetExhausted) break;
-      if (wrapped && ids.length < page.length) break;
-      if (page.length < WORKSPACE_PAGE_SIZE) {
-        if (wrapped) break;
-        wrapped = true;
-        cursor = null;
-        continue;
+      while (pending.size && !result.budgetExhausted) {
+        for (const workspaceId of [...pending]) {
+          if (exhausted()) break;
+          await advance(workspaceId);
+          if (result.budgetExhausted) break;
+        }
       }
-      cursor = page[page.length - 1];
-    }
-    if (result.failedWorkspaces > 0 || result.truncatedWorkspaces > 0 || result.budgetExhausted) {
-      observability.warn("model call fact reconciliation incomplete", { ...result });
-    } else if (result.missing > 0) {
-      observability.info("model call fact reconciliation", { ...result });
+      result.truncatedWorkspaces = pending.size;
+      if (result.failedWorkspaces > 0 || result.truncatedWorkspaces > 0 || result.budgetExhausted) {
+        observability.warn("model call fact reconciliation incomplete", { ...result });
+      } else if (result.missing > 0) {
+        observability.info("model call fact reconciliation", { ...result });
+      }
+      return result;
+    } finally {
+      clearTimeout(timer);
     }
-    return result;
   }
   return { reconcileRecentModelCallFacts };
 }
@@ -2654,7 +2718,7 @@ import {
   resolveTurnExecutionPolicyV1 as resolveTurnExecutionPolicyV12,
   TurnExecutionPolicyModelUnavailableError
 } from "@opengeni/config";
-import { Context } from "@temporalio/activity";
+import { Context as Context2 } from "@temporalio/activity";
 import { createHash as createHash2 } from "crypto";
 
 // src/scheduled-alert-occurrence.ts
@@ -2784,7 +2848,7 @@ function scheduledTaskRunProducerKey(input, suppliedActivityIdentity) {
   let info = suppliedActivityIdentity;
   if (!info) {
     try {
-      info = Context.current().info;
+      info = Context2.current().info;
     } catch {
       throw new Error(
         "scheduled task delivery without a producer key requires a Temporal activity execution"
@@ -6350,4 +6414,4 @@ export {
   createControlActivities,
   createControlActivitiesFromServices
 };
-//# sourceMappingURL=activities-control-KP6WCM3S.js.map
+//# sourceMappingURL=activities-control-7ZHF4LES.js.map