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

package/dist/{activities-turn-7ESD3YJB.js → activities-turn-7VX4IWPO.js}

@@ -1,4 +1,5 @@
 import {
+  ActiveRouteDispatchBoundary,
   CLAUDE_CORE_WAIT_BINDING,
   CODEX_CORE_WAIT_BINDING,
   FIRST_PARTY_MCP_SETUP_UNAVAILABLE_CODE,
@@ -112,7 +113,7 @@ import {
   wakeSubscriptionCoreWaitersAndDeliver,
   withFirstPartyTools,
   withModelRoutePresentation
-} from "./chunk-3LJG6QJL.js";
+} from "./chunk-5KOLEDGM.js";
 import "./chunk-K225DMA7.js";
 import {
   agentBackgroundCommandDeps,
@@ -164,7 +165,7 @@ import {
   runtimeMetricsHooksForObservability,
   sandboxAutomaticRecoveryOutcome,
   turnLifecycleMetricsFor
-} from "./chunk-6AZ2MKJC.js";
+} from "./chunk-AICMJ5A2.js";
 import {
   deliverChildRequiresActionToParent,
   deliverFailedChildTurnToParent
@@ -1269,11 +1270,11 @@ function requiresSignedFileResourceDownloads(settings, activeSandboxBackend = se
   if (activeSandboxBackend === "none") {
     return false;
   }
-  if (activeSandboxBackend === "selfhosted") {
+  const bucketMount = CAPABILITY_DESCRIPTORS[activeSandboxBackend].bucketMount;
+  if (bucketMount === "none") {
     return true;
   }
-  const nativeBucketMount = CAPABILITY_DESCRIPTORS[activeSandboxBackend].nativeBucketMount;
-  return activeSandboxBackend === "docker" && settings.objectStorageBackend === "s3-compatible" || settings.objectStorageBackend === "aws-s3" || settings.objectStorageBackend === "gcs" || nativeBucketMount && settings.objectStorageBackend === "azure-blob";
+  return activeSandboxBackend === "docker" && settings.objectStorageBackend === "s3-compatible" || settings.objectStorageBackend === "aws-s3" || settings.objectStorageBackend === "gcs" || bucketMount === "native" && settings.objectStorageBackend === "azure-blob";
 }
 function objectStorageForSandboxDownloads(settings, objectStorage, activeSandboxBackend = settings.sandboxBackend) {
   if (activeSandboxBackend === "selfhosted") {
@@ -26148,7 +26149,9 @@ var providerKinds = {
   "opper-workspace": "opper",
   "opper-organization": "opper",
   "anthropic-workspace": "anthropic",
-  "anthropic-organization": "anthropic"
+  "anthropic-organization": "anthropic",
+  "direct-openai-organization": "openai",
+  "direct-azure-organization": "azure_openai"
 };
 async function sessionTitleApiConnectionId(input) {
   const { db, settings, provider, workspaceId, accountId } = input;
@@ -26167,7 +26170,7 @@ async function sessionTitleApiConnectionId(input) {
   }
   const kind = providerKinds[provider.kind];
   if (provider.credentialSource.kind === "workspace_connection") {
-    if (!kind)
+    if (!kind || kind === "openai" || kind === "azure_openai")
       throw new SessionTitleRouteUnavailableError("Title workspace provider is unsupported");
     const metadata = await getWorkspaceProviderApiKeyConnectionMetadata(db, workspaceId, kind);
     const spec = workspaceProviderApiKeyConnectionSpec(kind);
@@ -36064,7 +36067,8 @@ function createRefreshCredentialsAttemptToolDefinition(input) {
 }
 
 // src/activities/agent-turn/code-search.ts
-import { usableJevApiKey } from "@opengeni/config";
+import { decisionModelConfiguration as decisionModelConfiguration2 } from "@opengeni/config";
+import { DecisionUnavailableError, DecisionRequestError } from "@opengeni/decisions";
 import {
   CODE_SEARCH_TOOL_DESCRIPTION,
   CODE_SEARCH_TOOL_NAME,
@@ -36072,9 +36076,6 @@ import {
   CodeSearchRipgrepMissingError,
   CodeSearchWorkspaceError,
   JevCircuitBreaker,
-  JevClient,
-  JevRequestError,
-  JevUnavailableError,
   codeSearchInputSchema,
   parseCodeSearchArguments,
   renderCodeSearchError,
@@ -36087,6 +36088,35 @@ import {
   ChannelAValidationError,
   isWindowsConnectedMachinePath
 } from "@opengeni/runtime/sandbox";
+
+// src/activities/agent-turn/decision-model.ts
+import {
+  decisionModelConfiguration
+} from "@opengeni/config";
+import { createHttpDecisionModel } from "@opengeni/decisions";
+import { createJevDecisionModel, JevClient } from "@opengeni/jev";
+function configuredDecisionModel(settings, options = {}) {
+  const config2 = decisionModelConfiguration(settings, options.allowLegacyCodeSearch);
+  if (!config2) return void 0;
+  const model = config2.provider === "jev" ? createJevDecisionModel(
+    new JevClient({
+      apiKey: config2.apiKey,
+      model: config2.model,
+      ...config2.baseUrl ? { baseUrl: config2.baseUrl } : {},
+      ...settings.jevRequestTimeoutMs !== void 0 ? { timeoutMs: settings.jevRequestTimeoutMs } : {},
+      ...options.fetch ? { fetch: options.fetch } : {}
+    })
+  ) : createHttpDecisionModel({
+    provider: config2.provider,
+    model: config2.model,
+    apiKey: config2.apiKey,
+    ...config2.baseUrl ? { endpoint: `${config2.baseUrl.replace(/\/$/, "")}/decisions` } : {},
+    ...options.fetch ? { fetch: options.fetch } : {}
+  });
+  return { id: `${config2.provider}/${config2.model}`, model };
+}
+
+// src/activities/agent-turn/code-search.ts
 var codeSearchCircuitBreaker = new JevCircuitBreaker();
 var CODE_SEARCH_RIPGREP_MAX_BYTES = 32 * 1024 * 1024;
 function codeSearchWorkspaceFromChannel(channel) {
@@ -36126,13 +36156,18 @@ function textResult(text, isError) {
 }
 function createCodeSearchAttemptToolDefinition(input) {
   const breaker = input.breaker ?? codeSearchCircuitBreaker;
-  const jev = new JevClient({
-    apiKey: input.apiKey,
-    baseUrl: input.settings.jevBaseUrl,
-    model: input.settings.jevModel,
-    timeoutMs: input.settings.jevRequestTimeoutMs,
-    ...input.fetch ? { fetch: input.fetch } : {}
-  });
+  const configured = configuredDecisionModel(
+    {
+      ...input.settings,
+      ...input.apiKey ? { jevApiKey: input.apiKey } : {}
+    },
+    {
+      allowLegacyCodeSearch: true,
+      ...input.fetch ? { fetch: input.fetch } : {}
+    }
+  );
+  if (!configured)
+    throw new DecisionUnavailableError("Code search needs a configured decision model");
   return {
     identity: { serverId: "opengeni", toolName: CODE_SEARCH_TOOL_NAME },
     modelName: CODE_SEARCH_TOOL_NAME,
@@ -36152,8 +36187,11 @@ function createCodeSearchAttemptToolDefinition(input) {
     execute: async (args, context) => {
       const startedAt = performance.now();
       let outcome = "failed";
-      let jevRequests = 0;
-      let jevCostUsd = 0;
+      let decisionRequests = 0;
+      let decisionCostUsd = 0;
+      let decisionInputTokens = 0;
+      let decisionModel = null, decisionProvider = null;
+      const costSources = /* @__PURE__ */ new Set();
       let lease = null;
       try {
         const request = parseCodeSearchArguments(args);
@@ -36162,7 +36200,9 @@ function createCodeSearchAttemptToolDefinition(input) {
           outcome = "breaker_open";
           return textResult(
             renderCodeSearchError(
-              new JevUnavailableError("Jev is not responding; calls are paused for a few minutes")
+              new DecisionUnavailableError(
+                "The decision model is not responding; calls are paused for a few minutes"
+              )
             ),
             true
           );
@@ -36171,33 +36211,27 @@ function createCodeSearchAttemptToolDefinition(input) {
         const result = await runCodeSearch({
           ...request,
           workspace,
-          jev,
+          decisionModel: configured.model,
+          onDecisionUsage: (usage) => {
+            decisionRequests += usage.requests;
+            decisionInputTokens = decisionInputTokens === null || usage.inputTokens === null ? null : decisionInputTokens + usage.inputTokens;
+            decisionCostUsd = decisionCostUsd === null || usage.costUsd === null ? null : decisionCostUsd + usage.costUsd;
+            decisionModel = usage.model;
+            decisionProvider = usage.provider;
+            costSources.add(usage.costSource);
+          },
           ...context.signal ? { signal: context.signal } : {}
         });
         const held = lease;
         lease = null;
-        if (result.statusCheckError instanceof JevUnavailableError) {
+        if (result.statusCheckError instanceof DecisionUnavailableError) {
           breaker.recordFailure(result.statusCheckError, Date.now(), held);
-        } else if (result.stats.jev.requests > 0) {
+        } else if (result.stats.decision.requests > 0) {
           breaker.recordSuccess(held);
         } else {
           breaker.release(held);
         }
         outcome = "completed";
-        jevRequests = result.stats.jev.requests;
-        jevCostUsd = result.stats.jev.costUsd;
-        if (input.recordUsage && jevRequests > 0) {
-          await input.recordUsage({
-            operationId: context.operationId,
-            jevRequests,
-            jevInputTokens: result.stats.jev.inputTokens,
-            jevCostUsd
-          }).catch((error51) => {
-            input.observability.warn("code_search usage record failed", {
-              error: error51 instanceof Error ? error51.message : String(error51)
-            });
-          });
-        }
         return textResult(result.text, false);
       } catch (error51) {
         if (context.signal?.aborted) {
@@ -36208,15 +36242,15 @@ function createCodeSearchAttemptToolDefinition(input) {
           outcome = "invalid_arguments";
           return textResult(error51.message, true);
         }
-        if (error51 instanceof JevUnavailableError) {
+        if (error51 instanceof DecisionUnavailableError) {
           const held = lease;
           lease = null;
           breaker.recordFailure(error51, Date.now(), held);
-          outcome = "jev_unavailable";
+          outcome = "decision_unavailable";
           return textResult(renderCodeSearchError(error51), true);
         }
-        if (error51 instanceof JevRequestError) {
-          outcome = "jev_rejected";
+        if (error51 instanceof DecisionRequestError) {
+          outcome = "decision_rejected";
           return textResult(renderCodeSearchError(error51), true);
         }
         if (error51 instanceof CodeSearchWorkspaceError) {
@@ -36233,27 +36267,41 @@ function createCodeSearchAttemptToolDefinition(input) {
         throw error51;
       } finally {
         if (lease) breaker.release(lease);
+        if (input.recordUsage && decisionRequests > 0) {
+          await input.recordUsage({
+            operationId: context.operationId,
+            decisionRequests,
+            decisionInputTokens,
+            decisionCostUsd,
+            model: decisionModel,
+            provider: decisionProvider,
+            costSources: [...costSources]
+          }).catch((error51) => {
+            input.observability.warn("code_search usage record failed", {
+              error: error51 instanceof Error ? error51.message : String(error51)
+            });
+          });
+        }
         recordCodeSearchCall(input.observability, {
           outcome,
           durationSeconds: (performance.now() - startedAt) / 1e3,
-          jevRequests,
-          jevCostUsd
+          decisionRequests,
+          decisionCostUsd
         });
       }
     }
   };
 }
 function codeSearchToolDefinitions(input) {
-  const apiKey = usableJevApiKey(input.settings);
+  const config2 = decisionModelConfiguration2(input.settings, true);
   const breaker = input.breaker ?? codeSearchCircuitBreaker;
-  if (!input.enabled || !apiKey || input.backend === "none") return [];
+  if (!input.enabled || !config2 || input.backend === "none") return [];
   if (input.machineWorkspaceRoot && isWindowsConnectedMachinePath(input.machineWorkspaceRoot)) {
     return [];
   }
   return [
     createCodeSearchAttemptToolDefinition({
       settings: input.settings,
-      apiKey,
       workspace: input.workspace,
       observability: input.observability,
       ...input.recordUsage ? { recordUsage: input.recordUsage } : {},
@@ -38255,7 +38303,7 @@ async function prepareTurnToolRuntime(deps) {
     backend: activeSandboxBackend ?? groupBoxBackend,
     machineWorkspaceRoot: sandboxState.machinePrimarySession?.workspaceRoot ?? null,
     observability,
-    // Opengeni's Jev key pays for these calls whatever model billing the
+    // The deployment's decision-model account pays whatever model billing the
     // workspace uses; record them per workspace so the cost stays visible.
     recordUsage: async (usage) => {
       const shared = {
@@ -38267,20 +38315,23 @@ async function prepareTurnToolRuntime(deps) {
         turnId: turn.id,
         turnAttemptId: input.attemptId
       };
-      await recordUsageEvent3(db, {
-        ...shared,
-        eventType: "code_search.jev_input_tokens",
-        quantity: usage.jevInputTokens,
-        unit: "tokens",
-        idempotencyKey: `usage:code_search.jev_input_tokens:${input.attemptId}:${usage.operationId}`
-      });
-      await recordUsageEvent3(db, {
-        ...shared,
-        eventType: "code_search.jev_cost",
-        quantity: Math.round(usage.jevCostUsd * 1e6),
-        unit: "usd_micros",
-        idempotencyKey: `usage:code_search.jev_cost:${input.attemptId}:${usage.operationId}`
-      });
+      if (usage.decisionInputTokens !== null)
+        await recordUsageEvent3(db, {
+          ...shared,
+          eventType: "code_search.decision_input_tokens",
+          quantity: usage.decisionInputTokens,
+          unit: "tokens",
+          idempotencyKey: `usage:code_search.decision_input_tokens:${input.attemptId}:${usage.operationId}`
+        });
+      const costEvent = usage.costSources.includes("estimate") ? "decision_estimated_cost" : "decision_cost";
+      if (usage.decisionCostUsd !== null)
+        await recordUsageEvent3(db, {
+          ...shared,
+          eventType: `code_search.${costEvent}`,
+          quantity: Math.round(usage.decisionCostUsd * 1e6),
+          unit: "usd_micros",
+          idempotencyKey: `usage:code_search.${costEvent}:${input.attemptId}:${usage.operationId}`
+        });
     },
     workspace: async () => {
       throwIfWorkerShuttingDown();
@@ -40490,6 +40541,59 @@ import { SandboxChannelAService as SandboxChannelAService4 } from "@opengeni/run
 import { sandboxRunAs as sandboxRunAs5 } from "@opengeni/runtime";
 import { VideoGenerationRejectedResult, resolveAgentToolFamilies as resolveAgentToolFamilies2 } from "@opengeni/contracts";
 
+// src/activities/agent-turn/tool-discovery.ts
+import { recordUsageEvent as recordUsageEvent4 } from "@opengeni/db";
+function configuredToolDecisionModel(input) {
+  const route = configuredDecisionModel(input.settings, input.fetch ? { fetch: input.fetch } : {});
+  if (!route) {
+    if (input.settings.decisionModelProvider || input.settings.decisionModelId || input.settings.decisionModelApiKey || input.settings.decisionModelBaseUrl)
+      input.onUnavailable();
+    return void 0;
+  }
+  return {
+    async decide(state, questions, options = {}) {
+      const requestId = crypto.randomUUID();
+      return await runAuxiliaryProviderDispatch(
+        () => route.model.decide(state, questions, {
+          ...options,
+          onUsage: async (usage) => {
+            await input.recordUsage(route.id, usage, requestId);
+            await options.onUsage?.(usage);
+          }
+        })
+      );
+    }
+  };
+}
+async function recordToolDecisionUsage(input) {
+  const entries = [
+    ["input_tokens", input.usage.inputTokens, "tokens"],
+    ["output_tokens", input.usage.outputTokens, "tokens"],
+    [
+      input.usage.costSource === "estimate" ? "estimated_provider_cost" : "provider_cost",
+      input.usage.costUsd === null ? null : Math.round(input.usage.costUsd * 1e6),
+      "usd_micros"
+    ]
+  ];
+  const identity = input.usage.requestId ?? input.requestId;
+  for (const [category, quantity, unit] of entries) {
+    if (quantity === null) continue;
+    await recordUsageEvent4(input.db, {
+      accountId: input.accountId,
+      workspaceId: input.workspaceId,
+      sessionId: input.sessionId,
+      turnId: input.turnId,
+      turnAttemptId: input.turnAttemptId,
+      sourceResourceType: "tool_discovery",
+      sourceResourceId: `${input.modelId}:${identity}`,
+      eventType: `tool_discovery.${category}`,
+      quantity,
+      unit,
+      idempotencyKey: `usage:tool_discovery:${category}:${input.turnAttemptId}:${identity}`
+    });
+  }
+}
+
 // src/activities/agent-turn/video-reference-sandbox.ts
 async function resolveVideoReferenceSandboxAccess(request, sandboxState, sdkOwnedSandboxSession) {
   if (videoReferencePaths(request).length === 0) return null;
@@ -41029,9 +41133,9 @@ async function buildTurnAgent(deps) {
         connectorActionPolicy,
         attemptConnectorActionBindings,
         ...approvedToolCallId ? { approvedToolCallId } : {},
-        // LIVE by-reference connector namespaces (fills during this turn's
-        // codex_apps tools/list): the codex tool_search description reads it per
-        // model call so the model sees the account's real connected sources.
+        // Legacy connector metadata remains available to non-progressive paths.
+        // Progressive discovery reads the authorized pool, never a changing
+        // source directory in its first-request control schemas.
         codexConnectorNamespaces: preparedTools.codexConnectorNamespaces,
         // Resolved-model routing + gating (legacy defaults when null). The model
         // is passed as the model *string* (agent.model = runSettings.openaiModel),
@@ -41051,6 +41155,23 @@ async function buildTurnAgent(deps) {
         ...imageGenerationOption,
         ...videoGenerationOption,
         lazyToolTransport,
+        toolSearchDecisionModel: configuredToolDecisionModel({
+          settings: runSettings,
+          onUnavailable: () => observability.warn(
+            "Configured decision model is unavailable; using lexical tool discovery"
+          ),
+          recordUsage: (modelId, usage, requestId) => recordToolDecisionUsage({
+            db,
+            accountId: input.accountId,
+            workspaceId: input.workspaceId,
+            sessionId: input.sessionId,
+            turnId: turn.id,
+            turnAttemptId: input.attemptId,
+            modelId,
+            usage,
+            requestId
+          })
+        }),
         ...eventing.toolPreparationReady ? {
           toolPreparationReady: eventing.toolPreparationReady,
           ...eventing.preparedTools?.startDeferredPreparation ? { startToolPreparation: eventing.preparedTools.startDeferredPreparation } : {}
@@ -41389,13 +41510,18 @@ function createRunAgentTurnActivity(services) {
       providerRecoveryCount: attempt.providerRecoveryCount,
       recoveryStartedAt: attempt.providerRecoveryStartedAt
     });
+    const activeRoute = new ActiveRouteDispatchBoundary({
+      session: () => sandboxState.resolvedSandbox?.established.session,
+      isRouteTransition: (error51) => sandboxRouteTransitionCode(error51) !== null
+    });
     const checkpointBeforeProviderDispatch = async () => {
       assertRecoveryWindow();
       await awaitModelCallAdmission();
       await checkpointHistoryBeforeProviderDispatch(historySink, {
         effectiveSandboxBackend: eventing.modelRunSettings.sandboxBackend,
         routingEnabled: routingEnabled(settings),
-        readActiveSandbox: () => readActiveSandbox3(db, input.workspaceId, input.sessionId)
+        readActiveSandbox: () => readActiveSandbox3(db, input.workspaceId, input.sessionId),
+        activeRoute
       });
       assertRecoveryWindow();
     };
@@ -44085,4 +44211,4 @@ export {
   createTurnActivities,
   createTurnActivitiesFromServices
 };
-//# sourceMappingURL=activities-turn-7ESD3YJB.js.map
+//# sourceMappingURL=activities-turn-7VX4IWPO.js.map