@caeliq/llms 1.0.57 → 1.0.59

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

@@ -0,0 +1,58 @@
+import { TextContent, UnifiedChatRequest, UnifiedMessage } from "../types/llm";
+/** Salt used in Claude Code's `cc_version` suffix hash (`RYn()`). */
+export declare const BILLING_SALT = "59cf53e54c78";
+export declare const CC_VERSION: string;
+export declare const CC_ENTRYPOINT: string;
+export declare const SYSTEM_IDENTITY = "You are Claude Code, Anthropic's official CLI for Claude.";
+export declare function extractFirstUserMessageText(messages: UnifiedMessage[] | undefined): string;
+export declare function computeVersionSuffix(text: string, version: string): string;
+/** 5 lowercase hex chars, cached per process — not a content hash. */
+export declare function sessionCch(): string;
+export declare function __resetClaudeBillingStateForTests(): void;
+export declare function buildClaudeBillingHeaderValue(messages: UnifiedMessage[] | undefined, version?: string, entrypoint?: string): string;
+/**
+ * Normalize `request.system` to an array as a complete ordered fold:
+ * top-level `request.system` blocks first, then every `role:"system"` /
+ * `role:"developer"` message's text blocks in source order. Consumed messages
+ * are removed from `request.messages` so no downstream builder can drop or
+ * double-emit them. Block-level `cache_control` is preserved.
+ */
+export declare function normalizeSystemToArray(request: UnifiedChatRequest): TextContent[];
+/** Drop any existing billing entry (dedupe) and prepend a fresh one at system[0]. */
+export declare function applyClaudeBillingSystemBlock(system: TextContent[], messages: UnifiedMessage[] | undefined): void;
+/**
+ * Insert SYSTEM_IDENTITY as its own entry at system[1]. Any remaining
+ * caller system content is left in place here — relocateForeignSystemContent
+ * (called separately, afterwards) is what moves it out of system[].
+ */
+export declare function applyClaudeSystemIdentity(system: TextContent[]): void;
+/**
+ * Move everything in `system[]` past the identity block (index 1) into the
+ * first user message instead. Anthropic's OAuth billing validator appears to
+ * inspect `system[]` content beyond the identity prefix and reject requests
+ * whose system array carries a foreign harness prompt with an "out of extra
+ * usage" 400 — the same approach used by third-party Claude Code OAuth
+ * clients (e.g. opencode-claude-auth). The relocated text still reaches the
+ * model, just as part of the first user turn rather than
+ * `system[]`.
+ *
+ * A no-op when there is no user message to attach the content to, so nothing
+ * is silently dropped — the caller's system content stays in `system[]`
+ * instead.
+ */
+export declare function relocateForeignSystemContent(system: TextContent[], messages: UnifiedMessage[] | undefined): void;
+/**
+ * Claude Code's OAuth validator expects tool names in the mcp_PascalCase
+ * spelling used by the official CLI. Non-Claude-Code clients commonly send
+ * ordinary names such as `bash` or `read`, so normalize them before the
+ * Anthropic body is built. The prefix check keeps this operation idempotent.
+ */
+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;

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

