@caeliq/llms 1.0.58 → 1.0.59

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

@@ -0,0 +1,53 @@
+import { UnifiedChatRequest } from "../types/llm";
+export interface ResponsesCallIdMap {
+    /** Original client call_id → sanitized id (and reverse). */
+    forward: Map<string, string>;
+    reverse: Map<string, string>;
+}
+export declare function createCallIdMap(): ResponsesCallIdMap;
+/** Sanitize and remember a stable per-turn mapping for function call correlation. */
+export declare function mapCallId(map: ResponsesCallIdMap, id: unknown, direction?: "client_to_unified" | "unified_to_client"): string | undefined;
+/**
+ * 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): UnifiedChatRequest;
+/** Unified Chat JSON → Responses API non-stream response. */
+export declare function unifiedResponseToResponses(chat: any, options?: {
+    originalModel?: string;
+    callIdMap?: ResponsesCallIdMap;
+}): any;
+export interface ResponsesStreamState {
+    responseId: string;
+    model?: string;
+    textItemId: string;
+    textStarted: boolean;
+    textOutputIndex?: number;
+    textContent: string;
+    toolCalls: Map<number, {
+        id: string;
+        name: string;
+        arguments: string;
+        added: boolean;
+        outputIndex: number;
+        emittedArgumentsLength: number;
+    }>;
+    nextOutputIndex: number;
+    finished: boolean;
+    created: boolean;
+    sequenceNumber: number;
+    finishReasonSeen: boolean;
+    usage?: any;
+    callIdMap: ResponsesCallIdMap;
+}
+export declare function createResponsesStreamState(options?: {
+    model?: string;
+    callIdMap?: ResponsesCallIdMap;
+}): ResponsesStreamState;
+/**
+ * Convert one Unified Chat Completions chunk into zero or more Responses
+ * stream events, including the mandatory content_part lifecycle for Codex.
+ */
+export declare function unifiedChunkToResponsesEvents(chunk: any, state: ResponsesStreamState): any[];
+export declare function finalizeResponsesStream(state: ResponsesStreamState, usage?: any): any[];
+export declare function responsesFailedEvent(message: string, state?: ResponsesStreamState): any;

package/dist/utils/redact.d.ts

@@ -3,6 +3,24 @@
  * Keep enough diagnostic signal (status, error type) without leaking secrets.
  */
 export declare function sanitizeUpstreamErrorText(value: string): string;
