@caeliq/llms 1.0.71 → 1.0.73

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

@@ -1,4 +1,5 @@
 import { UnifiedChatRequest } from "../types/llm";
+import type { HostedWebSearchRequest } from "../routing/protocol-endpoints";
 export interface ResponsesCallIdMap {
     /** Original client call_id → sanitized id (and reverse). */
     forward: Map<string, string>;
@@ -18,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;
@@ -170,6 +207,14 @@ export interface CodexIsolateConventionsOptions {
  * apply the exec/patch normalizers in one place so stream finalize, the
  * completed skeleton, and the non-stream JSON path cannot drift. */
 export declare function normalizeClientCustomToolInput(name: string | undefined, rawArguments: string, options?: CodexIsolateConventionsOptions): string;
+/**
+ * Hosted web search options from a Responses `web_search` tool. Unified keeps
+ * only the `web_search` function projection, so destinations that run the
+ * search themselves (Anthropic server tools) read these request-locally.
+ */
+export declare function hostedWebSearchFromResponsesTools(tools: unknown): HostedWebSearchRequest | undefined;
+/** Approximate location fields shared by Responses and Chat search options. */
+export declare function hostedUserLocation(location: any): Pick<HostedWebSearchRequest, "userLocation">;
 /** Unified Chat JSON → Responses API non-stream response. */
 export declare function unifiedResponseToResponses(chat: any, options?: {
     originalModel?: string;
@@ -185,10 +230,20 @@ export interface ResponsesStreamState {
     textClosed: boolean;
     textOutputIndex?: number;
     textContent: string;
+    /** Unified text length before the current text item (annotation offsets). */
+    textBase: number;
+    /** Unified text length emitted so far across all text items. */
+    totalTextLength: number;
+    textAnnotations: any[];
     closedTextItems: Array<{
         id: string;
         outputIndex: number;
         content: string;
+        annotations: any[];
+    }>;
+    webSearchCalls: Array<{
+        item: any;
+        outputIndex: number;
     }>;
     toolCalls: Map<number, {
         id: 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.71",
+  "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.13",
-    "@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",