@caeliq/llms 1.0.65 → 1.0.67

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/routing/protocol-endpoints.d.ts

@@ -1,5 +1,6 @@
 import type { RouterScenarioType } from "../utils/router";
 import type { AnthropicClientKind, AnthropicProviderMode } from "../utils/anthropic-client-policy";
+import type { ResponsesCallIdMap } from "../utils/openai.responses.util";
 /**
  * Inbound client protocols supported by CCR's gateway lifecycle.
  */
@@ -35,11 +36,24 @@ export interface ClientProtocolContext {
     anthropicPolicyApplied?: boolean;
     anthropicSystemTransformed?: boolean;
     claudeAuthToolNameMap?: Map<string, string>;
+    /** Per-request Responses call/result correlation across both pipeline legs. */
+    responsesCallIdMap?: ResponsesCallIdMap;
+    responsesCustomToolNames?: Set<string>;
     /** Claude Code routing metadata extracted without mutating the source billing block. */
     claudeCodeSubagent?: boolean;
+    /**
+     * Nested/worker agent on any inbound protocol (Claude Code Task, OpenCode
+     * child session, Codex x-openai-subagent, Cursor fork boilerplate).
+     */
+    nestedAgent?: boolean;
     taggedSubagentModel?: string;
     /** Transformer that owns this client protocol */
     ownerTransformerName: string;
+    /**
+     * Client conversation id captured from the original wire (never harness
+     * version or system text). Used for prompt-cache affinity and Codex headers.
+     */
+    sessionId?: string;
 }
 export interface ProtocolRouteMatch {
     protocol: ClientProtocol;

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/anthropic.message-start-usage.test.d.ts

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

package/dist/tests/cache-outcome.d.ts

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

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

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

package/dist/tests/cross-protocol.matrix.d.ts

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

package/dist/tests/cursor-sdk.auth-exchange-cache.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/responses.encrypted-content-cache.d.ts

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

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

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

package/dist/tests/tool-content.multimodal.d.ts

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

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

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

package/dist/tests/wire-keep.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

@@ -1,61 +1,37 @@
-import { UnifiedChatRequest } from "../types/llm";
 import { Transformer } from "../types/transformer";
+/**
+ * ChatGPT/Codex backend auth + Responses-wire constraints.
+ *
+ * Body conversion is owned by `openai-responses`. Configure
+ * `transformer.use: ["openai-responses", "codex"]`. Same-protocol
+ * Responses clients keep `input[]` (including `reasoning.encrypted_content`);
+ * this transformer only stamps auth, Codex headers, `store: false`, and
+ * `stream: true`.
+ */
 export declare class CodexTransformer implements Transformer {
     name: string;
+    requestPhase: "headers";
     logger?: any;
     private streamIntent;
-    transformRequestIn(request: UnifiedChatRequest, provider: any, context?: any): Promise<Record<string, any>>;
+    transformRequestIn(request: any, provider: any, context?: any): Promise<Record<string, any>>;
     auth(request: any, provider: any): Promise<any>;
     private resolveAuth;
     private buildAuthHeaders;
     private recoverUnauthorizedAuth;
     private resolvePatAuth;
     private requestPatAuth;
+    /**
+     * Transport quirks only. Do not convert Responses → Chat — openai-responses
+     * owns that, and same-protocol keep must forward native `input[]` /
+     * `encrypted_content` events unchanged.
+     */
     transformResponseOut(response: Response, context?: {
         req?: {
             id?: string;
         };
     }): Promise<Response>;
-    private transformResponseOutInner;
-    private convertStreamEvent;
-    /**
-     * Consume a Codex SSE response fully and return a single OpenAI
-     * ChatCompletion JSON. Used for non-streaming Anthropic SDK calls
-     * (e.g. client.beta.messages.create with stream:false) where the
-     * SDK expects a flat BetaMessage. The SDK accumulates the response
-     * by reading a single JSON object, not by parsing SSE, so we
-     * have to materialize the response here.
-     */
-    /**
-     * Re-emit a single OpenAI ChatCompletion JSON as a one-shot SSE stream of
-     * `chat.completion.chunk` events, so a streaming caller (which expects SSE)
-     * still receives the content when codex returned a flat JSON instead of a
-     * stream. The downstream anthropic transformer's stream reader parses each
-     * `data:` line as a chunk, so we split the full message into proper delta
-     * chunks (text content first, then a final chunk with finish_reason + usage)
-     * — emitting the raw chat.completion would put the text under `message`
-     * instead of `delta` and the content would be dropped.
-     */
-    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.
-     */
-    private readBodyAndPeek;
-    private collectSseIntoChatCompletion;
-    private normalizeRequestContent;
-    private convertResponseToChat;
-    private buildImageContent;
+    private normalizeCodexTransport;
+    private ensureSseContentType;
+    private jsonToSseBytes;
+    private collectSseIntoResponses;
 }

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.responses.transformer.d.ts

@@ -16,7 +16,7 @@ export declare class OpenAIResponsesTransformer implements Transformer {
     transformResponseIn(response: Response, context?: TransformerContext): Promise<Response>;
     private convertUnifiedStreamToResponses;
     transformRequestIn(request: UnifiedChatRequest, provider?: any, context?: any): Promise<UnifiedChatRequest>;
-    transformResponseOut(response: Response): Promise<Response>;
+    transformResponseOut(response: Response, context?: TransformerContext): Promise<Response>;
     /**
      * Convert one Responses stream event to a Chat chunk. `choices[0].index` is
      * always 0 — parallel-call identity lives in `delta.tool_calls[n].index`,

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;
@@ -30,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

@@ -138,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/cache-outcome.d.ts

@@ -0,0 +1,79 @@
+import type { CachePrefixDiff } from "./cache-prefix-debug";
+/**
+ * Provider-family-specific cache contracts. OpenAI-style message prefix +
+ * prompt_cache_key is only one of several; Cursor uses conversation/lifecycle,
+ * Anthropic uses ephemeral breakpoints, Gemini uses cachedContent resources.
+ */
+export type CacheFamily = "openai_prefix" | "anthropic_ephemeral" | "gemini_cached_content" | "cursor_conversation" | "deepseek_prefix" | "unknown";
+export type CacheVerdict = "cold" | "warm-start" | "hit" | "partial" | "expected-miss" | "unexpected-miss" | "unknown";
+export type CachePrediction = {
+    family: CacheFamily;
+    firstTurn: boolean;
+    /** Provider-specific: was a hit expected this turn? */
+    predictedHit: boolean;
+    /** Why we predicted miss/hit (for logs). */
+    reason: string;
+    /** OpenAI-style prefix intactness when available (diagnostic for Cursor). */
+    prefixIntact?: boolean;
+    firstDivergencePath?: string;
+    approxPrefixTokensLost?: number;
+    conversationId?: string;
+    conversationIdSource?: string;
+    /** Cursor lifecycle action when family is cursor_conversation. */
+    lifecycleAction?: string;
+    hostPrefixIntact?: boolean;
+};
+export type CursorCacheLifecycle = {
+    sessionKey?: string;
+    action: string;
+    reason?: string;
+};
+export type ResolveCacheFamilyInput = {
+    provider?: string;
+    model?: string;
+    body?: Record<string, any> | null;
+    cursorLifecycle?: CursorCacheLifecycle | null;
+};
+/**
+ * Prefer explicit provider/transformer id; fall back to body sniffing.
+ */
+export declare function resolveCacheFamily(input: ResolveCacheFamilyInput): CacheFamily;
+/**
+ * Join what we predicted against what upstream reported.
+ * Labels intentionally match the historical sse-debug-tap strings.
+ */
+export declare function classifyCacheOutcome(prediction: CachePrediction | null | undefined, hitRatio: number | undefined): CacheVerdict;
+/** OpenAI Chat/Responses, Codex, Zen, Cerebras, OpenRouter, Mistral, xAI. */
+export declare function predictOpenAiPrefix(diff: CachePrefixDiff | null | undefined): CachePrediction;
+/** DeepSeek uses the same outbound prefix contract; hit tokens are separate. */
+export declare function predictDeepSeekPrefix(diff: CachePrefixDiff | null | undefined): CachePrediction;
+/**
+ * Anthropic caches only when ephemeral breakpoints exist and the covered
+ * prefix stayed intact. No breakpoints → predicted miss.
+ */
+export declare function predictAnthropicEphemeral(diff: CachePrefixDiff | null | undefined, body?: Record<string, any> | null): CachePrediction;
+export declare function __resetGeminiCachedContentNamesForTests(): void;
+export declare function predictGeminiCachedContent(opts: {
+    diff?: CachePrefixDiff | null;
+    body?: Record<string, any> | null;
+    conversationId?: string;
+}): CachePrediction;
+/**
+ * Cursor has no prompt_cache_key. Prediction follows lifecycle:
+ * resume/incremental → hit expected; retire/replay or fresh send → miss expected.
+ */
+export declare function predictCursorConversation(opts: {
+    lifecycle?: CursorCacheLifecycle | null;
+    diff?: CachePrefixDiff | null;
+}): CachePrediction;
+/**
+ * Build the right prediction for this outbound leg.
+ */
+export declare function buildCachePrediction(opts: {
+    provider?: string;
+    model?: string;
+    body?: Record<string, any> | null;
+    diff?: CachePrefixDiff | null;
+    cursorLifecycle?: CursorCacheLifecycle | null;
+    conversationId?: string;
+}): CachePrediction;

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

@@ -35,7 +35,9 @@ export type CachePrefixSnapshot = {
     segments: CachePrefixSegment[];
 };
 export type CachePrefixChange = "none" | "appended" | "modified" | "removed";
-export type CachePrefixIdSource = "session" | "cache_key" | "fingerprint";
+export type CachePrefixIdSource = "session" | "cache_key" | "fingerprint"
+/** Parent session id mixed with first substantive user text (Claude Code Task). */
+ | "subagent";
 export type CachePrefixDiff = {
     conversationId: string;
     conversationIdSource: CachePrefixIdSource;
@@ -91,6 +93,8 @@ export type CachePrefixDiffOptions = {
      * become the baseline the following turn is judged against.
      */
     commit?: boolean;
+    /** Override when `conversationId` is a derived subagent key rather than the raw session. */
+    conversationIdSource?: CachePrefixIdSource;
 };
 export declare function __resetCachePrefixSnapshotsForTests(): void;
 /**
@@ -102,6 +106,22 @@ export declare function diffCachePrefixSnapshots(conversationId: string, previou
     stage?: CachePrefixStage;
     conversationIdSource?: CachePrefixIdSource;
 }): CachePrefixDiff;
+/**
+ * Snapshot key for consecutive cache-prefix diffs.
+ *
+ * Claude Code Tasks share the parent `session_id`. Mixing first substantive
+ * user text keeps parent vs fork (and two forks) from overwriting one baseline
+ * and reporting 25k-token "modified" misses.
+ */
+export declare function resolveCachePrefixConversationId(opts: {
+    sessionId?: string;
+    isSubagent?: boolean;
+    nestedAgent?: boolean;
+    firstUserText?: string;
+}): {
+    id?: string;
+    source?: CachePrefixIdSource;
+};
 /**
  * Compare this outbound body to the last one for the conversation, then
  * remember the current snapshot. Returns null when there is nothing cacheable.

package/dist/utils/cacheControl.d.ts

@@ -28,6 +28,14 @@ export declare function stripMessagesCacheControl(messages: UnifiedMessage[]): U
  * but non-Anthropic providers reject it on tool definitions.
  */
 export declare function stripToolsCacheControl(tools: UnifiedTool[] | undefined): UnifiedTool[] | undefined;
+/**
+ * Conversation id from the client wire. Never uses harness version, billing
+ * markers, or system-prompt text.
+ */
+export declare function extractClientSessionId(input: {
+    body?: any;
+    headers?: unknown;
+}): string | undefined;
 export declare function deriveCacheSessionKey(context: any, request: UnifiedChatRequest): string | undefined;
 export declare function selectCacheBreakpoints(request: UnifiedChatRequest, options: {
     maxBreakpoints: number;

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

@@ -11,7 +11,7 @@ type AssistantResponseRecorder = {
 };
 export declare function assistantNeedsReasoningForToolContext(message: MessageLike, priorMessages: MessageLike[]): boolean;
 export declare function isDeepSeekThinkingRequest(request: Pick<UnifiedChatRequest, "model" | "thinking" | "enable_thinking" | "reasoning">, provider?: Pick<LLMProvider, "name" | "baseUrl">): boolean;
-export declare function buildReasoningCacheNamespace(request: Pick<UnifiedChatRequest, "model" | "thinking" | "enable_thinking" | "reasoning">, provider?: Pick<LLMProvider, "name" | "baseUrl">): string;
+export declare function buildReasoningCacheNamespace(request: Pick<UnifiedChatRequest, "model" | "thinking" | "enable_thinking" | "reasoning">, provider?: Pick<LLMProvider, "name" | "baseUrl">, context?: TransformerContext): string;
 export declare function prepareReasoningReplay(request: UnifiedChatRequest, provider: Pick<LLMProvider, "name" | "baseUrl"> | undefined, context?: TransformerContext): {
     restoredFromCache: number;
     restoredFromThinking: number;

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

@@ -0,0 +1,45 @@
+/** 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;
+};
+/**
+ * Compact keep-wire snapshot for debug logs. Full transcripts stay behind
+ * LOG_REQUEST_BODY; this is how keep (Responses/Chat) shows encrypted
+ * replay on `ccr→provider` without a 200k-token dump.
+ */
+export declare function summarizeKeepWire(body: unknown): Record<string, unknown>;
+export declare function logKeepWire(body: unknown, opts: {
+    logger?: {
+        debug?: (...args: any[]) => void;
+    };
+    reqId?: string | number;
+    provider?: string;
+    model?: string;
+}): void;
+export declare function logMessageBody(body: unknown, opts: MessageBodyLogOptions): void;

package/dist/utils/nested-agent.d.ts

@@ -0,0 +1,26 @@
+/** First user-turn text only — never system (billing / harness version). */
+export declare function firstUserText(request: unknown): string;
+export declare function isHarnessUserNoise(text: string): boolean;
+export declare function userMessageTextParts(content: unknown): string[];
+/**
+ * First user text that distinguishes a worker transcript.
+ * Shared reminder/caveat preambles are skipped so parallel Tasks do not collide.
+ */
+export declare function firstSubstantiveUserText(request: unknown): string;
+/** Statusline / spinner polls — must not supersede or become a cache baseline. */
+export declare function isStatuslinePollTurn(request: unknown): boolean;
+/**
+ * Nested/worker agent on any inbound protocol.
+ *
+ * Claude Code: `cc_is_subagent`.
+ * OpenCode / Kilocode / MiMo: child session + `x-parent-session-id`.
+ * Kilocode gateway: `X-KILOCODE-PARENT-TASKID`.
+ * Codex: `x-openai-subagent`.
+ * Cursor/Claude forks: `<fork-boilerplate>` / worker-fork opening text.
+ * Grok CLI: child `x-grok-session-id` (unique) plus opening-text mix.
+ */
+export declare function detectNestedAgent(input: {
+    headers?: unknown;
+    body?: unknown;
+    claudeCodeSubagent?: boolean;
+}): boolean;

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

@@ -7,11 +7,24 @@ export interface ResponsesCallIdMap {
 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;
+/**
+ * Enforce the Responses call_id contract without rebuilding an exact-wire body.
+ *
+ * Same-protocol wire keep deliberately skips the Responses owner's full
+ * transformRequestIn so images/files/reasoning/cache fields remain byte-faithful.
+ * Call ids are still a provider validation boundary, though: Cursor-style
+ * composite ids can exceed 64 characters. Rewrite only the identity field on
+ * call/output items and reuse the normalization map so paired items and hash
+ * collisions resolve identically in both directions.
+ */
+export declare function sanitizeResponsesWireCallIds(body: any, callIdMap?: ResponsesCallIdMap): 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;
+/** 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 +95,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 +210,9 @@ export interface ResponsesStreamState {
     thinkingContent: string;
     thinkingEncryptedContent?: string;
     thinkingId?: string;
+    thinkingStarted: boolean;
+    thinkingClosed: boolean;
+    thinkingOutputIndex?: number;
     codexIsolateConventions: boolean;
 }
 export declare function createResponsesStreamState(options?: {