@caeliq/llms 1.0.64 → 1.0.66

package/dist/routing/inbound-pipeline.d.ts

@@ -11,8 +11,12 @@ export interface PreparedInboundRequest {
     clientWireBody: any;
     /** Normalized Unified body used for routing and provider conversion. */
     unifiedBody: UnifiedChatRequest;
-    /** Unified projection before destination-specific Anthropic emulation. */
-    prePolicyUnifiedBody: UnifiedChatRequest;
+    /**
+     * Unified projection before destination-specific Anthropic emulation.
+     * Only cloned when global fallback is configured; otherwise undefined so
+     * fallback can fall back to `unifiedBody`.
+     */
+    prePolicyUnifiedBody?: UnifiedChatRequest;
     providerName: string;
     modelName: string;
 }

package/dist/routing/protocol-adapter.d.ts

@@ -21,6 +21,8 @@ export declare function normalizeClientToUnified(protocol: ClientProtocolContext
 /**
  * Provider transformers are allowed to mutate their input. Every primary and
  * fallback attempt therefore needs an independent copy of the normalized body.
+ * Prefers structuredClone when available; falls back to JSON round-trip for
+ * environments without it.
  */
 export declare function cloneProtocolBody<T>(value: T): T;
 /**

package/dist/server.d.ts

@@ -45,6 +45,8 @@ declare class Server {
 }
 export default Server;
 export { sessionUsageCache };
+export { closeProxyDispatchers } from "./utils/request";
+export { closeTokenCountWorkers } from "./utils/token-count-worker";
 export { router };
 export { calculateTokenCount };
 export { searchProjectBySession };
@@ -57,6 +59,8 @@ export { pluginManager, tokenSpeedPlugin, getTokenSpeedStats, getGlobalTokenSpee
 export { SSEParserTransform, SSESerializerTransform, rewriteStream } from "./utils/sse";
 export { isClientAbortError } from "./utils/retry";
 export { sanitizeHeadersForLog, diffHeadersForLog, sanitizeBodyForLog, DEFAULT_LOG_BODY_MAX_BYTES, } from "./utils/redact";
+export { logMessageBody, bodyToLogString, shouldLogRequestBodies, shouldLogSSEEvents, resolveLogBodyMaxBytes, isTruthyConfigFlag, type MessageDebugDirection, } from "./utils/message-debug";
+export { tapUpstreamSSEDebug, tapClientSSEDebug, } from "./utils/sse-debug-tap";
 export { exchangeAuthorizationCode, fetchUserEmail, resolveProjectId, saveTokens, loadTokens, getValidAccessToken, getValidAccessToken as getAntigravityAccessToken, ANTIGRAVITY_CLIENT_ID, ANTIGRAVITY_CLIENT_SECRET, ANTIGRAVITY_REDIRECT_URI, ANTIGRAVITY_SCOPES, type AntigravityTokens, } from "./utils/antigravity-auth";
 export { getValidAccessToken as getClaudeAccessToken } from "./utils/claude-auth";
 export { getValidAccessToken as getCodexAccessToken, } from "./utils/codex-auth";

package/dist/tests/codex-system-instructions.d.ts

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

package/dist/tests/latency-cadence.d.ts

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

package/dist/tests/message-debug.d.ts

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

package/dist/tests/openrouter-headers.d.ts

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

package/dist/tests/proxy-dispatcher-cache.d.ts

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

package/dist/tests/reasoning.auto-summary.d.ts

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

package/dist/tests/sse-event-native.d.ts

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

package/dist/tests/transformer-plan.d.ts

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

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

@@ -1,6 +1,8 @@
 import { Transformer } from "../types/transformer";
 export declare class AntigravityAuthTransformer implements Transformer {
     name: string;
+    ownsTransport: boolean;
+    requestPhase: "transport";
     logger?: any;
     private buildAuthAndEnvelope;
     private buildHeaders;

package/dist/transformer/codex.transformer.d.ts

@@ -38,20 +38,10 @@ export declare class CodexTransformer implements Transformer {
      */
     private jsonToSseStream;
     /**
-     * Peek at the first non-whitespace character of a cloned response body to
-     * distinguish a real SSE stream (starts with `data:` or `event:`, first
-     * char `d` or `e`) from a flat JSON body (first char `{` or `[`) that the
-     * codex API sometimes returns even with text/event-stream Content-Type.
-     *
-     * - **For flat JSON** (`{` / `[`): reads the full clone body and returns
-     *   `{ firstChar, text }` so the caller can parse and handle it.
-     * - **For SSE** (anything else): returns `null` immediately after reading
-     *   only the first chunk from the clone. The original `response.body` on
-     *   the other side of the tee is untouched and can still be streamed live
-     *   by the SSE reader — avoiding buffering the entire response.
-     *
-     * Callers must pass `response.clone().body!` so the original body is not
-     * consumed by the peek.
+     * Peek the first chunk of the response body to distinguish flat JSON from
+     * SSE without Response.clone(). JSON drains the body into text; SSE returns
+     * a new Response whose stream replays the peeked chunk then continues from
+     * the same reader.
      */
     private readBodyAndPeek;
     private collectSseIntoChatCompletion;

package/dist/transformer/cursor-sdk.transformer.d.ts

@@ -17,6 +17,8 @@ export declare function buildCursorSdkRunnerOptions(options: CursorSdkTransforme
 export declare class CursorSdkTransformer implements Transformer {
     static TransformerName: string;
     name: string;
+    ownsTransport: boolean;
+    requestPhase: "transport";
     logger?: any;
     private options;
     constructor(options?: CursorSdkTransformerOptions);

package/dist/transformer/openai.transformer.d.ts

@@ -35,6 +35,8 @@ export declare class OpenAITransformer implements Transformer {
     transformRequestOut(request: any, _context?: TransformerContext): Promise<UnifiedChatRequest>;
     /**
      * Provider-side: apply OpenAI-native cache policy to a Unified Chat body.
+     * Avoid cloning the entire Unified body (~800KB at longContext) when no
+     * mutation will occur – native opencode mutates in place.
      */
     transformRequestIn(request: UnifiedChatRequest, provider: any, context: any): Promise<UnifiedChatRequest>;
     /**

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

@@ -1,6 +1,8 @@
 import { Transformer } from "../types/transformer";
 export declare class OpencodeHeadersTransformer implements Transformer {
     name: string;
+    ownsTransport: boolean;
+    requestPhase: "transport";
     private sessionCache;
     private readonly MAX_SESSIONS;
     private lastTimestamp;
@@ -18,6 +20,7 @@ export declare class OpencodeHeadersTransformer implements Transformer {
     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
@@ -29,6 +32,7 @@ export declare class OpencodeHeadersTransformer implements Transformer {
     private retryDelayMs;
     private exponentialRetryDelayMs;
     private retryAfterHeaders;
+    private ensurePromptCacheKey;
     private fingerprintConversation;
     private getOrCreateSessionId;
     private invalidateSession;

package/dist/transformer/openrouter.transformer.d.ts

@@ -1,10 +1,24 @@
 import { UnifiedChatRequest } from "../types/llm";
 import { Transformer, TransformerOptions } from "../types/transformer";
+import { HeaderRecord } from "../utils/headers";
+/**
+ * OpenRouter app attribution headers. Some routed upstreams also require a
+ * Claude Code–shaped User-Agent; attribution alone is not enough for those.
+ * @see https://openrouter.ai/docs/app-attribution
+ */
+export declare function buildOpenRouterAttributionHeaders(options?: TransformerOptions): HeaderRecord;
+/**
+ * Claude Code CLI identity headers. Prefer the caller's genuine CLI headers;
+ * otherwise synthesize the same profile claude-auth uses for non-CLI clients.
+ * Several OpenRouter upstreams reject requests without a claude-cli User-Agent.
+ */
+export declare function buildOpenRouterClaudeIdentityHeaders(clientHeaders?: Record<string, unknown>, options?: TransformerOptions): HeaderRecord;
+export declare function buildOpenRouterOutboundHeaders(clientHeaders?: Record<string, unknown>, options?: TransformerOptions): HeaderRecord;
 export declare class OpenrouterTransformer implements Transformer {
     private readonly options?;
     static TransformerName: string;
     logger?: any;
     constructor(options?: TransformerOptions | undefined);
-    transformRequestIn(request: UnifiedChatRequest, provider?: any, context?: any): Promise<UnifiedChatRequest>;
+    transformRequestIn(request: UnifiedChatRequest, provider?: any, context?: any): Promise<Record<string, any>>;
     transformResponseOut(response: Response): Promise<Response>;
 }

package/dist/transformer/reasoning.transformer.d.ts

@@ -3,6 +3,7 @@ import { Transformer, TransformerOptions } from "../types/transformer";
 export declare class ReasoningTransformer implements Transformer {
     private readonly options?;
     static TransformerName: string;
+    name: string;
     enable: any;
     constructor(options?: TransformerOptions | undefined);
     transformRequestIn(request: UnifiedChatRequest, provider?: any, context?: any): Promise<UnifiedChatRequest>;

package/dist/types/llm.d.ts

@@ -115,6 +115,11 @@ export interface UnifiedChatRequest {
     };
     reasoning?: {
         effort?: ThinkLevel;
+        /**
+         * Request readable reasoning text from destinations that gate it
+         * (Responses `reasoning.summary`, Codex, etc.). `"none"` opts out.
+         */
+        summary?: "auto" | "detailed" | "concise" | "none";
         max_tokens?: number;
         enabled?: boolean;
     };
@@ -133,6 +138,17 @@ export interface UnifiedChatRequest {
     anthropic_metadata?: Record<string, any>;
     anthropic_stop_sequences?: string[];
     reasoning_effort?: string;
+    /**
+     * Responses opaque `include` list (e.g. `reasoning.encrypted_content`).
+     * Client-driven: only set when the inbound protocol was Responses and the
+     * client sent it. Chat/Anthropic clients have no equivalent field.
+     */
+    include?: string[];
+    /**
+     * Responses `store`. Only `false` is preserved (CCR rejects `store: true`).
+     * Client-driven same-protocol hint, paired with `include` by OpenCode/AI SDK.
+     */
+    store?: false;
 }
 export interface UnifiedChatResponse {
     id: string;

package/dist/types/transformer.d.ts

@@ -25,6 +25,8 @@ export interface TransformerContext {
     claudeAuthPostBuildHook?: (anthropicBody: Record<string, any>) => void;
     [key: string]: any;
 }
+/** Where a request transformer runs in the compiled provider/model plan. */
+export type TransformerRequestPhase = "body" | "headers" | "transport";
 export type Transformer = {
     transformRequestIn?: (request: UnifiedChatRequest, provider: LLMProvider, context: TransformerContext) => Promise<Record<string, any>>;
     transformResponseIn?: (response: Response, context?: TransformerContext) => Promise<Response>;
@@ -32,6 +34,14 @@ export type Transformer = {
     transformResponseOut?: (response: Response, context: TransformerContext) => Promise<Response>;
     endPoint?: string;
     name?: string;
+    /**
+     * When true, this transformer performs the upstream call (fetch, SDK, etc.)
+     * and returns the Response via config.__providerResponse. The request plan
+     * runs at most one such transformer, after every body/header transform.
+     */
+    ownsTransport?: boolean;
+    /** Optional phase hint; ownsTransport implies "transport". */
+    requestPhase?: TransformerRequestPhase;
     auth?: (request: any, provider: LLMProvider, context: TransformerContext) => Promise<any>;
     logger?: any;
 };

package/dist/utils/message-debug.d.ts

@@ -0,0 +1,35 @@
+/** Wire direction for request/response body and SSE message debug logs. */
+export type MessageDebugDirection = "client→ccr" | "ccr→provider" | "provider→ccr" | "ccr→client";
+export declare function isTruthyConfigFlag(value: unknown): boolean;
+export declare function resolveLogBodyMaxBytes(configService: {
+    get?: (key: string) => unknown;
+} | null | undefined): number;
+export declare function shouldLogRequestBodies(configService: {
+    get?: (key: string) => unknown;
+} | null | undefined): boolean;
+export declare function shouldLogSSEEvents(configService: {
+    get?: (key: string) => unknown;
+} | null | undefined): boolean;
+/** Serialize a request/response body for sanitizeBodyForLog. */
+export declare function bodyToLogString(body: unknown): string;
+export type MessageBodyLogOptions = {
+    logger: {
+        debug?: (...args: any[]) => void;
+        info?: (...args: any[]) => void;
+    };
+    direction: MessageDebugDirection;
+    /** Prefer debug; info kept for the legacy Anthropic-only inbound path. */
+    level?: "debug" | "info";
+    reqId?: string | number;
+    protocol?: string;
+    provider?: string;
+    model?: string;
+    maxBytes?: number;
+    /** Override the historical `type` field when needed. */
+    type?: string;
+};
+/**
+ * Opt-in full message-body capture with a stable direction tag so operators
+ * can grep client↔CCR and CCR↔provider legs independently.
+ */
+export declare function logMessageBody(body: unknown, opts: MessageBodyLogOptions): void;

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

@@ -12,6 +12,8 @@ export declare function mapCallId(map: ResponsesCallIdMap, id: unknown, directio
  * Supports the Responses MVP subset; rejects CCR-unsupported stateful fields.
  */
 export declare function responsesRequestToUnified(body: any, callIdMap?: ResponsesCallIdMap, customToolNames?: Set<string>): 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;
 /**
  * Ciphertext Codex/OpenAI will verify. Item ids and Anthropic/Gemini
@@ -82,6 +84,11 @@ export declare function responsesReasoningItemFromThinking(thinking: {
     encrypted_content?: string;
     id?: string;
 } | undefined, id?: string): any | null;
+/**
+ * Zen rejects Requests whose `input` repeats the same reasoning item id.
+ * Rewrite placeholders / collisions using ciphertext (or summary) as seed.
+ */
+export declare function uniquifyReasoningItemIds(items: any[] | undefined): void;
 /** Synthetic argument key used to carry a `custom` tool's freeform text
  * through the Unified/Chat Completions function-call shape. */
 export declare const CUSTOM_TOOL_INPUT_KEY = "input";
@@ -192,6 +199,9 @@ export interface ResponsesStreamState {
     thinkingContent: string;
     thinkingEncryptedContent?: string;
     thinkingId?: string;
+    thinkingStarted: boolean;
+    thinkingClosed: boolean;
+    thinkingOutputIndex?: number;
     codexIsolateConventions: boolean;
 }
 export declare function createResponsesStreamState(options?: {

package/dist/utils/paced-sse.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Hermetic paced SSE upstream for latency / cadence benchmarks.
+ * Emits fixed-cadence Chat Completions SSE events with configurable delays.
+ */
+export type PacedSSEOptions = {
+    /** Delay before response headers resolve (ms). */
+    headerDelayMs?: number;
+    /** Delay before first SSE body byte after headers (ms). */
+    firstByteDelayMs?: number;
+    /** Gap between successive events (ms). */
+    eventIntervalMs?: number;
+    /** Number of content delta events. */
+    eventCount?: number;
+    /** Split each event across this many TCP-ish chunks (default 1). */
+    fragmentChunks?: number;
+    /** Abort tracking. */
+    signal?: AbortSignal;
+    /** Optional terminal Zen-style network_error finish_reason. */
+    terminalNetworkError?: boolean;
+    /** Fail with this HTTP status instead of streaming. */
+    httpErrorStatus?: number;
+    httpErrorBody?: string;
+};
+export type PacedSSEEventStamp = {
+    index: number;
+    enqueuedAt: number;
+};
+/**
+ * Build a Response whose body emits Chat Completions SSE at a fixed cadence.
+ * `stamps` is filled as each logical event is enqueued (before fragmentation).
+ */
+export declare function createPacedSSEResponse(options?: PacedSSEOptions, stamps?: PacedSSEEventStamp[]): Promise<Response>;
+/** Read a stream and record when each complete SSE event (blank-line delimited) arrives. */
+export declare function collectSSEEventTimings(body: ReadableStream<Uint8Array>, t0?: number): Promise<{
+    events: string[];
+    arrivalsMs: number[];
+}>;
+export declare function interArrivalGaps(arrivalsMs: number[]): number[];

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

@@ -1,7 +1,29 @@
 import type { ThinkLevel, UnifiedChatRequest } from "../types/llm";
 type UnifiedReasoning = UnifiedChatRequest["reasoning"];
+/** Readable-reasoning request levels shared across Responses / Codex / config. */
+export type ReasoningSummaryLevel = "auto" | "detailed" | "concise";
 /** Normalize effort tokens at the protocol boundary without rejecting extensions. */
 export declare function normalizeReasoningEffort(value: unknown): ThinkLevel | undefined;
+/**
+ * Parse `REASONING_AUTO_SUMMARY` / provider `reasoningSummary`.
+ * `true` → `"detailed"` (LiteLLM-compatible). `"none"` / false / unset → off.
+ */
+export declare function resolveReasoningAutoSummary(value: unknown): ReasoningSummaryLevel | undefined;
+/** True when reasoning is on (effort present and not none, or enabled:true). */
+export declare function isReasoningActive(reasoning: UnifiedReasoning | undefined, thinking?: UnifiedChatRequest["thinking"]): boolean;
+/**
+ * Opt-in: when config asks for auto-summary and the client enabled reasoning
+ * without an explicit `reasoning.summary`, stamp the Unified field so every
+ * destination protocol can request readable thinking the same way.
+ */
+export declare function applyReasoningAutoSummary(request: UnifiedChatRequest, configValue: unknown): UnifiedChatRequest;
+/**
+ * Outbound precedence: Unified `reasoning.summary` → provider.reasoningSummary.
+ * `"none"` means do not request a readable summary.
+ */
+export declare function resolveOutboundReasoningSummary(request: Pick<UnifiedChatRequest, "reasoning" | "thinking">, provider?: {
+    reasoningSummary?: unknown;
+} | null): ReasoningSummaryLevel | undefined;
 /** `none` and an explicit enabled:false are the canonical off signals. */
 export declare function isReasoningDisabled(reasoning: UnifiedReasoning | undefined, thinking?: UnifiedChatRequest["thinking"]): boolean;
 /** Build the canonical reasoning state used by every inbound protocol. */

package/dist/utils/request-latency.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Request-stage latency timings. Allocation-light monotonic stamps; one
+ * terminal structured record per request. No per-event logging, no tee.
+ */
+export type LatencyStage = "received" | "bodyParsed" | "normalized" | "projectLookup" | "tokenizeStart" | "tokenizeEnd" | "routeSelected" | "destinationPolicy" | "requestTransformers" | "upstreamFetchStart" | "upstreamHeaders" | "upstreamFirstByte" | "responseTransformers" | "downstreamFirstByte" | "complete";
+export type RequestLatency = {
+    t0: number;
+    stages: Partial<Record<LatencyStage, number>>;
+    meta: {
+        protocol?: string;
+        provider?: string;
+        model?: string;
+        scenario?: string;
+        bypass?: boolean;
+        tokenCount?: number;
+        inputBytes?: number;
+        upstreamAttempts?: number;
+        cancelled?: boolean;
+        error?: string;
+    };
+    emitted?: boolean;
+};
+export declare function createRequestLatency(): RequestLatency;
+export declare function markLatency(latency: RequestLatency | undefined | null, stage: LatencyStage): void;
+export declare function tapResponseFirstByte(response: Response, onFirstByte: () => void): Response;
+export declare function attachLatencyMeta(latency: RequestLatency | undefined | null, meta: Partial<RequestLatency["meta"]>): void;
+/** Emit one structured terminal latency record. Safe to call multiple times. */
+export declare function emitLatencyRecord(logger: {
+    info?: (obj: unknown, msg?: string) => void;
+} | undefined | null, latency: RequestLatency | undefined | null): void;
+export declare function ensureRequestLatency(req: {
+    _latency?: RequestLatency;
+}): RequestLatency;

package/dist/utils/request.d.ts

@@ -1,4 +1,11 @@
+import { ProxyAgent } from "undici";
 import { UnifiedChatRequest } from "../types/llm";
+/** One Undici ProxyAgent per normalized proxy URL so connections can be reused. */
+export declare function getProxyDispatcher(httpsProxy: string): ProxyAgent;
+/** Close every cached ProxyAgent (call on server shutdown). */
+export declare function closeProxyDispatchers(): void;
+/** Test-only: inspect the module-level dispatcher cache. */
+export declare function __getProxyDispatcherCacheForTests(): Map<string, ProxyAgent>;
 /** 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/sse/incremental-parser.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Incremental SSE event parser that preserves each event's raw bytes/text so
+ * unchanged events can be forwarded without re-serialization.
+ */
+export type ParsedSSEEvent = {
+    event?: string;
+    id?: string;
+    retry?: number;
+    /** Parsed JSON, `{ type: "done" }` for [DONE], or `{ raw, error }`. */
+    data?: unknown;
+    /** Original data field string (without the `data:` prefix), if any. */
+    dataRaw?: string;
+    /**
+     * Exact event block as received, including the blank-line delimiter.
+     * Forward this unchanged for byte-preserving passthrough.
+     */
+    raw: string;
+};
+/**
+ * Feed decoded SSE text and emit complete events. Tolerates `\n` and `\r\n`.
+ */
+export declare class IncrementalSSEParser {
+    private buffer;
+    push(chunk: string): ParsedSSEEvent[];
+    flush(): ParsedSSEEvent[];
+    private takeComplete;
+}
+/** Serialize a (possibly modified) event. Prefer `event.raw` when unchanged. */
+export declare function serializeSSEEvent(event: {
+    event?: string;
+    id?: string;
+    retry?: number;
+    data?: unknown;
+    dataRaw?: string;
+}): string;

package/dist/utils/sse-debug-tap.d.ts

@@ -1,4 +1,5 @@
 import { type CacheAffinityHeaders, type CachePrefixDiff, type CachePrefixStage } from "./cache-prefix-debug";
+import type { MessageDebugDirection } from "./message-debug";
 export type UpstreamSSEDebugOptions = {
     logger?: any;
     reqId?: string | number;
@@ -19,6 +20,31 @@ export type UpstreamSSEDebugOptions = {
     cacheDiff?: CachePrefixDiff | null;
     /** Cap for a single logged payload string (raw `data` field). */
     maxBytes?: number;
+    /**
+     * Opt-in raw per-event SSE logging. Independent of LOG_LEVEL=debug.
+     * When false (default), the debug tap still computes terminal cache outcome
+     * summaries but does not log every delta.
+     */
+    rawEvents?: boolean;
+    /**
+     * Which wire leg produced these bytes. Defaults to `provider→ccr` for the
+     * upstream tap and `ccr→client` for the client tap.
+     */
+    direction?: MessageDebugDirection;
+    /**
+     * When true, only emit raw SSE/JSON event logs (no cache outcome summary).
+     * Used for the client-bound leg where cache usage was already observed upstream.
+     */
+    eventsOnly?: boolean;
+};
+export type ClientSSEDebugOptions = {
+    logger?: any;
+    reqId?: string | number;
+    provider?: string;
+    model?: string;
+    protocol?: string;
+    maxBytes?: number;
+    rawEvents?: boolean;
 };
 /**
  * Byte-preserving upstream response debug tap.
@@ -42,6 +68,12 @@ export type UpstreamSSEDebugOptions = {
  * the single shared place that covers every outbound provider.
  */
 export declare function tapUpstreamSSEDebug(response: Response, opts: UpstreamSSEDebugOptions): Promise<Response>;
+/**
+ * Byte-preserving tap for the SSE body CCR sends back to the client after
+ * response transformers. Same non-blocking tunnel as the upstream tap; events
+ * are tagged `direction: "ccr→client"` so greps can split the two legs.
+ */
+export declare function tapClientSSEDebug(body: ReadableStream<Uint8Array>, opts: ClientSSEDebugOptions): ReadableStream<Uint8Array>;
 export type CacheStructureSummary = {
     systemBreakpoints: number;
     messageBreakpoints: number;

package/dist/utils/stream.d.ts

@@ -1,13 +1,36 @@
+import { type ParsedSSEEvent } from "./sse/incremental-parser";
 export interface StreamContext {
     controller: ReadableStreamDefaultController;
     encoder: TextEncoder;
 }
-export declare function createSSEStreamReader(response: Response, processLine: (line: string, context: StreamContext) => void, options?: {
+export type SSEEvent = ParsedSSEEvent;
+export type ProcessSSEEvent = (event: SSEEvent, context: StreamContext) => void;
+export type ProcessSSELine = (line: string, context: StreamContext) => void;
+/** Forward an event using its original raw bytes/string. */
+export declare function forwardSSEEvent(event: SSEEvent, context: StreamContext): void;
+/** Serialize and enqueue a modified event (only when data changed). */
+export declare function emitSSEEvent(event: {
+    event?: string;
+    id?: string;
+    retry?: number;
+    data?: unknown;
+    dataRaw?: string;
+}, context: StreamContext): void;
+type StreamReaderOptions = {
     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;
+    processEvent?: ProcessSSEEvent;
+};
+/**
+ * Create a transformed SSE Response.
+ *
+ * Prefer `options.processEvent` for event-native handling (parse once, forward
+ * raw when unchanged). The legacy `processLine` callback is still supported via
+ * a shim that feeds reconstructed data lines.
+ */
+export declare function createSSEStreamReader(response: Response, processLineOrOptions?: ProcessSSELine | StreamReaderOptions, maybeOptions?: StreamReaderOptions): Response;
 export declare function encodeSSEData(data: string, encoder: TextEncoder): Uint8Array;
 export declare function encodeSSELine(line: string, encoder: TextEncoder): Uint8Array;
+export { serializeSSEEvent } from "./sse/incremental-parser";

package/dist/utils/token-count-worker.d.ts

@@ -0,0 +1,12 @@
+export type TokenCountWorkerRequest = {
+    messages: unknown;
+    system: unknown;
+    tools: unknown;
+};
+/** Offload when serialized payload exceeds this many characters. */
+export declare const TOKEN_COUNT_WORKER_THRESHOLD_CHARS = 200000;
+export declare function estimateTokenizePayloadChars(messages: unknown, system: unknown, tools: unknown): number;
+/** Conservative under-estimate: ~4 chars/token. Safe for "below threshold" skips. */
+export declare function estimateTokensFromChars(charCount: number): number;
+export declare function countTokensInWorker(request: TokenCountWorkerRequest): Promise<number>;
+export declare function closeTokenCountWorkers(): Promise<void>;

package/dist/utils/transformer-plan.d.ts

@@ -0,0 +1,21 @@
+import type { Transformer } from "../types/transformer";
+export type CompiledTransformerPlan = {
+    /** Body/header middleware, then at most one transport owner. */
+    request: Transformer[];
+    /** Reverse of `request` for onion-style response transforms. */
+    response: Transformer[];
+    transportOwner?: Transformer;
+};
+/**
+ * Compile provider-level + model-level transformer chains into one plan.
+ *
+ * - Deduplicates by transformer name (first occurrence wins).
+ * - Runs every non-transport transformer before the transport owner.
+ * - Rejects configurations that leave more than one distinct transport owner.
+ */
+export declare function compileTransformerPlan(providerUse: Transformer[] | undefined, modelUse: Transformer[] | undefined, options?: {
+    skipName?: string;
+}): CompiledTransformerPlan;
+export declare function isExactProtocolResponsePlan(plan: CompiledTransformerPlan, endpointTransformer: Transformer, clientProtocolOwnerName: string | undefined): boolean;
+/** Cancel a Response body when a newer transport result replaces it. */
+export declare function cancelReplacedProviderResponse(previous: Response | undefined | null, next: Response | undefined | null): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@caeliq/llms",
-  "version": "1.0.64",
+  "version": "1.0.66",
   "description": "A universal LLM API transformation server",
   "main": "dist/cjs/server.cjs",
   "module": "dist/esm/server.mjs",
@@ -29,28 +29,28 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.115.0",
-    "@caeliq/ccr-shared": "^2.1.6",
-    "@cursor/sdk": "^1.0.28",
+    "@anthropic-ai/sdk": "^0.120.0",
+    "@caeliq/ccr-shared": "^2.1.8",
+    "@cursor/sdk": "^1.0.30",
     "@fastify/cors": "^11.3.0",
     "@fastify/rate-limit": "^11.2.0",
-    "@google/genai": "^2.17.1",
+    "@google/genai": "^2.18.0",
     "@huggingface/tokenizers": "^0.1.3",
     "dotenv": "^17.4.2",
-    "fastify": "^5.12.0",
+    "fastify": "^5.12.1",
     "fastify-plugin": "^6.0.0",
     "google-auth-library": "^11.0.2",
     "json5": "^2.2.3",
     "jsonrepair": "^3.15.0",
     "latex-to-unicode": "^0.1.0",
     "lru-cache": "^11.5.2",
-    "openai": "^7.4.0",
+    "openai": "^7.5.0",
     "tiktoken": "^1.0.22",
     "undici": "^8.10.0",
-    "uuid": "^14.0.1"
+    "uuid": "^14.0.2"
   },
   "devDependencies": {
-    "@types/node": "^26.2.0",
+    "@types/node": "^26.4.0",
     "esbuild": "^0.28.2",
     "tsx": "^4.23.12",
     "typescript": "^6.0.3"