@@ -0,0 +1,49 @@
+/**
+ * Claude Code's bundled model capability catalog (extracted from v2.1.220).
+ *
+ * Every model-dependent decision in the claude-auth impersonation path (beta
+ * flags, effort support, thinking shape, max_tokens ceiling) is driven by
+ * `capabilities` membership here, never by matching on the model name.
+ */
+export interface ClaudeModelCatalogEntry {
+    /** Context window in tokens, or undefined when the model predates 1M-context routing. */
+    window?: number;
+    /** Router carries a native (unconditional) 1M-token context window. */
+    nativeOneMillion: boolean;
+    /** Model can opt into a 1M-token window via the context-1m-2025-08-07 beta. */
+    supportsOneMillionBeta: boolean;
+    /** Model id accepts an explicit "[1m]" wire suffix. */
+    supportsOneMillionSuffix: boolean;
+    maxOutputTokens: {
+        default: number;
+        upper: number;
+    };
+    defaultEffort?: string;
+    capabilities: string[];
+}
+export declare const CLAUDE_MODEL_CATALOG: Record<string, ClaudeModelCatalogEntry>;
+/** Strip the "[1m]" wire marker, reporting whether it was present. */
+export declare function stripOneMillionContextMarker(modelId: string | undefined): {
+    modelId: string;
+    requestedOneMillion: boolean;
+};
+/**
+ * Normalize a routed model id (CCR "provider,model" selector, an optional
+ * "[1m]" marker, and Anthropic's dated model-id suffix) down to a catalog
+ * key, e.g. "anthropic,claude-opus-5-20260101[1m]" -> "claude-opus-5".
+ */
+export declare function normalizeModelIdForCatalog(modelId: string | undefined): string;
+/** Look up a model's catalog entry. Unknown models resolve to undefined (minimal capability set). */
+export declare function lookupClaudeModelCatalogEntry(modelId: string | undefined): ClaudeModelCatalogEntry | undefined;
+export declare function catalogEntryHasCapability(entry: ClaudeModelCatalogEntry | undefined, capability: string): boolean;
+/**
+ * Whether extended-thinking betas apply to this model. The catalog has no
+ * dedicated "supports_thinking" column, but every entry that predates the
+ * Claude 4 thinking generation (claude-3-5-haiku, claude-3-5-sonnet,
+ * claude-3-7-sonnet) — plus the not-yet-classified claude-mythos-5 — carries
+ * an empty capability set; every thinking-capable model carries at least
+ * "context_management". A non-empty capability set is therefore a reliable,
+ * self-documenting proxy that also degrades unknown models to "no thinking"
+ * rather than guessing.
+ */
+export declare function catalogEntrySupportsThinking(entry: ClaudeModelCatalogEntry | undefined): boolean;

package/dist/utils/headers.d.ts

@@ -0,0 +1,10 @@
+export type HeaderRecord = Record<string, string | undefined>;
+export declare function mergeHeadersCaseInsensitive(base: HeaderRecord | undefined, update: HeaderRecord | undefined): HeaderRecord;
+/**
+ * Carry non-representational upstream response headers (rate-limit/usage
+ * metadata, request ids, etc.) onto a reshaped `Response`, so overage
+ * observability (`anthropic-ratelimit-unified-*`) survives SSE re-framing.
+ */
+export declare function preserveUpstreamResponseHeaders(headers: Headers | undefined): Record<string, string>;
+export declare function selectSafeDownstreamHeaders(headers: Headers | HeaderRecord | undefined): Record<string, string>;
+export declare function canonicalizeOutboundHeaders(headers: HeaderRecord | undefined, fallbackBearer?: string): Record<string, string>;

package/dist/utils/mistral.util.d.ts

@@ -2,7 +2,7 @@ import { UnifiedChatRequest } from "../types/llm";
 /**
  * Transform incoming request to Mistral-compatible format
  */
-export declare function buildRequestBody(request: UnifiedChatRequest, context?: any, provider?: any): Record<string, any>;
+export declare function buildRequestBody(request: UnifiedChatRequest, context?: any, _provider?: any): Record<string, any>;
 /**
  * Transform a Mistral provider request back into a UnifiedChatRequest
  */

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

@@ -0,0 +1,23 @@
+export declare function isValidAnthropicToolCallId(id: unknown): id is string;
+/**
+ * Coerce an id into Anthropic's allowed alphabet.
+ *
+ * Runs of invalid characters collapse to a single `_` rather than being
+ * deleted: deletion can merge two distinct ids into one (`a\nb` and `ab` both
+ * become `ab`), and a duplicate `tool_use.id` is a worse failure than a long
+ * one — it silently mispairs tool results.
+ *
+ * Must be deterministic and idempotent. The same id arrives from two
+ * independent directions — emitted on the response and echoed back by the
+ * client on the next request — and both must map to the same value or the
+ * `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.57",
+  "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.0.3",
-    "@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",