@caeliq/llms 1.0.71 → 1.0.73

package/dist/routing/protocol-endpoints.d.ts

@@ -10,6 +10,33 @@ export interface AnthropicSourceRequestFields {
     thinking?: Record<string, unknown>;
     outputConfig?: Record<string, unknown>;
     stopSequences?: string[];
+    /**
+     * Anthropic-defined (typed) tools such as `web_search_20250305` or
+     * `bash_20250124`, exactly as the client sent them. Unified `tools[]` keeps
+     * their function projection (by name) for routing and other providers.
+     */
+    tools?: Record<string, any>[];
+    /**
+     * Server tool blocks (`server_tool_use`, `web_search_tool_result`) of each
+     * assistant turn, indexed by assistant-turn ordinal, with that turn's
+     * joined text so the builder only re-attaches them to the same turn.
+     */
+    assistantServerBlocks?: Array<{
+        text: string;
+        blocks: any[];
+    } | undefined>;
+}
+/** Client asked for provider-hosted web search (any inbound protocol). */
+export interface HostedWebSearchRequest {
+    allowedDomains?: string[];
+    /** Per-request search cap from `WEB_SEARCH_MAX_USES` (none by default). */
+    maxUses?: number;
+    userLocation?: {
+        city?: string;
+        region?: string;
+        country?: string;
+        timezone?: string;
+    };
 }
 export interface ClientProtocolContext {
     protocol: ClientProtocol;
@@ -25,6 +52,12 @@ export interface ClientProtocolContext {
     scenarioType?: RouterScenarioType;
     /** Source-only Anthropic semantics retained before destination routing. */
     anthropicSource?: AnthropicSourceRequestFields;
+    /**
+     * Hosted web search requested by an Anthropic `web_search_*` tool, a
+     * Responses `web_search` tool or Chat `web_search_options`; Unified carries
+     * the `web_search` function projection.
+     */
+    hostedWebSearch?: HostedWebSearchRequest;
     /** Client fingerprint captured before Anthropic normalization. */
     anthropicClientKind?: AnthropicClientKind;
     /** In-scope Anthropic destination/auth variant selected after routing. */

package/dist/services/provider.d.ts

@@ -1,4 +1,4 @@
-import { LLMProvider, RegisterProviderRequest, ModelRoute, RequestRouteInfo } from "../types/llm";
+import { LLMProvider, RegisterProviderRequest, ModelRoute, ProviderUpdate, RequestRouteInfo } from "../types/llm";
 import { ConfigService } from "./config";
 import { TransformerService } from "./transformer";
 export declare class ProviderService {
@@ -12,10 +12,16 @@ export declare class ProviderService {
     private initializeFromProvidersArray;
     /** Match TransformerService: instances used in provider use[] need the service logger. */
     private attachTransformerLogger;
+    /**
+     * Store request-scoped error rules under the canonical key only, so an
+     * update under any spelling cannot be shadowed by a stale alias. Rules are
+     * validated here to surface config mistakes at registration time.
+     */
+    private withCanonicalScopedErrorRules;
     registerProvider(request: RegisterProviderRequest): LLMProvider;
     getProviders(): LLMProvider[];
     getProvider(name: string): LLMProvider | undefined;
-    updateProvider(id: string, updates: Partial<LLMProvider>): LLMProvider | null;
+    updateProvider(id: string, updates: ProviderUpdate): LLMProvider | null;
     deleteProvider(id: string): boolean;
     toggleProvider(name: string, _enabled: boolean): boolean;
     resolveModelRoute(modelName: string): RequestRouteInfo | null;

package/dist/session-registry.d.ts

@@ -1,26 +1,42 @@
 /**
  * Persistent registry for every session identity CCR mints.
  *
- * Two families, one mechanism — the stable lookup key already exists in each
+ * Several families, one mechanism — the stable lookup key already exists in each
  * case (Zen conversation id, cursor buildSessionKey hash); only the minted
  * value used to live in process memory and died on restart:
  *
  * - "zen":    conversationKey -> x-opencode-session (ses_…)
  * - "cursor": sessionKey      -> { agentId, workspaceDir, model }
+ * - "cursor-inbound": hashed protocol conversation key -> internal Cursor id
+ *   (cursor-sdk/inbound-session.ts; written on mint, claim, new user text,
+ *   and at most hourly as a TTL refresh)
  *
  * The file lives under CCR_HOME (the mounted ~/.claude-code-router volume),
  * so bindings survive both restarts and image rebuilds. Plain JSON: values
  * are short strings, not blobs (unlike cursor-opencode-provider's pb.gz,
  * which persists raw Cursor protocol state we never see — the SDK owns that).
  *
- * Synchronous API, tiny file (capped entries), persistence on mint/delete
- * only — never on the hot read path.
+ * Synchronous API, tiny file (entries capped per family), persistence on
+ * writes only — never on the read path.
  */
 export type PersistedSession = {
     /** The fixed CCR-minted id (ses_… for zen; SDK agentId for cursor). */
     sessionId: string;
     workspaceDir?: string;
     model?: string;
+    /** `id|sorted params` from cursorModelFingerprint. Missing means pre-variant binding. */
+    modelFingerprint?: string;
+    /**
+     * Cursor inbound opening row: a follow-up turn claimed it. A repeated
+     * opening then needs a fresh id.
+     */
+    progressed?: boolean;
+    /**
+     * Cursor inbound opening row that replaced an unclaimed opening of an
+     * identical earlier conversation. A follow-up cannot tell the two apart,
+     * so it gets a fresh agent instead of claiming this one.
+     */
+    contested?: boolean;
     updatedAt: number;
 };
 export declare const SESSION_REGISTRY_TTL_MS: number;
@@ -28,6 +44,17 @@ export declare const SESSION_REGISTRY_TTL_MS: number;
 export declare function getPersistedSession(family: string, key: string, now?: number): PersistedSession | undefined;
 /** Record a newly minted fixed id. Overwrites any prior binding. */
 export declare function putPersistedSession(family: string, key: string, value: Omit<PersistedSession, "updatedAt">, now?: number): PersistedSession;
+/**
+ * Apply several writes to one family with a single file rewrite: `put`
+ * entries are stored (overwriting), then `remove` keys are dropped.
+ */
+export declare function updatePersistedSessions(family: string, changes: {
+    put?: Array<{
+        key: string;
+        value: Omit<PersistedSession, "updatedAt">;
+    }>;
+    remove?: string[];
+}, now?: number): void;
 /** Forget a binding (session retire, Zen bucket re-roll). */
 export declare function deletePersistedSession(family: string, key: string): void;
 /** Drop expired bindings; returns the number pruned. */

package/dist/tests/anthropic.third-party-tool-names.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/codex.bootstrap-buffer.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/codex.model-catalog.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/cursor-sdk.inbound-session.d.ts

@@ -0,0 +1 @@
+import "./support/isolate-session-registry";

package/dist/tests/cursor-sdk.interrupt-reentry.d.ts

@@ -1 +1 @@
-export {};
+import "./support/isolate-session-registry";

package/dist/tests/cursor-sdk.model-remint.d.ts

@@ -0,0 +1 @@
+import "./support/isolate-session-registry";

package/dist/tests/cursor-sdk.model-selection.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/cursor-sdk.on-delta-thinking.d.ts

@@ -1 +1 @@
-export {};
+import "./support/isolate-session-registry";

package/dist/tests/cursor-sdk.runner-recovery.d.ts

@@ -1 +1 @@
-export {};
+import "./support/isolate-session-registry";

package/dist/tests/cursor-sdk.scratch-report.d.ts

@@ -1 +1 @@
-export {};
+import "./support/isolate-session-registry";

package/dist/tests/cursor-sdk.turn-coordination.d.ts

@@ -1 +1 @@
-export {};
+import "./support/isolate-session-registry";

package/dist/tests/fallback.request-context.routes.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/path-alias.build.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/request-scoped-errors.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/request-scoped-errors.routes.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/responses.multi-agent.routes.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/responses.orphan-delegation.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/support/isolate-session-registry.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/web-search.cross-protocol.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/transformer/claude-auth.transformer.d.ts

@@ -5,6 +5,14 @@ import { ClaudeModelCatalogEntry } from "../utils/claude-model-catalog";
 /** Anthropic beta required for Claude subscription / Claude Code OAuth Bearer auth. */
 export declare const CLAUDE_OAUTH_REQUIRED_BETA = "oauth-2025-04-20";
 export declare function mergeAnthropicBetaValues(...values: Array<string | undefined | null>): string;
+/**
+ * Beta tokens a third-party client sent for its Anthropic-defined computer use
+ * tool (e.g. `computer-use-2025-11-24` for `computer_20251124`). The emulated
+ * profile otherwise ignores client betas; the client already chose the one
+ * matching its tool version, so only that family is carried over, and only
+ * when the request actually declares a `computer_*` tool.
+ */
+export declare function clientComputerUseBetas(clientBeta: string | undefined, typedTools: Array<Record<string, any>> | undefined): string | undefined;
 /** Read a named header value from a Fastify/Node headers object (case-insensitive). */
 export declare function readHeaderValue(headers: Record<string, unknown> | undefined, name: string): string | undefined;
 /** True when the client's User-Agent identifies it as the genuine Claude Code CLI. */
@@ -67,8 +75,9 @@ export declare class ClaudeAuthTransformer implements Transformer {
     /**
      * Body/URL/wire-format conversion belong to AnthropicTransformer's
      * provider pair, which already ran (response-side order is reversed, so
-     * it runs before this stage). This stage only inspects the resulting
-     * response for subscription-specific overage observability.
+     * it runs before this stage). This stage inspects the resulting response
+     * for subscription-specific overage observability and restores tool names
+     * its own legacy branch renamed.
      */
     transformResponseOut(response: Response, context?: TransformerContext): Promise<Response>;
     /**

package/dist/transformer/codex.transformer.d.ts

@@ -1,4 +1,5 @@
 import { Transformer } from "../types/transformer";
+import { type CodexBootstrapOptions } from "../utils/codex-bootstrap";
 /**
  * ChatGPT/Codex backend auth + Responses-wire constraints.
  *
@@ -8,10 +9,26 @@ import { Transformer } from "../types/transformer";
  * this transformer only stamps auth, Codex headers, `store: false`, and
  * `stream: true`.
  */
+export interface CodexTransformerOptions extends CodexBootstrapOptions {
+    streamBootstrapMaxFrames?: number;
+    streamBootstrapMaxBytes?: number;
+    streamBootstrapTimeoutMs?: number;
+    /**
+     * Hold pre-generation SSE frames uncommitted so an in-stream
+     * `server_is_overloaded` / quota rejection throws a fallback-eligible
+     * error *before* downstream headers commit, instead of reaching the
+     * client as a failed stream. Default false (opt-in).
+     */
+    streamBootstrapBuffering?: boolean;
+}
 export declare class CodexTransformer implements Transformer {
+    static TransformerName: string;
     name: string;
     requestPhase: "headers";
     logger?: any;
+    private readonly bootstrapOptions;
+    constructor(options?: CodexTransformerOptions);
+    private get bootstrapEnabled();
     private streamIntent;
     transformRequestIn(request: any, provider: any, context?: any): Promise<Record<string, any>>;
     auth(request: any, provider: any): Promise<any>;
@@ -29,6 +46,7 @@ export declare class CodexTransformer implements Transformer {
         req?: {
             id?: string;
         };
+        signal?: AbortSignal;
     }): Promise<Response>;
     private normalizeCodexTransport;
     private ensureSseContentType;

package/dist/types/llm.d.ts

@@ -6,6 +6,7 @@ import type { ChatCompletionTool } from "openai/resources/chat/completions";
 import type { Tool as AnthropicTool } from "@anthropic-ai/sdk/resources/messages";
 import { Transformer } from "./transformer";
 import type { ProviderTokenizerConfig } from "./tokenizer";
+import type { RequestScopedErrorRule } from "../utils/request-scoped-errors";
 export type TransformerConfigEntry = string | [string, Record<string, any>?];
 export interface UrlCitation {
     url: string;
@@ -18,6 +19,16 @@ export interface Annotation {
     type: "url_citation";
     url_citation?: UrlCitation;
 }
+/**
+ * A provider-executed web search (e.g. Anthropic's server `web_search`),
+ * surfaced so clients can render the call itself (Responses `web_search_call`).
+ * Internal: Chat Completions clients never receive it.
+ */
+export interface WebSearchCall {
+    id: string;
+    query: string;
+    status: "completed" | "failed";
+}
 export interface TextContent {
     type: "text";
     text: string;
@@ -137,6 +148,12 @@ export interface UnifiedChatRequest {
     anthropic_output_config?: Record<string, any>;
     anthropic_metadata?: Record<string, any>;
     anthropic_stop_sequences?: string[];
+    /**
+     * Anthropic-defined (typed) tools for legacy direct claude-auth callers,
+     * like the other anthropic_* fields. Routed requests carry them in
+     * `protocolContext.anthropicSource.tools` so no other provider sees them.
+     */
+    anthropic_tools?: Record<string, any>[];
     reasoning_effort?: string;
     /**
      * Responses opaque `include` list (e.g. `reasoning.encrypted_content`).
@@ -168,6 +185,7 @@ export interface UnifiedChatResponse {
         };
     }>;
     annotations?: Annotation[];
+    web_search_calls?: WebSearchCall[];
 }
 export interface StreamChunk {
     id: string;
@@ -195,6 +213,7 @@ export interface StreamChunk {
                 thought_signature?: string;
             }>;
             annotations?: Annotation[];
+            web_search_calls?: WebSearchCall[];
         };
         finish_reason?: string | null;
     }>;
@@ -241,6 +260,12 @@ export interface LLMProvider {
     models: string[];
     /** Optional GCP / Antigravity project id (provider-specific). */
     project_id?: string;
+    /**
+     * Request-scoped error rules for this provider (CLIProxyAPI port).
+     * Evaluated before global rules; first match decides stop vs continue.
+     * The provider service stores rules only under this canonical key.
+     */
+    request_scoped_errors?: RequestScopedErrorRule[];
     transformer?: {
         [key: string]: {
             use?: Transformer[];
@@ -250,7 +275,18 @@ export interface LLMProvider {
         passthrough?: any;
     };
 }
-export type RegisterProviderRequest = LLMProvider;
+/**
+ * Accepted input spellings of the request-scoped error rule list. The
+ * provider service folds them into `request_scoped_errors`.
+ */
+export interface RequestScopedErrorsCarrier {
+    request_scoped_errors?: RequestScopedErrorRule[];
+    requestScopedErrors?: RequestScopedErrorRule[];
+    "request-scoped-errors"?: RequestScopedErrorRule[];
+}
+export type RegisterProviderRequest = LLMProvider & RequestScopedErrorsCarrier;
+/** Provider update payload; any rule-list spelling replaces the stored rules. */
+export type ProviderUpdate = Partial<LLMProvider> & RequestScopedErrorsCarrier;
 export interface ModelRoute {
     provider: string;
     model: string;
@@ -261,7 +297,8 @@ export interface RequestRouteInfo {
     originalModel: string;
     targetModel: string;
 }
-export interface ConfigProvider {
+/** Request-scoped error rules use any RequestScopedErrorsCarrier spelling. */
+export interface ConfigProvider extends RequestScopedErrorsCarrier {
     name: string;
     api_base_url: string;
     api_key: string;

package/dist/utils/anthropic-client-policy.d.ts

@@ -1,4 +1,5 @@
 import { UnifiedChatRequest } from "../types/llm";
+import type { AnthropicSourceRequestFields, HostedWebSearchRequest } from "../routing/protocol-endpoints";
 export type AnthropicClientKind = "claude_desktop" | "claude_code" | "other";
 export type AnthropicProviderMode = "api_key" | "claude_oauth" | "out_of_scope";
 export interface AnthropicClientFingerprintSignals {
@@ -20,6 +21,8 @@ export interface AnthropicClientPolicyContext {
     anthropicPolicyApplied?: boolean;
     anthropicSystemTransformed?: boolean;
     claudeAuthToolNameMap?: Map<string, string>;
+    anthropicSource?: AnthropicSourceRequestFields;
+    hostedWebSearch?: HostedWebSearchRequest;
 }
 export declare function readHeaderValue(headers: Record<string, unknown> | undefined, name: string): string | undefined;
 /**
@@ -55,3 +58,8 @@ export declare function applyNativeClaudeOAuthCacheTtl(body: any, context: Anthr
  * before the provider's Anthropic body builder runs.
  */
 export declare function applyThirdPartyAnthropicPolicy(request: UnifiedChatRequest, context: AnthropicClientPolicyContext, configService: any): Promise<void>;
+/**
+ * Names of Anthropic-defined tools in this request: typed tools sent by an
+ * Anthropic client, and hosted web search requested over another protocol.
+ */
+export declare function anthropicFixedToolNames(context: AnthropicClientPolicyContext): string[];

package/dist/utils/claude-billing.d.ts

@@ -71,8 +71,23 @@ export declare function prefixClaudeToolName(name: string): string;
 /** Restore a Claude Code tool name to the caller's original spelling. */
 export declare function unprefixClaudeToolName(name: string): string;
 /** Rewrite tool names in a Unified request in place for the OAuth wire path. */
-export declare function prefixClaudeToolNames(request: UnifiedChatRequest, nameMap?: Map<string, string>): void;
-/** Rewrite tool names in a Unified/OpenAI-shaped response in place. */
-export declare function unprefixClaudeToolNames(value: any, nameMap?: Map<string, string>): void;
-/** Rewrite one OpenAI SSE data payload's tool names. */
-export declare function unprefixClaudeToolNamesInSseData(value: any, nameMap?: Map<string, string>): void;
+export declare function prefixClaudeToolNames(request: UnifiedChatRequest, nameMap?: Map<string, string>, fixedNames?: Iterable<string>): void;
+/**
+ * Rewrite tool names in a response payload in place and report whether any
+ * name changed. Accepts both shapes a response takes after the provider leg:
+ * Unified/OpenAI (`choices[].message|delta.tool_calls`) and Anthropic
+ * Messages wire (`content[]` tool_use blocks of a message, or the
+ * `content_block_start` stream event that carries a tool_use block's name).
+ *
+ * With a request-local `nameMap`, only names CCR itself prefixed are restored,
+ * which keeps the operation idempotent: a caller's own `mcp__server__tool`
+ * name is never stripped a second time. Without one, fall back to the
+ * spelling heuristic.
+ */
+export declare function unprefixClaudeToolNames(value: any, nameMap?: Map<string, string>): boolean;
+/**
+ * Restore CCR-prefixed tool names in a JSON or SSE response. SSE events and
+ * JSON bodies without a renamed tool are forwarded byte-identical, so
+ * exact-protocol responses keep the provider's usage and framing untouched.
+ */
+export declare function restoreClaudeToolNamesInResponse(response: Response, nameMap: Map<string, string>, logger?: any): Promise<Response>;

package/dist/utils/codex-bootstrap.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Codex stream bootstrap buffering (CLIProxyAPI `stream-bootstrap-buffering` port).
+ *
+ * The ChatGPT backend smuggles overload/quota rejections *inside* an HTTP 200
+ * SSE stream — right after the handshake events — instead of returning a
+ * retryable status on the wire. Once downstream headers are committed that
+ * failure can only be delivered to the client; holding the pre-generation
+ * bootstrap frames uncommitted keeps the window open for a transparent
+ * fallback to the next model.
+ *
+ * Held (never released on their own): handshake frames
+ * (`response.created`, `response.in_progress`, `response.queued`), `*.added`
+ * announcements, empty `output_text.delta` heartbeats, SSE comments, `event:`
+ * lines and blank separators. Anything else — text deltas, tool-call deltas,
+ * `*.done` / `*.completed` / `*.failed` / `error` frames, or an unparsable
+ * `data:` line — releases the buffer immediately. The hold is bounded by a
+ * frame budget and a byte budget, never by nothing.
+ */
+export interface CodexBootstrapOptions {
+    /** Max held `data:` lines before release. Default 48. */
+    maxFrames?: number;
+    /** Max held bytes before release. Default 1 MiB. */
+    maxBytes?: number;
+    /**
+     * Max hold time in ms before release. Default 0 (unlimited — the budget
+     * bounds what is held, not how long). Evaluated between reads; a peer that
+     * stops mid-line is still bounded by the request context, not this timer.
+     */
+    timeoutMs?: number;
+}
+/**
+ * Capacity failure classes, as Codex CLI distinguishes them: the server is
+ * overloaded (503), the request rate is limited (429), or the account's quota
+ * or plan does not cover it (429). Each is worth another model; a request
+ * failure is not.
+ */
+export type CodexOverloadKind = "overload" | "rate_limit" | "quota";
+export type CodexBootstrapRelease = "generated" | "budget" | "timeout" | "ended" | "overload";
+export interface CodexBootstrapResult {
+    /** Replayable response: held bytes followed by the live remainder. */
+    response: Response;
+    overloaded: boolean;
+    overloadKind?: CodexOverloadKind;
+    /** Raw bootstrap text that carried the overload signal (truncated). */
+    overloadText?: string;
+    /** Structured error fields retained for internal request-scoped matching. */
+    overloadErrorText?: string;
+    /** Retry-After value (seconds or HTTP date) the failed event advised. */
+    overloadRetryAfter?: string;
+    heldBytes: number;
+    heldFrames: number;
+    releasedBy: CodexBootstrapRelease;
+}
+export declare const DEFAULT_BOOTSTRAP_MAX_FRAMES = 48;
+export declare const DEFAULT_BOOTSTRAP_MAX_BYTES: number;
+/** Capacity class of a structured Responses error; `message` is ignored. */
+export declare function classifyCodexError(error: {
+    code?: unknown;
+    type?: unknown;
+    message?: unknown;
+}): CodexOverloadKind | undefined;
+/**
+ * Buffer the Codex SSE bootstrap. Never throws on upstream content: overload
+ * is reported on the result so the caller can raise a fallback-eligible error
+ * *before* downstream headers commit. The returned response replays held
+ * bytes first, then the untouched remainder of the original stream.
+ */
+export declare function bufferCodexBootstrapStream(response: Response, options?: CodexBootstrapOptions, signal?: AbortSignal): Promise<CodexBootstrapResult>;

package/dist/utils/codex-model-catalog.d.ts

@@ -0,0 +1,63 @@
+/**
+ * OpenAI model metadata imported from Codex CLI's bundled catalog
+ * (codex-rs `models-manager/models.json`), so CCR sends what Codex sends:
+ *
+ * - reasoning effort: only the model's supported levels. `ultra` is a picker
+ *   alias and never reaches the wire (`ModelInfo::resolve_reasoning_effort`).
+ * - Responses Lite: the request shape Codex uses for `use_responses_lite`
+ *   models (`core/src/client.rs::build_responses_request`).
+ * - verbosity: only models with `support_verbosity`.
+ *
+ * Refresh the table when Codex adds or retires catalog models.
+ */
+import { type ReasoningSummaryLevel } from "./reasoning-effort";
+import type { ThinkLevel } from "../types/llm";
+export type CodexTextVerbosity = "low" | "medium" | "high";
+export interface CodexModelSpec {
+    /** `supported_reasoning_levels`, lowest first. */
+    efforts: readonly ThinkLevel[];
+    /** `multi_agent_reasoning_effort`: what `ultra` resolves to, when set. */
+    ultraEffort?: ThinkLevel;
+    /** `use_responses_lite`. */
+    responsesLite: boolean;
+    /** `support_verbosity`. */
+    verbosity: boolean;
+}
+/**
+ * GPT-6 Luna slugs (`gpt-6-luna`, `gpt-6.1-luna`, `openai/gpt-6-luna`,
+ * `codex,gpt-6.1-luna`). Anchored so `gpt-6-sol` / `gpt-6-astra` /
+ * `gpt-5.6-luna` do not match.
+ */
+export declare function isGpt6LunaModel(model: unknown): boolean;
+/**
+ * Catalog metadata for a model id, or undefined for models Codex does not
+ * list. GPT-6 slugs newer than the table get the family's shape (Luna tops
+ * out at `max`), so a new minor release keeps working before a refresh.
+ */
+export declare function codexModelSpec(model: unknown): CodexModelSpec | undefined;
+/**
+ * The effort a catalog model is sent. `ultra` follows Codex: the model's
+ * multi-agent effort, else `max`, else the highest level below `ultra`. Any
+ * other unsupported level moves to the nearest end of the supported range
+ * (`none` / `minimal` → the lowest). Unknown tokens and unlisted models pass
+ * through unchanged.
+ */
+export declare function resolveCodexReasoningEffort(model: unknown, effort: ThinkLevel | undefined): ThinkLevel | undefined;
+/**
+ * Apply `resolveCodexReasoningEffort` to a Responses/Unified request in
+ * place. Covers convert (`openai-responses`) and same-protocol wire-keep
+ * (`codex`). A disabled-reasoning request raised to a supported level is
+ * re-enabled, since the model cannot run without reasoning.
+ */
+export declare function applyCodexReasoningEffort(request: {
+    model?: unknown;
+    reasoning?: {
+        effort?: unknown;
+        enabled?: boolean;
+    } | null;
+}): void;
+/**
+ * `text.verbosity` implied by `REASONING_AUTO_SUMMARY`: detailed thinking
+ * pairs with verbose answers, concise with terse ones.
+ */
+export declare function verbosityForReasoningSummary(summary: ReasoningSummaryLevel | undefined): CodexTextVerbosity | undefined;

package/dist/utils/nested-agent.d.ts

@@ -2,6 +2,8 @@
 export declare function firstUserText(request: unknown): string;
 export declare function isHarnessUserNoise(text: string): boolean;
 export declare function userMessageTextParts(content: unknown): string[];
+/** Substantive user turns, in order. Reminders and caveats are not identity. */
+export declare function substantiveUserTexts(request: unknown): string[];
 /**
  * First user text that distinguishes a worker transcript.
  * Shared reminder/caveat preambles are skipped so parallel Tasks do not collide.
@@ -9,6 +11,8 @@ export declare function userMessageTextParts(content: unknown): string[];
 export declare function firstSubstantiveUserText(request: unknown): string;
 /** Statusline / spinner polls — must not supersede or become a cache baseline. */
 export declare function isStatuslinePollTurn(request: unknown): boolean;
+/** Explicit worker-fork boundary, including inside inherited history. */
+export declare function isForkOpeningText(text: string): boolean;
 /**
  * Nested/worker agent on any inbound protocol.
  *