@opengeni/worker-bundle 1.0.0-canary.1 → 1.0.0

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

@@ -1,18 +1,31 @@
 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 ResolvedAgentConfig, 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;
     titleSource: "user" | "agent" | null;
+    agentConfig?: ResolvedAgentConfig | null;
     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[];
+    agentConfig?: ResolvedAgentConfig | null;
     selectedFirstPartyMcpTools: readonly FirstPartyMcpToolName[];
     shouldRequestTitle: boolean;
     parallelGenerationAvailable: boolean;
+    routeAllowsTitleRequests: boolean;
 }): {
     promoteTitleTool: boolean;
     generateTitleInParallel: boolean;
@@ -20,6 +33,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/skill-checkout.d.ts

@@ -1,8 +1,26 @@
 import type { AttemptToolDefinition } from "@opengeni/codemode";
-import type { SandboxChannelAService } from "@opengeni/runtime/sandbox";
-import type { SkillTextFile } from "@opengeni/runtime/skill-library";
+import { type SkillTextFile } from "@opengeni/runtime/skill-library";
+import { type SkillFileSystem } from "./skill-transfer.js";
 import type { SkillSaveReceipt, SkillSaveRequest } from "./skill-save.js";
-type SkillFileSystem = Pick<SandboxChannelAService, "fsList" | "fsRead" | "fsWrite" | "fsMkdir">;
+export type SkillCheckoutOutcome = "written" | "unchanged" | "refused" | "failed";
+/**
+ * Content-free timing of one skill_checkout call. `resolve` covers authority
+ * and the Skill read, `sandbox` acquiring the turn's filesystem handle, and
+ * `write` the batched filesystem write. On a lazily provisioned turn whose
+ * first sandbox use is this checkout, acquiring the handle starts the box, so
+ * box start is inside `sandbox`. A phase that did not run is null.
+ */
+export type SkillCheckoutObservation = Readonly<{
+    outcome: SkillCheckoutOutcome;
+    selection: "all" | "paths";
+    files: number;
+    written: number;
+    unchanged: number;
+    resolveSeconds: number | null;
+    sandboxSeconds: number | null;
+    writeSeconds: number | null;
+    totalSeconds: number;
+}>;
 export declare function createSkillCheckoutAttemptToolDefinition(input: {
     authorize: () => Promise<void>;
     load: (skill: string) => Promise<{
@@ -11,11 +29,12 @@ export declare function createSkillCheckoutAttemptToolDefinition(input: {
         scopeVersion: number | null;
         files: readonly SkillTextFile[];
     }>;
-    filesystem: () => Promise<SkillFileSystem>;
+    filesystem: () => Promise<Pick<SkillFileSystem, "fsWriteFiles">>;
+    /** Telemetry only; a failure here never changes the result. */
+    observe?: (observation: SkillCheckoutObservation) => void;
 }): AttemptToolDefinition;
 export declare function createSkillPublishAttemptToolDefinition(input: {
     authorize: () => Promise<void>;
-    filesystem: () => Promise<SkillFileSystem>;
+    filesystem: () => Promise<Pick<SkillFileSystem, "fsList" | "fsRead">>;
     save: (request: SkillSaveRequest) => Promise<SkillSaveReceipt>;
 }): AttemptToolDefinition;
-export {};

package/dist/activities/agent-turn/skill-read.d.ts

@@ -1,15 +1,83 @@
-import type { AttemptToolDefinition } from "@opengeni/codemode";
+import type { AttemptToolDefinition, AttemptToolExecutionContext } from "@opengeni/codemode";
+import { type SkillReadKind, type SkillUseSource } from "@opengeni/contracts";
 import { type SkillTextFile } from "@opengeni/runtime/skill-library";
 export declare const SKILL_READ_TOOL_NAME = "skill_read";
+/** Content-free provenance of a resolved Skill. The caller never receives it. */
+export type SkillReadOrigin = Readonly<{
+    id: string;
+    source: SkillUseSource;
+    /** Platform display label of a built-in; never user-authored text. */
+    label?: string;
+    /** Whole-artifact digest, for an artifact without a ledger revision. */
+    contentSha256?: string;
+}>;
 export type SkillReadContent = Readonly<{
     files: readonly SkillTextFile[];
     skillId: string;
     revisionId: string;
     scopeVersion: number;
     installationVersion?: number;
+    origin?: SkillReadOrigin;
+}>;
+/** A selected built-in or session artifact: no ledger identity, and none is synthesized. */
+export type SelectedSkillReadContent = Readonly<{
+    files: readonly SkillTextFile[];
+    origin: SkillReadOrigin;
+}>;
+export type SkillReadObservation = Readonly<{
+    caller: AttemptToolExecutionContext["caller"]["kind"];
+    kind: SkillReadKind;
+    /** Null when the read was refused before a Skill resolved. */
+    source: SkillUseSource | null;
+    /** The resolved Skill id, or the requested identifier when none resolved. */
+    skill: string;
+}>;
+/**
+ * Content-free read telemetry. It never changes what the caller receives: a
+ * model result gains only MCP `_meta`, which the model never sees and which
+ * only the tool-output event projection keeps.
+ */
+export type SkillReadTelemetry = Readonly<{
+    /** Ids in the Skill index the model sees this turn; null until known. */
+    indexedSkillIds: () => ReadonlySet<string> | null;
+    /** Whether skill_search returned this id earlier in this turn attempt. */
+    searched: (id: string) => boolean;
+    observe: (observation: SkillReadObservation) => void;
+}>;
+export type SkillReadActiveHistory = Readonly<{
+    /** Earlier skill_read results still in this session's active model history. */
+    readResults: () => Promise<ReadonlyArray<Record<string, unknown>>>;
+    /**
+     * This turn's model tool-output bound. Rows are bounded when stored, but a
+     * later model with a lower bound receives a shorter copy than the row holds.
+     */
+    toolOutputTruncationTokens: () => number;
+    /** The lookup only saves tokens, so a failure returns the full text. */
+    onLookupFailed?: (error: unknown) => void;
+}>;
+export declare const SKILL_UNAVAILABLE_MESSAGE = "Skill is not available in this session.";
+/** Bounds on the Skill list an unresolved identifier returns. */
+export declare const SKILL_UNAVAILABLE_LIST_MAX_ENTRIES = 25;
+export declare const SKILL_UNAVAILABLE_LIST_MAX_BYTES: number;
+export type AvailableSkill = Readonly<{
+    id: string;
+    name: string;
 }>;
+/**
+ * The error for an identifier that resolves to no Skill. It lists available
+ * Skills by id and name only, the descriptors the Skill index and skill_search
+ * already show the model, so the caller can retry instead of rediscovering
+ * the work from scratch. Entries resembling the requested identifier (shared
+ * prefix, suffix, or containment) come first, so a mistyped or spliced id
+ * keeps its likely targets inside the bound. The requested identifier is
+ * never echoed.
+ */
+export declare function unavailableSkillError(requested: string, available: readonly AvailableSkill[]): Error;
 /** A first-party gateway definition, not a sandbox capability or second backend. */
 export declare function createSkillReadAttemptToolDefinition(input: {
     authorize: () => Promise<void>;
-    load: (skill: string) => Promise<readonly SkillTextFile[] | SkillReadContent>;
+    load: (skill: string) => Promise<readonly SkillTextFile[] | SkillReadContent | SelectedSkillReadContent>;
+    /** Without it every read returns full text. */
+    activeHistory?: SkillReadActiveHistory;
+    telemetry?: SkillReadTelemetry;
 }): AttemptToolDefinition;

package/dist/activities/agent-turn/skill-remove.d.ts

@@ -0,0 +1,14 @@
+import type { AttemptToolDefinition } from "@opengeni/codemode";
+import { z } from "zod";
+import type { SkillWriteReceipt } from "@opengeni/contracts";
+export declare const SkillRemoveRequest: z.ZodObject<{
+    operationId: z.ZodUUID;
+    skillId: z.ZodUUID;
+    expectedRevisionId: z.ZodNullable<z.ZodUUID>;
+    expectedScopeVersion: z.ZodNumber;
+    reason: z.ZodString;
+}, z.core.$strict>;
+export declare function createSkillRemoveAttemptToolDefinition(input: {
+    authorize: () => Promise<void>;
+    remove: (request: z.infer<typeof SkillRemoveRequest>) => Promise<SkillWriteReceipt>;
+}): AttemptToolDefinition;

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

@@ -7,10 +7,12 @@ export type WorkspaceSkillSearchEntry = Readonly<{
     revisionId?: string;
     scopeVersion?: number;
     installationVersion?: number;
-    source?: "workspace" | "builtin" | "session" | "pack";
+    source?: "workspace" | "builtin" | "session";
 }>;
 export declare function createSkillSearchAttemptToolDefinition(input: {
     authorize: () => Promise<void>;
     listWorkspace: () => Promise<readonly WorkspaceSkillSearchEntry[]>;
     publicSearch: PublicSkillSearchClient;
+    /** Ids of the readable Skills a search returned, for read telemetry only. */
+    onWorkspaceHits?: (ids: readonly string[]) => void;
 }): AttemptToolDefinition;

package/dist/activities/agent-turn/skill-tools.d.ts

@@ -2,7 +2,9 @@ import type { Settings } from "@opengeni/config";
 import { type SkillActor } from "@opengeni/contracts";
 import { type Database } from "@opengeni/db";
 import type { RuntimeSkillArtifact } from "@opengeni/runtime";
-import type { SandboxChannelAService } from "@opengeni/runtime/sandbox";
+import { type SkillReadObservation } from "./skill-read.js";
+import { type SkillCheckoutObservation } from "./skill-checkout.js";
+import type { SkillFileSystem } from "./skill-transfer.js";
 export declare function createWorkspaceSkillTools(input: {
     db: Database;
     settings: Settings;
@@ -16,5 +18,16 @@ export declare function createWorkspaceSkillTools(input: {
         id: string;
         artifact: RuntimeSkillArtifact;
     }[];
-    filesystem: () => Promise<Pick<SandboxChannelAService, "fsList" | "fsRead" | "fsWrite" | "fsMkdir">>;
+    filesystem: () => Promise<SkillFileSystem>;
+    /** Content-free skill_checkout timing; it never changes a result. */
+    observeSkillCheckout?: (observation: SkillCheckoutObservation) => void;
+    /** The resolved model's bound, which `settings` does not carry. */
+    modelToolOutputTruncationTokens: () => number;
+    onSkillReadHistoryLookupFailed?: (error: unknown) => void;
+    /** Content-free skill_read telemetry; it never changes a result. */
+    skillReadTelemetry?: {
+        /** Ids in the Skill index the model sees this turn; null until known. */
+        indexedSkillIds: () => ReadonlySet<string> | null;
+        observe: (observation: SkillReadObservation) => void;
+    };
 }): import("@opengeni/codemode").AttemptToolDefinition[];

package/dist/activities/agent-turn/skill-transfer.d.ts

@@ -1,26 +1,38 @@
 import type { SandboxChannelAService } from "@opengeni/runtime/sandbox";
 import { type SkillTextFile } from "@opengeni/runtime/skill-library";
-type SkillFileSystem = Pick<SandboxChannelAService, "fsList" | "fsRead" | "fsWrite" | "fsMkdir">;
+export type SkillFileSystem = Pick<SandboxChannelAService, "fsList" | "fsRead" | "fsWriteFiles">;
 /** Reuse the host's cancellation and workspace-mutation authority for each filesystem operation. */
 export declare function guardSkillFilesystem(fs: SkillFileSystem, authority: {
     assertActive: () => void;
     runMutation: <T>(operation: () => Promise<T>) => Promise<T>;
 }): SkillFileSystem;
-/** Caller supplies an authorized live filesystem and a fresh workspace-relative target. */
-export declare function checkoutSkillDirectory(fs: SkillFileSystem, directory: string, files: readonly SkillTextFile[]): Promise<{
+export type SkillCheckoutResult = {
     directory: string;
     fileCount: number;
-}>;
+    written: number;
+    unchanged: number;
+    /** This call created the directory, so it holds nothing but these files. */
+    createdDirectory: boolean;
+};
+/**
+ * Caller supplies an authorized live filesystem and a workspace-relative
+ * target. All missing files are created in one filesystem batch (normally a
+ * single sandbox command). Nothing is overwritten: files already holding the
+ * same bytes are kept, and any other existing entry fails before writing.
+ * `paths` selects exactly those Skill files, for example one script to run.
+ */
+export declare function checkoutSkillDirectory(fs: Pick<SkillFileSystem, "fsWriteFiles">, directory: string, files: readonly SkillTextFile[], options?: {
+    paths?: readonly string[];
+}): Promise<SkillCheckoutResult>;
 /**
  * Read a folder through existing structured filesystem services, never via model
  * arguments. The caller owns workspace confinement and the final governed save.
  * This operation does not execute scripts or activate the resulting artifact.
  */
-export declare function readSkillDirectory(fs: SkillFileSystem, directory: string): Promise<Readonly<{
+export declare function readSkillDirectory(fs: Pick<SkillFileSystem, "fsList" | "fsRead">, directory: string): Promise<Readonly<{
     name: string;
     description: string;
     files: readonly import("@opengeni/runtime").SkillLibraryFile[];
     contentSha256: string;
     totalBytes: number;
 }>>;
-export {};

package/dist/activities/agent-turn/stream-attempt.d.ts

@@ -11,7 +11,7 @@ import { ToolResultSpill } from "./tool-result-spill.js";
 import { createTurnCredentialLeases } from "./credential-leases.js";
 import { createTurnMediaArtifacts } from "./media-artifacts.js";
 import { createTurnHistorySink } from "./history-sink.js";
-import { type SessionEvent } from "@opengeni/contracts";
+import { type SessionEvent, type SessionTurn } from "@opengeni/contracts";
 import { createModelCheckpointMemoryCollector } from "../../model-checkpoint-memory-collector.js";
 import { TurnEventPublisher } from "./model-usage.js";
 import type { CompactionSummarizer } from "../context-compaction.js";
@@ -44,11 +44,12 @@ export type TurnStreamAttemptDeps = {
     providerTurn: ProviderTurnState;
     leases: ReturnType<typeof createTurnCredentialLeases>;
     historySink: ReturnType<typeof createTurnHistorySink>;
+    checkpointBeforeProviderDispatch: () => Promise<void>;
     media: ReturnType<typeof createTurnMediaArtifacts>;
     toolResultSpill: ToolResultSpill;
     claimedResult: ClaimedResult;
     flushRuntimeBatcher: () => Promise<void>;
-    finalizeTurnOpStreamOps: () => Promise<void>;
+    finalizeTurnOpStreamOps: (toolCallIds?: readonly string[]) => Promise<void>;
     runWorkspaceMutationForSandbox: <T>(sandbox: ResumedTurnSandbox, operation: string, mutation: () => Promise<T>, observePhase?: (measurement: {
         phase: "admission" | "provider" | "settlement" | "snapshot_wait";
         outcome: "completed" | "failed";
@@ -79,9 +80,12 @@ export type TurnStreamAttemptDeps = {
     activeSandboxBackend: Settings["sandboxBackend"] | undefined;
     groupBoxBackend: Settings["sandboxBackend"];
     turnExecutionPolicy: TurnExecutionPolicyV1;
-    turn: {
+    turn: Pick<SessionTurn, "initiator" | "initiatorContext"> & {
+        initiatingHumanSubjectId: string | null;
+        id: string;
         executionGeneration: number;
         model: string;
+        source?: string;
     };
     trigger: NonNullable<Awaited<ReturnType<typeof getSessionEvent>>>;
     humanInputResume: Awaited<ReturnType<typeof getHumanInputResumeForEvent>>;

package/dist/activities/agent-turn/subscription-lease.d.ts

@@ -0,0 +1,38 @@
+export type LeaseRenewReason = "timer" | "runtime_event" | "model_usage";
+export type LeaseLossReason = "deadline" | "not_found";
+type LeaseIdentity = {
+    turnId: string;
+    holderId: string;
+    generation: number;
+};
+export type SubscriptionLeaseDeps = {
+    ttlMs: number;
+    getTurnId: () => string | undefined;
+    heartbeat: (identity: LeaseIdentity) => Promise<Date | null>;
+    onLost: (reason: LeaseLossReason) => void;
+    onRenewed?: (reason: LeaseRenewReason) => void;
+    onError: (error: unknown, reason: LeaseRenewReason) => void;
+    lostError: (reason: LeaseLossReason) => Error;
+    now?: () => number;
+};
+/** Cross-provider lease lifecycle. Only on-time DB confirmation extends ownership. */
+export declare class SubscriptionTurnLease {
+    private readonly leaseDeps;
+    held: boolean;
+    lost: boolean;
+    lossReason: LeaseLossReason | null;
+    holderId: string | null;
+    generation: number | null;
+    confirmedUntilMs: number | null;
+    private heartbeatInFlight;
+    private heartbeatTimer;
+    private readonly now;
+    constructor(leaseDeps: SubscriptionLeaseDeps);
+    private expired;
+    markLost: (reason: LeaseLossReason) => void;
+    assertUsable: () => void;
+    renew: (reason?: LeaseRenewReason) => Promise<void>;
+    startHeartbeat: () => void;
+    stopHeartbeat: () => void;
+}
+export {};

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

@@ -1,15 +1,20 @@
-import { type AttemptConnectorActionBinding, type ConnectorActionPolicyHooks } from "@opengeni/runtime";
+import { type RunMcpCredentials, type AttemptConnectorActionBinding, type ConnectorActionPolicyHooks } from "@opengeni/runtime";
 import { type Settings } from "@opengeni/config";
 import { withFirstPartyTools } from "../goals.js";
 import type { TurnActivityServices as ActivityServices, RunAgentTurnInput } from "../types.js";
 import { ToolResultSpill } from "./tool-result-spill.js";
 import { createTurnMediaArtifacts } from "./media-artifacts.js";
+import { type ResourceRef, type Permission } from "@opengeni/contracts";
 import type { ClaimTurnOk } from "./claim.js";
 import type { GovernanceModelOk } from "./governance-model.js";
 import type { SandboxTurnRuntime } from "./sandbox-runtime.js";
 import type { sandboxArtifactRuntimeAdmission } from "./sandbox-route.js";
-import type { AttemptIdentityState, EventingState, SandboxRuntimeState, WorkspaceRefState } from "./turn-context.js";
-import type { RuntimeSkillActivation } from "@opengeni/runtime";
+import type { AttemptIdentityState, EventingState, RenewalState, SandboxRuntimeState, WorkspaceRefState } from "./turn-context.js";
+/** A linked turn's immutable policy must survive array and token boundaries. */
+export declare function linkedTurnFirstPartyPermissions(selected: Permission[] | null, linked: {
+    permissions: Permission[];
+    permissionMode?: "legacy" | "explicit";
+} | null): Permission[] | null;
 export type PrepareTurnToolPolicyDeps = {
     input: RunAgentTurnInput;
     db: ActivityServices["db"];
@@ -25,7 +30,6 @@ export type PrepareTurnToolPolicyDeps = {
 };
 export type PrepareTurnToolRuntimeDeps = {
     fetchKnowledgeSource?: ((input: import("../types.js").RunKnowledgeSourceSyncBatchInput) => Promise<import("../types.js").RunKnowledgeSourceSyncBatchResult>) | undefined;
-    selectedSkillActivations: readonly RuntimeSkillActivation[];
     input: RunAgentTurnInput;
     catalogSourceSettings: Settings;
     db: ActivityServices["db"];
@@ -34,7 +38,6 @@ export type PrepareTurnToolRuntimeDeps = {
     objectStorage: ActivityServices["objectStorage"];
     observability: ActivityServices["observability"];
     cancellationSignal: AbortSignal | undefined;
-    connectionCredentials: ActivityServices["connectionCredentials"];
     eventing: EventingState;
     attempt: AttemptIdentityState;
     sandboxState: SandboxRuntimeState;
@@ -49,13 +52,13 @@ export type PrepareTurnToolRuntimeDeps = {
     turnExecutionPolicy: ClaimTurnOk["turnExecutionPolicy"];
     trigger: ClaimTurnOk["trigger"];
     runSettings: GovernanceModelOk["runSettings"];
+    resolvedModel: GovernanceModelOk["resolvedModel"];
     lazyToolTransport: GovernanceModelOk["lazyToolTransport"];
     turnTools: ReturnType<typeof withFirstPartyTools>;
     connectionScope: {
         accountId: string;
         workspaceId: string;
     };
-    hostCredentialRootSessionId: string | null;
     sandboxArtifactRuntime: ReturnType<typeof sandboxArtifactRuntimeAdmission>;
     activeSandboxBackend: Settings["sandboxBackend"] | undefined;
     groupBoxBackend: Settings["sandboxBackend"];
@@ -64,8 +67,18 @@ export type PrepareTurnToolRuntimeDeps = {
     credentialSubjectId: ClaimTurnOk["credentialSubjectId"];
     interactionInterventionResume: ClaimTurnOk["interactionInterventionResume"];
     runWorkspaceMutationForSandbox: SandboxTurnRuntime["runWorkspaceMutationForSandbox"];
+    /** Deployment and workspace allow the Jev-backed code_search tool. */
+    codeSearchEnabled: boolean;
+    /**
+     * False for an optional repository that sits this turn out after losing
+     * access (dropUnavailableOptionalRepositories), so no tool surface offers it.
+     */
+    retainsOptionalRepository?: (resource: ResourceRef) => boolean;
     throwIfWorkerShuttingDown: () => void;
     throwIfTurnCancelled: () => void;
+    /** Present when this turn resolves host-managed run credentials. */
+    runCredentialRenewals?: RenewalState | undefined;
+    runMcpCredentials?: RunMcpCredentials;
 };
 export declare function prepareTurnToolPolicy(deps: PrepareTurnToolPolicyDeps): Promise<{
     turnResources: ({
@@ -85,6 +98,7 @@ export declare function prepareTurnToolPolicy(deps: PrepareTurnToolPolicyDeps):
         connectionId?: string | undefined;
         githubInstallationId?: number | undefined;
         githubRepositoryId?: number | undefined;
+        optional?: boolean | undefined;
     } | {
         kind: "file";
         fileId: string;
@@ -107,6 +121,7 @@ export declare function prepareTurnToolPolicy(deps: PrepareTurnToolPolicyDeps):
         connectionId?: string | undefined;
         githubInstallationId?: number | undefined;
         githubRepositoryId?: number | undefined;
+        optional?: boolean | undefined;
     } | {
         kind: "file";
         fileId: string;
@@ -129,9 +144,44 @@ export declare function prepareTurnToolPolicy(deps: PrepareTurnToolPolicyDeps):
 export declare function prepareTurnToolRuntime(deps: PrepareTurnToolRuntimeDeps): Promise<{
     attemptConnectorActionBindings: AttemptConnectorActionBinding[];
     connectorActionPolicy: ConnectorActionPolicyHooks;
+    mcpServers: {
+        id: string;
+        name?: string | undefined;
+        url: string;
+        allowedTools?: string[] | undefined;
+        timeoutMs?: number | undefined;
+        cacheToolsList: boolean;
+        requireApproval?: boolean | string[] | undefined;
+        headers?: Record<string, string> | undefined;
+        connectionRef?: {
+            connectionId?: string | undefined;
+            accountSelection?: "all_eligible" | undefined;
+            authoritySource?: "host" | undefined;
+            hostBinding?: {
+                bindingId: string;
+                generation: number;
+            } | {
+                selection: "accepted_turn";
+            } | undefined;
+            provider?: string | undefined;
+            providerDomain: string;
+            kind?: "api_key" | "app_install" | "delegated" | "oauth2" | undefined;
+            scopes?: string[] | undefined;
+            resource?: string | undefined;
+            selectedResources?: {
+                id: string;
+                kind: "repository";
+            }[] | undefined;
+            subjectScope?: "subject" | "workspace" | undefined;
+        } | undefined;
+        operationRecovery?: Record<string, {
+            observerTool: string;
+        }> | undefined;
+    }[];
     generateSessionTitleInParallel: boolean;
     postToolPreparationStartedAt: number;
     preparationIndependentToolNames: string[];
+    codeSearchAvailable: boolean;
     skillCatalog: {
         id: string;
         name: string;

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

@@ -43,6 +43,49 @@ export declare function structuredToolTransportForTurn(resolvedModel: {
         baseUrl?: string | undefined;
     };
 } | null): boolean;
+/**
+ * `text.verbosity: "low"` is the Codex CLI default for its GPT-5-family models
+ * and keeps final answers short. Send it only where the wire is known to accept
+ * it: the ChatGPT/Codex subscription backend, direct OpenAI Responses, and the
+ * Azure OpenAI Responses wire, where the parallel session-title request already
+ * sends the same field with the turn's model. Gateways, xAI, other
+ * OpenAI-compatible endpoints and chat wires keep their provider default. The
+ * result depends only on the route and model, so a session sends the same value
+ * on every request until its model changes, and a model change already starts a
+ * new prompt-cache prefix.
+ */
+export declare function textVerbosityForTurn(resolvedModel: {
+    provider: {
+        id: string;
+        kind: ResolvedModelProvider["kind"];
+        api: ModelProviderApi;
+        wireProfile: "openai" | "azure-openai";
+        builtin: boolean;
+        baseUrl?: string | undefined;
+    };
+} | null, upstreamModelId: string): "low" | undefined;
+/**
+ * Ask supported reasoning Responses routes for their provider-selected summary
+ * format. This is public summary text, never private or encrypted reasoning.
+ * Codex and unverified compatible wires retain the existing detailed setting.
+ */
+export declare function reasoningSummaryForTurn(resolvedModel: {
+    provider: {
+        id: string;
+        api: ModelProviderApi;
+        wireProfile: "openai" | "azure-openai";
+        builtin: boolean;
+        baseUrl?: string | undefined;
+    };
+    configured: {
+        upstreamModelId: string;
+        capabilities: {
+            reasoning: {
+                runnable: boolean;
+            };
+        };
+    };
+} | null): "auto" | undefined;
 /**
  * Progressive tool disclosure is universal for supported OpenGeni turns; only
  * its contained transport differs. Codex keeps its native path, built-in direct

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

@@ -1,3 +1,4 @@
+import type { TurnHeartbeatDetails } from "../../op-journal.js";
 import type { Settings } from "@opengeni/config";
 import type { CodexUsageHeaderSnapshot } from "@opengeni/codex";
 import type { AppendEventInput, ApplySessionTurnSettlementInput } from "@opengeni/db";
@@ -14,6 +15,7 @@ import type { TurnOutcome } from "../../observability-metrics.js";
 import type { ResumedTurnSandbox, TurnSandboxLeaseHolderId } from "../../sandbox-resume.js";
 import type { TurnEventPublisher } from "./model-usage.js";
 import type { TurnSandboxProvisioner } from "./sandbox-provision.js";
+import { InitialModelWireDispatchClock } from "./model-wire-dispatch.js";
 /** Stamps the claimed turn/attempt ids onto a phase's own outcome. */
 export type ClaimedResult = (result: Omit<Extract<RunAgentTurnResult, {
     status: Exclude<RunAgentTurnResult["status"], "unclaimed">;
@@ -24,6 +26,7 @@ export type TurnSettleFn = (input: {
     sessionStatus: SessionStatus;
     activeTurnId: string | null;
     suppressGoalContinuation?: boolean;
+    allowanceGoalPause?: ApplySessionTurnSettlementInput["allowanceGoalPause"];
     consumeRequestedCompactionFailure?: boolean;
     runState?: ApplySessionTurnSettlementInput["runState"];
 }) => Promise<boolean>;
@@ -40,6 +43,10 @@ export type AttemptIdentityState = {
     triggerEventId: string | undefined;
     executionGeneration: number;
     providerRecoveryCount: number;
+    claudeAuthRecovery?: {
+        credentialId: string;
+        credentialVersion: number;
+    } | undefined;
     modelRequestStarted: boolean;
     redispatchesAtDispatch: number;
     triggerType: string | null;
@@ -47,6 +54,7 @@ export type AttemptIdentityState = {
 export type BillingState = {
     isCodexTurn: boolean;
     isXaiTurn: boolean;
+    isClaudeTurn: boolean;
     isExternallyBilledTurn: boolean;
     chargesOpenGeniCredits: boolean;
     countsTowardTokenCap: boolean;
@@ -79,16 +87,23 @@ export type SandboxRuntimeState = {
     startupMilestoneBackend: Settings["sandboxBackend"] | null;
 };
 export type RenewalState = {
+    /** Secret-only local state; closed on every attempt finalization path. */
+    runMcpCredentials?: {
+        close(): void;
+    };
     gitCredentialRenewals: GitCredentialRenewalController[];
     gitCredentialRenewalClosed: boolean;
     runCredentialRenewal: RunCredentialRenewalController | null;
     runCredentialRenewalClosed: boolean;
+    /** Outcome of the most recent renewal attempt, for on-demand refresh reporting. */
+    runCredentialRenewalOutcome: "completed" | "auth_needed" | "error" | null;
     runCredentialSession: RunCredentialCommandSession | null;
     codemodeTokenRenewal: CodemodeTokenRenewalController | null;
     codemodeTokenRenewalClosed: boolean;
     publishedRunCredentialNotices: Set<string>;
 };
 export type EventingState = {
+    heartbeatDetails: TurnHeartbeatDetails | null;
     heartbeatTimer: ReturnType<typeof startActivityHeartbeat> | undefined;
     batcher: ReturnType<typeof createRuntimeBatcher> | null;
     preparedTools: Awaited<ReturnType<OpenGeniRuntime["prepareTools"]>> | null;
@@ -106,7 +121,10 @@ export type EventingState = {
     firstModelRequestPreparationStartedAt: number | null;
     firstModelRequestPreparationRecorded: boolean;
     firstModelRequestCheckpointAt: number | null;
+    initialModelWireDispatch: InitialModelWireDispatchClock;
     companyBrainContextContributions: readonly ModelContextContributionSummary[] | null;
+    /** Skill ids in this turn's frozen, model-visible Skill index; telemetry only. */
+    modelVisibleSkillIds: ReadonlySet<string> | null;
 };
 /** Rig telemetry (M3): set once the session loads; empty string for a rig-less
  * turn (mirrors variableSetId). Read by the activity span's finally block. */
@@ -121,8 +139,18 @@ export type ProviderTurnState = {
     effectiveCodexCredentialVersion: number | null;
     /** Frozen alternate-account ceiling observed by the fenced allocator. */
     codexCredentialFailoverLimit: number;
+    /**
+     * Accepted product model id (`codex/<slug>`) the Codex allocator filtered
+     * for. Failure settlement scopes plan entitlement and failover to it.
+     */
+    codexProductModelId?: string | null;
     /** Accepted Codex allocator policy captured with the first durable lease. */
     codexPolicySnapshot: CodexCredentialPolicySnapshotV1 | null;
+    effectiveClaudeCredentialId: string | null;
+    effectiveClaudeCredentialVersion: number | null;
+    claudeUpstreamModelId: string | null;
+    claudeRotationEnabled: boolean;
+    claudeAuthoritySnapshot: XaiProviderAccountAuthoritySnapshotV1 | null;
     effectiveXaiCredentialId: string | null;
     xaiRotationEnabled: boolean;
     xaiAuthoritySnapshot: XaiProviderAccountAuthoritySnapshotV1 | null;
@@ -130,6 +158,7 @@ export type ProviderTurnState = {
     xaiCredentialQuarantined: boolean;
     priorSessionCodexCredentialId: string | null;
     latestCodexUsage: CodexUsageHeaderSnapshot | null;
+    latestClaudeUsage: Map<string, import("./claude-usage-observer.js").CapturedClaudeUsage>;
     lastCodexRequestOpaqueArtifacts: readonly string[];
 };
 export type TurnContext = {