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

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

@@ -63,6 +63,8 @@ export type BuildTurnAgentDeps = {
     connectorActionPolicy: ConnectorActionPolicyHooks;
     trigger: ClaimTurnOk["trigger"];
     preparationIndependentToolNames: readonly string[];
+    /** The attempt's tool catalog includes the Jev-backed code_search tool. */
+    codeSearchAvailable: boolean;
     videoGenerationAcceptancesByCallId: Map<string, {
         operationId: string;
         requestDigest: string;

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

@@ -0,0 +1,60 @@
+import type { AttemptToolDefinition } from "@opengeni/codemode";
+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";
+/**
+ * One breaker per worker process. Repeated Jev 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
+ * model's cached prompt, and sessions move between workers whose breakers
+ * disagree.
+ */
+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. */
+export type CodeSearchUsage = {
+    operationId: string;
+    jevRequests: number;
+    jevInputTokens: number;
+    jevCostUsd: number;
+};
+/**
+ * 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
+ * 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;
+    workspace: () => Promise<CodeSearchWorkspace>;
+    observability: Observability;
+    /** Records Jev usage against the workspace. Failures are logged, never surfaced. */
+    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
+ * 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
+ * hides the tool; the breaker only refuses calls.
+ */
+export declare function codeSearchToolDefinitions(input: {
+    enabled: boolean;
+    settings: Pick<Settings, "jevApiKey" | "jevBaseUrl" | "jevModel" | "jevRequestTimeoutMs">;
+    backend: Settings["sandboxBackend"];
+    /** The turn's Connected Machine workspace root, when a machine is primary. */
+    machineWorkspaceRoot?: string | null;
+    observability: Observability;
+    workspace: () => Promise<CodeSearchWorkspace>;
+    recordUsage?: (usage: CodeSearchUsage) => Promise<void>;
+    breaker?: JevCircuitBreaker;
+}): AttemptToolDefinition[];
+export {};

package/dist/activities/agent-turn/codex-capacity.d.ts

@@ -1,8 +1,21 @@
 import { type Settings } from "@opengeni/config";
 import type { TurnActivityServices as ActivityServices, RunAgentTurnInput, RunAgentTurnResult } from "../types.js";
 import { createTurnCredentialLeases } from "./credential-leases.js";
+import { type LogThrottle } from "@opengeni/observability";
 import type { ClaimTurnOk } from "./claim.js";
 import type { AttemptIdentityState, BillingState, ClaimedResult, EventingState, ProviderTurnState, TurnControlState } from "./turn-context.js";
+/** The eligible-pool gauge and `opengeni_codex_pool_low_total` stay per turn;
+ * the warning line is the first observation per workspace pool depth, then at
+ * most one per interval with the count it hid. The public log projection drops
+ * the identifiers and counts, so the closed `reason` keeps the depth visible. */
+export declare const CODEX_POOL_LOW_WARNING_INTERVAL_MS: number;
+export declare function warnCodexPoolLow(observability: Pick<ActivityServices["observability"], "warn">, input: {
+    workspaceKey: string;
+    workspaceId: string;
+    eligibleCount: number;
+    connectedCount: number;
+    depth: "zero" | "one";
+}, throttle?: LogThrottle): void;
 export type CapacityPhaseDeps = {
     input: RunAgentTurnInput;
     settings: Settings;

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

@@ -1,4 +1,4 @@
-import { type CompactionProviderRejection, type MaterializationVerificationDiagnostic } from "@opengeni/runtime";
+import { type CompactionProviderRejection, type MaterializationVerificationDiagnostic, type ProviderQuotaExhaustion, type ProviderQuotaScope } from "@opengeni/runtime";
 import { type McpTransportRequestFailureDiagnostic } from "@opengeni/runtime/mcp-network";
 import { ApplicationFailure } from "@temporalio/activity";
 import type { CodexAccountStatus } from "@opengeni/db";
@@ -168,6 +168,7 @@ export declare function compactionFailureTurnEventPayload(error: unknown, overri
     recovery: "user_message";
     compacted: false;
     providerRejection?: CompactionProviderRejection;
+    quotaScope?: ProviderQuotaScope;
 };
 export declare function isCompactionSummaryFailure(error: unknown): boolean;
 export declare function shouldRecoverCompactionProviderFailure(error: unknown): boolean;
@@ -235,6 +236,15 @@ export declare function collectErrorStrings(value: unknown, seen?: WeakSet<objec
 export declare const STATUSLESS_UPSTREAM_CONNECTIVITY_MESSAGE = "unable to connect. is the computer able to access the url?";
 export declare function isExactStatuslessUpstreamConnectivityMessage(message: string): boolean;
 export declare function isTransientProviderError(error: unknown): boolean;
+/**
+ * Recognize an exhausted API-key provider quota (a daily or monthly allowance,
+ * a free-tier day cap, or an account out of credits) as distinct from an
+ * ordinary per-minute rate limit. Retrying within the bounded same-turn budget
+ * cannot succeed, so the turn fails promptly instead. Subscription transports
+ * own their quota semantics through credential rotation and durable capacity
+ * waits, so a Codex or SuperGrok transport error never classifies here.
+ */
+export declare function classifyProviderQuotaExhaustionError(error: unknown): ProviderQuotaExhaustion | null;
 export type XaiCredentialFailure = {
     kind: "auth" | "forbidden" | "rate_limit";
     cooldownMs: number | null;
@@ -271,6 +281,7 @@ declare function baseAgentRunFailurePayload(error: unknown, options?: {
     historyPersistenceStage?: MandatoryHistoryPersistenceStage;
     mcpTransportDiagnostic?: McpTransportRequestFailureDiagnostic;
     materializationDiagnostic?: MaterializationVerificationDiagnostic;
+    quotaScope?: ProviderQuotaScope;
 };
 export type CodexCredentialFailure = {
     kind: "auth" | "forbidden" | "rate_limit" | "quota";

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

@@ -37,6 +37,8 @@ export type GovernanceModelOk = {
     rigVersion: NonNullable<Awaited<ReturnType<typeof materializeRigVersionForAttempt>>>["version"] | null;
     rigName: string | null;
     agentHumanInputEnabled: boolean;
+    /** Deployment and workspace allow the Jev-backed code_search tool. */
+    codeSearchEnabled: boolean;
     workspaceAgentInstructions: string | null | undefined;
     workspaceGovernance: ReturnType<typeof renderWorkspaceGovernanceContext>;
     structuredWorkspacePolicyActive: boolean;

package/dist/activities/agent-turn/session-title.d.ts

@@ -1,6 +1,7 @@
 import type { AttemptToolDefinition } from "@opengeni/codemode";
-import type { GeneratedSessionTitle } from "@opengeni/runtime";
-import { type FirstPartyMcpToolName, type Permission, type ToolRef } from "@opengeni/contracts";
+import { type ModelCapabilitiesV1 } from "@opengeni/config";
+import type { GeneratedSessionTitle, GenerateSessionTitleOptions, OpenGeniRuntime } from "@opengeni/runtime";
+import { ReasoningEffort, type FirstPartyMcpToolName, type Permission, type ToolRef } from "@opengeni/contracts";
 export declare const SESSION_TITLE_MODEL_TOOL_NAME = "opengeni__set_session_title";
 export declare function shouldRequestMissingSessionTitle(input: {
     title: string | null;
@@ -8,11 +9,21 @@ export declare function shouldRequestMissingSessionTitle(input: {
     firstPartyMcpTools: readonly FirstPartyMcpToolName[];
     firstPartyMcpPermissions: readonly Permission[] | null;
 }): boolean;
+/**
+ * Whether the turn's route can afford a model request spent only on a title.
+ * The managed OpenRouter free route draws on one deployment-wide per-minute
+ * and per-day request quota that users' turns need, so an untitled session on
+ * it gets no title sidecar and no title tool (whose call would cost a
+ * follow-up request). Clients keep showing the prompt preview, and a later
+ * turn on another route titles the session.
+ */
+export declare function routeAllowsSessionTitleRequests(resolvedModel: ReturnType<OpenGeniRuntime["resolveTurnModel"]>): boolean;
 export declare function sessionTitleToolPlan(input: {
     tools: readonly ToolRef[];
     selectedFirstPartyMcpTools: readonly FirstPartyMcpToolName[];
     shouldRequestTitle: boolean;
     parallelGenerationAvailable: boolean;
+    routeAllowsTitleRequests: boolean;
 }): {
     promoteTitleTool: boolean;
     generateTitleInParallel: boolean;
@@ -20,6 +31,25 @@ export declare function sessionTitleToolPlan(input: {
     preparationIndependentToolNames: string[];
 };
 export declare const PARALLEL_SESSION_TITLE_TIMEOUT_MS = 15000;
+/**
+ * The lowest reasoning effort the resolved model can run, for the auxiliary
+ * title request only. A title needs no deliberation, and a provider default
+ * effort can use most of the output budget before any visible text. Returns
+ * undefined when the model declares no runnable reasoning control, so the
+ * request carries no reasoning parameter.
+ */
+export declare function sessionTitleReasoningEffort(capabilities: Pick<ModelCapabilitiesV1, "reasoning"> | undefined): ReasoningEffort | undefined;
+/**
+ * Options for the parallel title request. It uses the turn's resolved
+ * provider and credential authority, but its own lowest runnable reasoning
+ * effort rather than the turn's effort.
+ */
+export declare function sessionTitleGenerationOptions(input: {
+    resolvedModel: ReturnType<OpenGeniRuntime["resolveTurnModel"]>;
+    modelName: string;
+    serviceTier: GenerateSessionTitleOptions["serviceTier"] | null | undefined;
+    signal: AbortSignal;
+}): GenerateSessionTitleOptions;
 export type ParallelSessionTitleGeneration = {
     finish: () => Promise<GeneratedSessionTitle | null>;
     cancel: () => Promise<void>;

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

@@ -46,6 +46,7 @@ export type PrepareTurnToolRuntimeDeps = {
     turnExecutionPolicy: ClaimTurnOk["turnExecutionPolicy"];
     trigger: ClaimTurnOk["trigger"];
     runSettings: GovernanceModelOk["runSettings"];
+    resolvedModel: GovernanceModelOk["resolvedModel"];
     lazyToolTransport: GovernanceModelOk["lazyToolTransport"];
     turnTools: ReturnType<typeof withFirstPartyTools>;
     connectionScope: {
@@ -60,6 +61,8 @@ export type PrepareTurnToolRuntimeDeps = {
     credentialSubjectId: ClaimTurnOk["credentialSubjectId"];
     interactionInterventionResume: ClaimTurnOk["interactionInterventionResume"];
     runWorkspaceMutationForSandbox: SandboxTurnRuntime["runWorkspaceMutationForSandbox"];
+    /** Deployment and workspace allow the Jev-backed code_search tool. */
+    codeSearchEnabled: boolean;
     throwIfWorkerShuttingDown: () => void;
     throwIfTurnCancelled: () => void;
 };
@@ -162,6 +165,7 @@ export declare function prepareTurnToolRuntime(deps: PrepareTurnToolRuntimeDeps)
     generateSessionTitleInParallel: boolean;
     postToolPreparationStartedAt: number;
     preparationIndependentToolNames: string[];
+    codeSearchAvailable: boolean;
     skillCatalog: {
         id: string;
         name: string;

package/dist/activities/context-compaction.d.ts

@@ -1,5 +1,5 @@
 import { type Database } from "@opengeni/db";
-import { type CompactionItem, type CompactionProviderRejection } from "@opengeni/runtime";
+import { prepareCompactionPromptInput, type CompactionItem, type CompactionProviderRejection } from "@opengeni/runtime";
 import { type Settings } from "@opengeni/config";
 import type { SessionEvent } from "@opengeni/contracts";
 export type MaybeCompactResult = {
@@ -28,7 +28,10 @@ export type MaybeCompactResult = {
  * Codex, call Codex `/codex/responses` with `compaction_trigger` and persist the
  * opaque compaction item. Fail closed — never silently fall back to portable.
  */
-export type CompactionSummarizer = (settings: Settings, input: CompactionItem[]) => Promise<string>;
+export type CompactionSummarizer = ((settings: Settings, input: CompactionItem[]) => Promise<string>) & {
+    /** Model-visible instructions and tool schemas outside the history estimate. */
+    estimatePrefixTokens?: () => number;
+};
 /** Returns the opaque Codex remote compaction v2 item. */
 export type RemoteCompactionV2Requester = (settings: Settings, input: CompactionItem[]) => Promise<CompactionItem>;
 export declare function maybeCompactContext(db: Database, settings: Settings, scope: {
@@ -86,5 +89,10 @@ export declare function settleFailedContextCompactionLandmark(db: Database, scop
 }): Promise<Extract<MaybeCompactResult, {
     compacted: false;
 }>>;
+export declare function summarizeWithCodexOverflowTrimming(summarize: CompactionSummarizer, settings: Settings, activeHistory: CompactionItem[]): Promise<{
+    summaryBody: string;
+    preparation: ReturnType<typeof prepareCompactionPromptInput>;
+    providerCalls: number;
+}>;
 export declare function isContextWindowExceeded(error: unknown, seen?: WeakSet<object>): boolean;
 export declare function isExactContextLengthExceeded(error: unknown, seen?: WeakSet<object>): boolean;

package/dist/activities/knowledge-indexing.d.ts

@@ -1,5 +1,24 @@
 import type { DocumentServices } from "@opengeni/documents";
 import type { ControlActivityServices } from "./types.js";
+/** The configured monthly indexed-chunk limit, not a provider failure. */
+export declare class KnowledgeIndexUsageLimitError extends Error {
+    constructor();
+}
+export type KnowledgeIndexFailureStage = "embedding" | "processing";
+/**
+ * Content-free classification for a deferred Knowledge index batch. Only
+ * protocol constants, an HTTP status, and a PostgreSQL SQLSTATE are retained;
+ * provider messages, bodies, SQL, and identifiers never leave the process.
+ * Outside the embedding call, only a PostgreSQL error in the cause chain is
+ * attributed to the database; any other failure stays a worker failure.
+ */
+export declare function knowledgeIndexFailureDiagnostic(stage: KnowledgeIndexFailureStage, error: unknown): {
+    errorClass: "KnowledgeIndexOperationError";
+    errorCode: "knowledge_index_usage_limit_reached" | "knowledge_index_embedding_failed" | "knowledge_index_persistence_failed" | "knowledge_index_failed";
+    origin: "worker" | "db";
+    status?: number;
+    sqlState?: string;
+};
 export declare function createKnowledgeIndexingActivities(services: () => Promise<ControlActivityServices>, resolveDocumentServices?: () => Promise<DocumentServices>): {
     indexKnowledge: () => Promise<{
         completed: number;

package/dist/{activities-control-IVTL723D.js → activities-control-I72CRMAE.js}

@@ -33,7 +33,7 @@ import {
   warnDrainSnapshotFailure,
   withFirstPartyTools,
   workflowIdForSession
-} from "./chunk-JMO5ZUW3.js";
+} from "./chunk-7M6G2SCF.js";
 import {
   inspectOpenSandboxKubernetesInventory,
   recordCreditBalanceGauges,
@@ -53,7 +53,7 @@ import {
   recordTurnsQueuedGauge,
   recordWorkerDeathRecoveryMetrics,
   runtimeMetricsHooksForObservability
-} from "./chunk-I7HKKMUJ.js";
+} from "./chunk-DSPP6CZL.js";
 import "./chunk-PZ5AY32C.js";
 
 // src/activities/knowledge-indexing.ts
@@ -76,6 +76,64 @@ import {
   withWorkspaceUsageLock,
   waitKnowledgeIndexForFunding
 } from "@opengeni/db";
+var KnowledgeIndexUsageLimitError = class extends Error {
+  constructor() {
+    super("monthly document indexing limit reached");
+    this.name = "KnowledgeIndexUsageLimitError";
+  }
+};
+function knowledgeIndexFailureDiagnostic(stage, error) {
+  if (error instanceof KnowledgeIndexUsageLimitError) {
+    return {
+      errorClass: "KnowledgeIndexOperationError",
+      errorCode: "knowledge_index_usage_limit_reached",
+      origin: "worker"
+    };
+  }
+  if (stage === "embedding") {
+    const status = ownValue(error, "status");
+    return {
+      errorClass: "KnowledgeIndexOperationError",
+      errorCode: "knowledge_index_embedding_failed",
+      origin: "worker",
+      ...typeof status === "number" && Number.isInteger(status) && status >= 100 && status <= 599 ? { status } : {}
+    };
+  }
+  const postgres = postgresErrorState(error);
+  if (!postgres) {
+    return {
+      errorClass: "KnowledgeIndexOperationError",
+      errorCode: "knowledge_index_failed",
+      origin: "worker"
+    };
+  }
+  return {
+    errorClass: "KnowledgeIndexOperationError",
+    errorCode: "knowledge_index_persistence_failed",
+    origin: "db",
+    ...postgres.sqlState ? { sqlState: postgres.sqlState } : {}
+  };
+}
+function ownValue(value, key) {
+  try {
+    if (!value || typeof value !== "object") return void 0;
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    return descriptor && "value" in descriptor ? descriptor.value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function postgresErrorState(error) {
+  let current = error;
+  for (let depth = 0; depth < 4 && current && typeof current === "object"; depth += 1) {
+    if (ownValue(current, "name") === "PostgresError") {
+      const code = ownValue(current, "code");
+      return typeof code === "string" && /^[0-9A-Z]{5}$/.test(code) ? { sqlState: code } : {};
+    }
+    current = ownValue(current, "cause");
+  }
+  return void 0;
+}
 function createKnowledgeIndexingActivities(services, resolveDocumentServices) {
   let activationTime;
   return {
@@ -103,6 +161,7 @@ function createKnowledgeIndexingActivities(services, resolveDocumentServices) {
         limit: 2
       });
       for (const claim of claims) {
+        let stage = "processing";
         try {
           const source = await readKnowledgeIndexSource(db, claim);
           if (!source) {
@@ -167,8 +226,7 @@ function createKnowledgeIndexingActivities(services, resolveDocumentServices) {
                     eventType: "document.indexed",
                     since: new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 1))
                   });
-                  if (used + chunks.length > limit)
-                    throw new Error("monthly document indexing limit reached");
+                  if (used + chunks.length > limit) throw new KnowledgeIndexUsageLimitError();
                 }
               }
               const inputs = chunks.map((chunk) => chunk.embeddingInput);
@@ -176,9 +234,11 @@ function createKnowledgeIndexingActivities(services, resolveDocumentServices) {
                 (sum, input) => sum + Buffer.byteLength(input, "utf8"),
                 0
               );
+              stage = "embedding";
               const vectors = await embedder.embedMany(inputs);
               if (vectors.length !== chunks.length)
                 throw new Error("Incomplete Knowledge embeddings");
+              stage = "processing";
               if (paid) {
                 const publication = await guardPaidKnowledgeIndexPublication(lockedDb, claim);
                 if (publication !== "published") {
@@ -276,14 +336,19 @@ function createKnowledgeIndexingActivities(services, resolveDocumentServices) {
               else result.unavailable++;
             }
           });
-        } catch {
-          await deferKnowledgeIndexJob(db, claim).catch(() => void 0);
-          result.deferred++;
-          observability.warn("Knowledge indexing batch deferred", {
-            accountId: claim.accountId,
-            entryId: claim.entryId,
-            revisionId: claim.revisionId
+        } catch (error) {
+          observability.warn(
+            "Knowledge indexing batch deferred",
+            knowledgeIndexFailureDiagnostic(stage, error)
+          );
+          await deferKnowledgeIndexJob(db, claim).catch((deferError) => {
+            const deferDiagnostic = knowledgeIndexFailureDiagnostic("processing", deferError);
+            observability.warn("Knowledge indexing batch deferral failed", {
+              ...deferDiagnostic,
+              errorCode: "knowledge_index_defer_failed"
+            });
           });
+          result.deferred++;
         }
       }
       return result;
@@ -4763,6 +4828,7 @@ import {
   openGeniSlackBotMetadata,
   requireOpenGeniSlackBotConnection,
   resolveWorkspaceCatalogSettings as resolveWorkspaceCatalogSettings2,
+  resolveScheduledTaskDefaultModel,
   resolveSessionToolPolicy,
   workspaceCustomModelReference,
   lockActiveCustomModelForAdmission,
@@ -5127,8 +5193,9 @@ function createScheduledTaskActivities(services) {
         taskAuthoritySubjectId
       ) : null;
       const settings = await settingsForTask(task, targetSessionExecutionBase?.model);
-      const model = task.agentConfig.model ?? settings.openaiModel;
-      const reasoningEffort = task.agentConfig.reasoningEffort ?? settings.openaiReasoningEffort;
+      const resolvedDefault = task.agentConfig.model || targetSessionExecutionBase ? null : await resolveScheduledTaskDefaultModel(db, settings, task);
+      const model = task.agentConfig.model ?? resolvedDefault?.model ?? settings.openaiModel;
+      const reasoningEffort = task.agentConfig.reasoningEffort ?? resolvedDefault?.reasoningEffort ?? settings.openaiReasoningEffort;
       let sandboxBackend = task.agentConfig.sandboxBackend ?? settings.sandboxBackend;
       let sandboxOs = "linux";
       const taskTools = withFirstPartyTools(settings, task.agentConfig.tools);
@@ -7679,4 +7746,4 @@ export {
   createControlActivities,
   createControlActivitiesFromServices
 };
-//# sourceMappingURL=activities-control-IVTL723D.js.map
+//# sourceMappingURL=activities-control-I72CRMAE.js.map