@caeliq/llms 1.0.69 → 1.0.71

package/dist/tests/opencode-gate-stubs.d.ts

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

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

@@ -48,7 +48,7 @@ export declare function modelIdForRequestedOneMillionBeta(modelId: string | unde
  * post-build Anthropic body (not the Unified request) because
  * `buildAnthropicBody` may synthesize `thinking`/`output_config` itself.
  */
-export declare function applyClaudeModelCapabilityAdjustments(anthropicBody: Record<string, any>, entry: ClaudeModelCatalogEntry | undefined): void;
+export declare function applyClaudeModelCapabilityAdjustments(anthropicBody: Record<string, any>, entry: ClaudeModelCatalogEntry | undefined, logger?: any): void;
 /** Test-only reset hook so session-id state doesn't leak across test cases. */
 export declare function __resetClaudeAuthTransformerStateForTests(): void;
 /** Synthesized Claude Code identity headers for the non-Claude-Code branch. */

package/dist/transformer/opencode-headers.transformer.d.ts

@@ -5,23 +5,37 @@ export declare class OpencodeHeadersTransformer implements Transformer {
     requestPhase: "transport";
     private lastTimestamp;
     private counter;
+    private firstEventTimeoutMs;
+    private firstProgressTimeoutMs;
+    private streamIdleTimeoutMs;
+    private reasoningIdleTimeoutMs;
     transformRequestIn(request: any, provider: any, context: any): Promise<Record<string, any>>;
-    transformResponseOut(response: Response): Promise<Response>;
+    transformResponseOut(response: Response, context?: any): Promise<Response>;
+    /** Restore JSON for clients whose requests were streamed only to pass Zen's gate. */
+    private collectForcedStream;
     /**
-     * Own the full upstream call so a `No provider available` 401 can be retried
-     * with a fresh session in isolation. Any other non-ok response is re-thrown in
-     * the exact shape sendRequestToProvider would have produced, so genuine
-     * auth/rate/server errors keep flowing through the normal error + fallback
-     * path unchanged.
+     * Own the full upstream call so Zen routing failures can be recovered by
+     * re-rolling the session, and transient failures retried on the same one.
+     * Exhausted routing failures become 503 so the normal fallback path can try
+     * another model; ordinary 4xx errors retain their upstream status.
      */
     private sendWithSessionRetry;
+    /**
+     * Zen can send SSE headers and lifecycle events, then stall before any
+     * output. Hold the response until a complete event and real output progress
+     * arrive while a fallback is still possible, then bound later idle reads.
+     * An open reasoning item emits nothing until it finishes when no summary is
+     * streamed, so while one is open the looser reasoning bound applies instead.
+     */
+    private requireFirstZenEvent;
     private preserveZenStreamErrors;
     private static zenStreamFailure;
     private buildHeaders;
     private resolveParentSessionId;
     /**
-     * True only for the two Zen session-hash routing failures — a re-roll can
-     * recover these. Kept deliberately narrow (exact status + message) so genuine
+     * True only for the two Zen session-hash routing failures — retried on the
+     * SAME session (which must not change during a conversation), then passed
+     * to fallback. Kept deliberately narrow (exact status + message) so genuine
      * auth errors (401 invalid key) and request errors (400 validation) are never
      * mistaken for routing failures and pass straight through.
      */
@@ -32,8 +46,77 @@ export declare class OpencodeHeadersTransformer implements Transformer {
     private retryAfterHeaders;
     private ensurePromptCacheKey;
     private ensurePromptCacheRetention;
+    /**
+     * Free-tier gate scope: `-free` models on a zen (opencode.ai) endpoint.
+     * Paid Zen models and non-Zen providers sharing this transformer skip the
+     * stub/stream handling below entirely.
+     */
+    private static isFreeTierZenRequest;
+    /**
+     * The free-tier gate answers `stream: false` with 403 FreeTierError even
+     * when everything else is exact (curl A/B 2026-09-24). Force SSE on the
+     * wire; the normal response path does not de-stream SSE for JSON clients,
+     * so transformRequestIn records the forced shape and transformResponseOut
+     * restores JSON via collectForcedStream.
+     */
+    private ensureStreamedForFreeTier;
+    /**
+     * Free-tier thinking arrives almost entirely as opaque `encrypted_content`;
+     * the only readable part is the reasoning summary, and Zen emits ~nothing
+     * unless `reasoning.summary` is asked for (curl A/B 2026-09-24, same prompt:
+     * `"detailed"` → 68 summary chars, `"auto"` → 0). Stamp `detailed` when the
+     * client already reasons but states no summary preference. An explicit
+     * client value (including `"none"`) always wins; absent/disabled reasoning
+     * is left alone so non-reasoning calls never gain a reasoning block.
+     */
+    private ensureDetailedSummaryForFreeTier;
+    /**
+     * Zen aborts free-tier Responses runs (`response.incomplete`, no further
+     * events — a client-side stall) unless `prompt_cache_key` equals the
+     * `x-opencode-session` header (curl A/B 2026-09-24). CCR's generic cache
+     * key (`ccr_<sha256>`, stable per conversation but foreign to Zen) must be
+     * replaced after `ensurePromptCacheKey` runs. Scoped to free-tier Zen on the
+     * Responses wire; chat bodies and paid models keep existing behavior.
+     * Runs per attempt so header and key stay in lockstep.
+     */
+    private applyFreeTierCacheKey;
+    /**
+     * Inject the exact-name `read`/`shell` function stubs the free-tier gate
+     * requires (curl A/B 2026-09-24: lowercase exact match; `Read`/`Bash`
+     * fail, schemas are free-form, extras harmless). Client tools are never
+     * modified or reordered; stubs are appended. Each stub clones its client
+     * counterpart's description/parameters when present so a
+     * stub call maps back onto a schema the client already accepts; otherwise
+     * it carries a minimal empty-object schema. Returns the alias map
+     * (stub -> client name, or null without counterpart) for the response
+     * stage; no aliases when nothing was injected.
+     */
+    private ensureGateStubTools;
+    private static readonly GATE_STUB_COUNTERPARTS;
+    private static outgoingToolShape;
+    private static toolName;
+    private static toolDef;
+    private static buildStubTool;
+    private static gateAliasesFrom;
+    /**
+     * Map gate-stub calls back to the advertised client tool inside SSE events.
+     * Only `name` fields on
+     * Responses `function_call` objects and chat `tool_calls[].function` objects
+     * are touched; text payloads and unrelated events pass through byte-identical.
+     * Stubs without a client counterpart are left alone (the client errors on
+     * them exactly as it would on any unknown tool).
+     */
+    private rewriteGateStubCalls;
+    private static renameGateStubCalls;
     private fingerprintConversation;
-    private getOrCreateSessionId;
     private invalidateSession;
+    /**
+     * Conversation identity for the Zen session binding: an explicit client
+     * session id wherever the client supplies one (router-parsed, protocol
+     * context, or the shared header/body extractor used for cache keys), and
+     * the content fingerprint only for fully anonymous clients.
+     */
+    private resolveConversationId;
+    private getOrCreateSessionId;
     private generateId;
 }

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

@@ -37,6 +37,18 @@ export declare function inspectAnthropicClientFingerprint(headers: Record<string
  */
 export declare function getAnthropicProviderMode(provider: any, endpointTransformerName?: string): AnthropicProviderMode;
 export declare function isNativeAnthropicClient(kind: AnthropicClientKind): boolean;
+/** `CLAUDE_AUTH_NATIVE_CACHE_TTL` values: `1h` (default) or `client`. */
+export type NativeClaudeOAuthCacheTtlMode = "1h" | "client";
+export declare function resolveNativeClaudeOAuthCacheTtlMode(value: unknown): NativeClaudeOAuthCacheTtlMode;
+/**
+ * Native Desktop/CLI on claude-auth OAuth: extend the client's default-TTL
+ * (5m) ephemeral breakpoints to 1h, the TTL the third-party profile already
+ * uses on this route. Breakpoint placement is untouched. A body that already
+ * sets a TTL on any breakpoint is left exactly as sent (an explicit client
+ * choice), as is every body when the mode is `client`. Returns whether the
+ * body changed.
+ */
+export declare function applyNativeClaudeOAuthCacheTtl(body: any, context: AnthropicClientPolicyContext | undefined, mode?: NativeClaudeOAuthCacheTtlMode): boolean;
 /**
  * Apply the one and only system transformation allowed by the gateway policy.
  * This runs after routing has identified an in-scope Anthropic destination and

package/dist/utils/cache-prefix-debug.d.ts

@@ -5,10 +5,14 @@
  * transformer chain without a bisect.
  */
 export type CachePrefixStage = "client" | "wire";
+/**
+ * Routing headers that pin prompt-cache affinity. `x-client-request-id` is
+ * deliberately absent: claude-auth mints a fresh one per request (as Claude
+ * Code does), and Codex sets it equal to `thread-id`, which is tracked here.
+ */
 export type CacheAffinityHeaders = {
     sessionId?: string;
     threadId?: string;
-    clientRequestId?: string;
 };
 export type CachePrefixSegment = {
     path: string;

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

@@ -9,7 +9,7 @@ export declare function extractFirstUserMessageText(messages: UnifiedMessage[] |
 export declare function computeVersionSuffix(text: string, version: string): string;
 /**
  * Current first-party Anthropic requests use the literal cch marker. Older
- * captures showed a random session value; the current 2.1.226 decompilation
+ * captures showed a random session value; the current 2.1.280 decompilation
  * gates this field to first-party/Vertex and emits `00000`.
  */
 export declare function sessionCch(): string;
@@ -25,6 +25,15 @@ export declare function buildClaudeBillingHeaderValue(messages: UnifiedMessage[]
 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;
+/**
+ * Drop any existing billing entry (dedupe) and reserve system[0] for a fresh
+ * one, so applyClaudeSystemIdentity places identity right after it. The value
+ * samples the first user text as sent, which relocation may still change, so
+ * fill it afterwards with fillClaudeBillingSystemBlock.
+ */
+export declare function reserveClaudeBillingSystemBlock(system: TextContent[]): TextContent;
+/** Fill a reserved billing block; remove it when attribution is disabled. */
+export declare function fillClaudeBillingSystemBlock(system: TextContent[], block: TextContent, messages: UnifiedMessage[] | undefined): void;
 /**
  * Insert SYSTEM_IDENTITY after the billing block (normally system[1], or
  * system[0] when attribution is disabled). Any remaining caller system
@@ -45,8 +54,13 @@ export declare function applyClaudeSystemIdentity(system: TextContent[]): void;
  * 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.
+ *
+ * Returns the inserted block unless the first user message has non-empty
+ * string content (the relocated text is then a standalone block a cache
+ * breakpoint can end on); non-empty string content is prefixed in place and
+ * returns undefined.
  */
-export declare function relocateForeignSystemContent(system: TextContent[], messages: UnifiedMessage[] | undefined): void;
+export declare function relocateForeignSystemContent(system: TextContent[], messages: UnifiedMessage[] | undefined): TextContent | undefined;
 /**
  * Claude Code's OAuth validator expects tool names in the mcp_PascalCase
  * spelling used by the official CLI. Non-Claude-Code clients commonly send

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

@@ -1,6 +1,6 @@
 /**
  * Claude Code's bundled model capability catalog, revalidated against the
- * installed v2.1.226 CLI decompilation.
+ * installed v2.1.280 CLI decompilation.
  *
  * Every model-dependent decision in the claude-auth impersonation path (beta
  * flags, effort support, thinking shape, max_tokens ceiling) is driven by
@@ -21,6 +21,21 @@ export interface ClaudeModelCatalogEntry {
     };
     defaultEffort?: string;
     capabilities: string[];
+    /**
+     * CCR-owned Messages API request constraints. Not part of Claude Code's
+     * catalog (Claude Code simply never sends these shapes); sourced from
+     * Anthropic's per-model API documentation. Each flag names a request shape
+     * the model rejects with HTTP 400, so third-party emulation must normalize
+     * it away before sending.
+     */
+    apiConstraints?: {
+        /** `thinking: {type: "disabled"}` is rejected; thinking is always on. */
+        thinkingAlwaysOn?: boolean;
+        /** Forced `tool_choice` (`any` / `tool`) is rejected. */
+        noForcedToolChoice?: boolean;
+        /** `temperature` / `top_p` / `top_k` are rejected. */
+        noSamplingParams?: boolean;
+    };
 }
 export declare const CLAUDE_MODEL_CATALOG: Record<string, ClaudeModelCatalogEntry>;
 /** Strip the "[1m]" wire marker, reporting whether it was present. */

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

@@ -37,8 +37,13 @@ export declare function toAnthropicReasoningEffort(effortValue: unknown): Exclud
  * `codex,gpt-6-astra`). Anchored so `gpt-60` / `gpt-5.6` do not match.
  */
 export declare function isGpt6FamilyModel(model: unknown): boolean;
-/** Astra rejects `none` / `minimal`; OpenAI's migration floor is `low`. */
+/** 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`).

package/dist/utils/tool-content.d.ts

@@ -39,6 +39,12 @@ export declare function unifiedToolTextOnly(content: unknown): string;
 export declare function unifiedToolHasMedia(content: unknown): boolean;
 /** Anthropic tool_result.content: string or (text|image|document)[]. */
 export declare function unifiedToolContentToAnthropic(content: unknown): string | any[];
+/**
+ * Anthropic blocks for one Unified user content part. Empty when the part is
+ * not sent (empty text, image without URL, file without data or URL, unknown
+ * type), so callers placing cache breakpoints can skip it.
+ */
+export declare function unifiedUserPartToAnthropic(part: any): any[];
 /**
  * Anthropic inbound tool_result.content → Unified tool content
  * (string or text/image_url/file parts).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@caeliq/llms",
-  "version": "1.0.69",
+  "version": "1.0.71",
   "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.11",
-    "@cursor/sdk": "^1.0.30",
+    "@caeliq/ccr-shared": "^2.1.13",
+    "@cursor/sdk": "^1.0.32",
     "@fastify/cors": "^11.3.0",
     "@fastify/rate-limit": "^11.2.0",
     "@google/genai": "^2.18.0",