@caeliq/llms 1.0.72 → 1.0.73

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/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/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;
@@ -259,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[];
@@ -268,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;
@@ -279,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/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.
  *

package/dist/utils/openai.responses.util.d.ts

@@ -19,11 +19,47 @@ export declare function mapCallId(map: ResponsesCallIdMap, id: unknown, directio
  * collisions resolve identically in both directions.
  */
 export declare function sanitizeResponsesWireCallIds(body: any, callIdMap?: ResponsesCallIdMap): any;
+/**
+ * Opt-in inbound compatibility for Codex multi-agent traffic (CLIProxyAPI
+ * `orphan-delegation-compatibility` / `optimize-multi-agent-v2` port).
+ *
+ * Both flags default to false and are read from top-level config
+ * (`orphanDelegationCompatibility` / `orphan_delegation_compatibility`,
+ * `optimizeMultiAgentV2` / `optimize_multi_agent_v2`). Orphan conversion
+ * additionally requires the `X-Openai-Subagent: collab_spawn` request header,
+ * so unrelated clients never silently change shape.
+ */
+export interface ResponsesInboundCompatOptions {
+    orphanDelegationCompatibility?: boolean;
+    optimizeMultiAgentV2?: boolean;
+    /** True when the collab_spawn subagent header is present on the request. */
+    subagentCollabSpawn?: boolean;
+}
+export declare function hasCollabSpawnSubagentHeader(headers: unknown): boolean;
+export declare function resolveResponsesInboundCompat(headers: unknown, configService?: {
+    get(key: string): any;
+}): ResponsesInboundCompatOptions;
+/**
+ * Apply the opt-in multi-agent compatibility to the Responses client wire.
+ *
+ * Same-protocol wire keep (primary and fallback) sends `clientWireBody`
+ * upstream instead of the Unified projection, so the Unified-side conversion
+ * alone would still ship items the upstream cannot correlate or does not
+ * know. Under the same gates as responsesRequestToUnified:
+ * - orphan outputs (flag + `collab_spawn` header) become user message items,
+ *   ordered exactly like the Unified projection;
+ * - role-less `agent_message` items (`optimizeMultiAgentV2`) become user
+ *   message items with their content parts preserved.
+ * Role-bearing `agent_message` items and every other item stay byte-identical.
+ * Call only after normalization has validated the body. Returns the input
+ * body when nothing changes.
+ */
+export declare function repairResponsesWireMultiAgentCompat(body: any, compat: ResponsesInboundCompatOptions): any;
 /**
  * Client Responses wire → Unified (Chat Completions shape).
  * Supports the Responses MVP subset; rejects CCR-unsupported stateful fields.
  */
-export declare function responsesRequestToUnified(body: any, callIdMap?: ResponsesCallIdMap, customToolNames?: Set<string>): UnifiedChatRequest;
+export declare function responsesRequestToUnified(body: any, callIdMap?: ResponsesCallIdMap, customToolNames?: Set<string>, compat?: ResponsesInboundCompatOptions): UnifiedChatRequest;
 /** Responses `include` is a string list; drop non-strings rather than invent values. */
 export declare function normalizeResponsesInclude(include: unknown): string[] | undefined;
 export declare function isResponsesReasoningItemId(value: unknown): value is string;

package/dist/utils/reasoning-effort.d.ts

@@ -33,28 +33,11 @@ export declare function applyOpenAIChatReasoning(request: UnifiedChatRequest): U
 /** Anthropic accepts low..max, while CCR/OpenAI may additionally emit minimal/ultra/none. */
 export declare function toAnthropicReasoningEffort(effortValue: unknown): Exclude<ThinkLevel, "none" | "minimal" | "ultra"> | undefined;
 /**
- * GPT-6 family slugs (`gpt-6`, `gpt-6-astra`, `openai/gpt-6-astra`,
- * `codex,gpt-6-astra`). Anchored so `gpt-60` / `gpt-5.6` do not match.
+ * GPT-6 family slugs (`gpt-6`, `gpt-6-astra`, `gpt-6.1-sol`,
+ * `openai/gpt-6-astra`, `codex,gpt-6.1-sol`). Anchored so `gpt-60` /
+ * `gpt-5.6` do not match.
  */
 export declare function isGpt6FamilyModel(model: unknown): boolean;
-/** Astra/Sol reject `none` / `minimal`; OpenAI's migration floor is `low`. */
-export declare function coerceGpt6ReasoningEffort(model: unknown, effort: ThinkLevel | undefined): ThinkLevel | undefined;
-/**
- * GPT-6 Luna slugs (`gpt-6-luna`, `openai/gpt-6-luna`, `codex,gpt-6-luna`).
- * Anchored so `gpt-6-sol` / `gpt-6-astra` do not match.
- */
-export declare function isGpt6LunaModel(model: unknown): boolean;
-/**
- * Remap unsupported GPT-6 efforts on a Responses/Unified request in place.
- * Covers convert (`openai-responses`) and same-protocol wire-keep (`codex`).
- */
-export declare function applyGpt6ReasoningEffortCoercion(request: {
-    model?: unknown;
-    reasoning?: {
-        effort?: unknown;
-        enabled?: boolean;
-    } | null;
-}): void;
 /**
  * GPT-6 Astra rejects temperature / top_p / logprobs on Responses. Strip in
  * place when the model is in the gpt-6 family.

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

@@ -0,0 +1,92 @@
+export type RequestScopedErrorAction = "stop" | "stop-and-cooldown" | "continue" | "continue-and-cooldown";
+export interface RequestScopedErrorRule {
+    status?: number;
+    match?: string[];
+    match_regex?: string[];
+    matchRegex?: string[];
+    "match-regex"?: string[];
+    action: RequestScopedErrorAction;
+    cooldown_seconds?: number;
+    cooldownSeconds?: number;
+}
+export interface NormalizedScopedErrorRule {
+    status?: number;
+    /** Lowercased substring patterns. */
+    match: string[];
+    matchRegex: RegExp[];
+    action: RequestScopedErrorAction;
+    cooldownSeconds: number;
+}
+/** A config rule rejected by validation; `index` is -1 for a non-array list. */
+export interface ScopedErrorRuleIssue {
+    index: number;
+    reason: string;
+}
+/** Default cooldown for `*-and-cooldown` actions (matches legacy 60s transient). */
+export declare const DEFAULT_SCOPED_ERROR_COOLDOWN_SECONDS = 60;
+/** Accepted spellings of the rule-list key, canonical first. */
+export declare const SCOPED_ERROR_RULE_KEYS: readonly ["request_scoped_errors", "requestScopedErrors", "request-scoped-errors"];
+/**
+ * Compile raw config rules. An invalid rule (unknown key, bad action, status,
+ * pattern list, regex or cooldown) is dropped and reported via `onInvalid`;
+ * it is never widened into a broader match.
+ */
+export declare function normalizeRequestScopedErrorRules(input: unknown, onInvalid?: (issue: ScopedErrorRuleIssue) => void): NormalizedScopedErrorRule[];
+/**
+ * Compiled rules for a raw config list, cached per list object so validation
+ * (and its `onInvalid` reports) runs once per config value, not per request.
+ */
+export declare function compiledScopedErrorRules(input: unknown, onInvalid?: (issue: ScopedErrorRuleIssue) => void): NormalizedScopedErrorRule[];
+/** Read a rule list from a config carrier under any accepted key spelling. */
+export declare function readScopedErrorRulesFromCarrier(carrier: unknown): unknown;
+/** Top-level (global) rule list from a config service, any key spelling. */
+export declare function readGlobalScopedErrorRules(configService: {
+    get(key: string): unknown;
+}): unknown;
+/** Upper bound (chars) on the raw text kept for rule matching. */
+export declare const MAX_SCOPED_ERROR_CLASSIFICATION_CHARS = 16384;
+/** Attach the raw upstream error text an error was built from. */
+export declare function attachScopedErrorClassificationText(error: unknown, rawText: unknown): void;
+/** Raw classification text previously attached to an error, if any. */
+export declare function readScopedErrorClassificationText(error: unknown): string | undefined;
+/** HTTP status for classification: explicit field first, then upstream snapshot. */
+export declare function errorStatusForClassification(error: any): number | undefined;
+/**
+ * Searchable body text. Prefers the raw upstream text a producer attached;
+ * without it, falls back to the message plus any captured upstream body. A
+ * specific error code is appended either way. The error `type` (always
+ * `api_error` for provider failures) is never included.
+ */
+export declare function errorTextForClassification(error: any): string;
+/** First matching rule, or undefined when nothing matches. */
+export declare function matchScopedErrorRule(error: any, rules: NormalizedScopedErrorRule[]): NormalizedScopedErrorRule | undefined;
+export type ScopedErrorDecision = {
+    kind: "default";
+} | {
+    kind: "stop" | "continue";
+    rule: NormalizedScopedErrorRule;
+    cooldown: boolean;
+};
+/**
+ * Classify an upstream error against provider rules first, then global rules.
+ * `stop` forces a terminal failure (no fallback); `continue` forces fallback
+ * eligibility even when the status alone would not qualify.
+ */
+export declare function decideScopedError(error: any, providerRules: NormalizedScopedErrorRule[], globalRules: NormalizedScopedErrorRule[]): ScopedErrorDecision;
+/**
+ * Cooldown key. The model drops its `[1m]` context marker: the primary route
+ * strips it before dispatch while fallback entries keep it as configured,
+ * yet both name the same upstream model.
+ */
+export declare function scopedErrorCooldownKey(providerName: string, model: string): string;
+export declare class ScopedErrorCooldownRegistry {
+    private readonly expiries;
+    put(providerName: string, model: string, cooldownSeconds?: number, now?: number): void;
+    isCooledDown(providerName: string, model: string, now?: number): boolean;
+    /** Drop every expired entry so keys that are never re-read cannot pile up. */
+    prune(now?: number): void;
+    /** Number of tracked entries, expired or not. */
+    get size(): number;
+}
+/** The cooldown registry owned by `scope`, created on first use. */
+export declare function scopedErrorCooldownsFor(scope: object): ScopedErrorCooldownRegistry;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@caeliq/llms",
-  "version": "1.0.72",
+  "version": "1.0.73",
   "description": "A universal LLM API transformation server",
   "main": "dist/cjs/server.cjs",
   "module": "dist/esm/server.mjs",
@@ -30,8 +30,8 @@
   ],
   "dependencies": {
     "@anthropic-ai/sdk": "^0.120.0",
-    "@caeliq/ccr-shared": "^2.1.14",
-    "@cursor/sdk": "^1.0.32",
+    "@caeliq/ccr-shared": "^2.1.15",
+    "@cursor/sdk": "^1.0.36",
     "@fastify/cors": "^11.3.0",
     "@fastify/rate-limit": "^11.2.0",
     "@google/genai": "^2.18.0",