+/**
+ * Deep-sanitize a parsed upstream error body before it is logged or
+ * serialized to a client: secret-bearing keys are redacted outright and
+ * every string value passes through sanitizeUpstreamErrorText. Depth and
+ * array length are bounded so an adversarial body cannot balloon.
+ */
+export declare function sanitizeUpstreamErrorBody(value: unknown, depth?: number): unknown;
+/** Default cap for a single logged request body. */
+export declare const DEFAULT_LOG_BODY_MAX_BYTES = 32768;
+/**
+ * Redact secrets from a request body that is about to be logged verbatim.
+ *
+ * Unlike sanitizeUpstreamErrorText this preserves whitespace, newlines and
+ * full string values: the point of body capture is to read prompts and
+ * message content back, so per-string truncation would defeat it. Only
+ * secret-bearing patterns are rewritten, then the whole payload is capped.
+ */
+export declare function sanitizeBodyForLog(value: string, maxBytes?: number): string;
 export declare function sanitizeErrorForLog(error: unknown): {
     message: string;
     code?: string;

package/dist/utils/request.d.ts

@@ -1,4 +1,4 @@
 import { UnifiedChatRequest } from "../types/llm";
 /** Loopback and NO_PROXY/no_proxy hosts should not go through HTTPS_PROXY. */
 export declare function shouldBypassProxy(target: URL | string): boolean;
-export declare function sendUnifiedRequest(url: URL | string, request: UnifiedChatRequest, config: any, context: any, logger?: any): Promise<Response>;
+export declare function sendUnifiedRequest(url: URL | string, request: UnifiedChatRequest, config: any, _context: any, _logger?: any): Promise<Response>;

package/dist/utils/retry.d.ts

@@ -24,4 +24,11 @@ export declare function toClientAbortError(reason?: unknown): Error;
 export declare function isClientAbortError(error: unknown): boolean;
 export declare function isResponseSocketGone(reply: FastifyReply): boolean;
 export declare function isProviderNetworkError(error: unknown): boolean;
+/**
+ * HTTP statuses worth trying another model for: transient throttling,
+ * contention, and server-side failures. Ordinary 4xx responses (validation,
+ * authentication, permissions, model-not-found) are terminal — resending the
+ * identical request to a fallback model would fail the same way.
+ */
+export declare function isFallbackEligibleStatus(status: number | undefined): boolean;
 export declare function isFallbackEligibleError(error: unknown): boolean;

package/dist/utils/router.d.ts

@@ -13,8 +13,10 @@ interface MessageParam {
     role: string;
     content: string | ContentBlockParam[];
 }
+export declare const CLAUDE_CODE_BILLING_SYSTEM_HEADER_PREFIX = "x-anthropic-billing-header";
 /** Normalize `provider/model` or `provider,model` into our `provider,model` form. */
 export declare function normalizeModelSelector(value: string | undefined | null): string | undefined;
+export declare function claudeCodeBillingMetadataIsSubagent(text: string): boolean;
 /**
  * Strip Claude Code's billing helper system block.
  * Returns true when that block marks the request as a subagent.
@@ -22,6 +24,11 @@ export declare function normalizeModelSelector(value: string | undefined | null)
 export declare function removeClaudeCodeBillingSystemHeader(body: any): boolean;
 /** Prefer system tag, then early user-message tag; strip whichever matched. */
 export declare function extractAndRemoveClaudeCodeSubagentModelTag(body: any): string | undefined;
+/** Read Claude Code's billing/subagent marker without mutating the source body. */
+export declare function inspectClaudeCodeBillingSystemHeader(body: any): {
+    present: boolean;
+    isSubagent: boolean;
+};
 export declare const calculateTokenCount: (messages: MessageParam[], system: any, tools: Tool[]) => number;
 export interface RouterContext {
     configService: ConfigService;

package/dist/utils/stream.d.ts

@@ -5,6 +5,8 @@ export interface StreamContext {
 export declare function createSSEStreamReader(response: Response, processLine: (line: string, context: StreamContext) => void, options?: {
     bufferSize?: number;
     onComplete?: (context: StreamContext) => void;
+    /** Return true when the protocol adapter emitted its own terminal error. */
+    onError?: (error: unknown, context: StreamContext) => boolean | void;
     logger?: any;
 }): Response;
 export declare function encodeSSEData(data: string, encoder: TextEncoder): Uint8Array;

package/dist/utils/toolCallId.d.ts

@@ -13,3 +13,11 @@ export declare function isValidAnthropicToolCallId(id: unknown): id is string;
  * `tool_use` / `tool_result` pair stops matching.
  */
 export declare function sanitizeToolCallId(id: unknown): string | undefined;
+/**
+ * Bound a Responses API call id without losing tool-call/result pairing.
+ *
+ * Invalid or overlong ids use a readable prefix plus a deterministic hash of
+ * the original value. Hashing avoids collisions from either normalization or
+ * plain truncation, while the conforming fast path makes this idempotent.
+ */
+export declare function sanitizeResponsesCallId(id: unknown): string | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@caeliq/llms",
-  "version": "1.0.58",
+  "version": "1.0.59",
   "description": "A universal LLM API transformation server",
   "main": "dist/cjs/server.cjs",
   "module": "dist/esm/server.mjs",
@@ -29,30 +29,34 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.54.0",
-    "@caeliq/ccr-shared": "^2.1.0",
-    "@cursor/sdk": "^1.0.23",
-    "@fastify/cors": "^11.0.1",
-    "@google/genai": "^2.13.0",
-    "@huggingface/tokenizers": "^0.0.6",
-    "dotenv": "^16.5.0",
-    "fastify": "^5.4.0",
-    "fastify-plugin": "^5.1.0",
-    "google-auth-library": "^10.1.0",
+    "@anthropic-ai/sdk": "^0.115.0",
+    "@caeliq/ccr-shared": "^2.1.1",
+    "@cursor/sdk": "^1.0.26",
+    "@fastify/cors": "^11.3.0",
+    "@fastify/rate-limit": "^10.3.0",
+    "@google/genai": "^2.15.0",
+    "@huggingface/tokenizers": "^0.1.3",
+    "dotenv": "^17.4.2",
+    "fastify": "^5.11.2",
+    "fastify-plugin": "^6.0.0",
+    "google-auth-library": "^11.0.0",
     "json5": "^2.2.3",
-    "jsonrepair": "^3.13.0",
+    "jsonrepair": "^3.15.0",
     "latex-to-unicode": "^0.1.0",
-    "lru-cache": "^11.2.2",
-    "openai": "^5.6.0",
-    "tiktoken": "^1.0.21",
-    "undici": "^7.10.0",
-    "uuid": "^11.1.0"
+    "lru-cache": "^11.5.2",
+    "openai": "^7.2.0",
+    "tiktoken": "^1.0.22",
+    "undici": "^8.9.0",
+    "uuid": "^14.0.1"
   },
   "devDependencies": {
-    "@types/node": "^24.0.15",
-    "esbuild": "^0.25.1",
-    "tsx": "^4.20.3",
-    "typescript": "^5.8.2"
+    "@types/node": "^26.1.2",
+    "esbuild": "^0.28.1",
+    "tsx": "^4.23.1",
+    "typescript": "^6.0.3"
+  },
+  "engines": {
+    "node": ">=22.19.0"
   },
   "repository": {
     "type": "git",