@caeliq/llms 1.0.66 → 1.0.67

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/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/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/responses.encrypted-content-cache.d.ts

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

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

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

package/dist/tests/wire-keep.d.ts

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

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

@@ -1,51 +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 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;
-    private normalizeRequestContent;
-    private convertResponseToChat;
-    private buildImageContent;
+    private normalizeCodexTransport;
+    private ensureSseContentType;
+    private jsonToSseBytes;
+    private collectSseIntoResponses;
 }

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/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

@@ -29,7 +29,17 @@ export type MessageBodyLogOptions = {
     type?: string;
 };
 /**
- * Opt-in full message-body capture with a stable direction tag so operators
- * can grep client↔CCR and CCR↔provider legs independently.
+ * 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,6 +7,17 @@ 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.

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

@@ -10,9 +10,13 @@ export type RequestLatency = {
         protocol?: string;
         provider?: string;
         model?: string;
+        method?: string;
+        url?: string;
         scenario?: string;
         bypass?: boolean;
+        wireKeep?: boolean;
         tokenCount?: number;
+        tokenCountSource?: "exact" | "estimate" | "skipped";
         inputBytes?: number;
         upstreamAttempts?: number;
         cancelled?: boolean;

package/dist/utils/responses.encrypted-content-cache.d.ts

@@ -0,0 +1,42 @@
+import { LLMProvider, UnifiedChatRequest, UnifiedMessage } from "../types/llm";
+import { TransformerContext } from "../types/transformer";
+type MessageLike = Pick<UnifiedMessage, "role" | "content" | "thinking" | "tool_calls" | "tool_call_id" | "reasoning_content"> & {
+    name?: string;
+};
+export type EncryptedReasoningPayload = {
+    encrypted_content: string;
+    content?: string;
+    id?: string;
+};
+export type EncryptedReasoningStreamRecorder = {
+    observe(event: any): void;
+    completedOutput(): any[] | undefined;
+    discard(): void;
+};
+/**
+ * Accumulate only the opaque reasoning/tool state needed for replay. Some
+ * Responses-compatible hosts omit full output from response.completed, so the
+ * cache cannot depend on that one event. Bounds make malformed streams fail
+ * closed (no cache write) without affecting client-visible stream conversion.
+ */
+export declare function createEncryptedReasoningStreamRecorder(): EncryptedReasoningStreamRecorder;
+export declare function isCrossProtocolResponsesClient(context?: TransformerContext): boolean;
+export declare function buildEncryptedReasoningCacheNamespace(request: Pick<UnifiedChatRequest, "model" | "thinking" | "reasoning">, provider?: Pick<LLMProvider, "name" | "baseUrl">, context?: TransformerContext): string;
+/**
+ * Anthropic/Chat clients cannot round-trip Responses `encrypted_content`.
+ * For those inbound protocols, request ciphertext from the destination and
+ * restore it onto assistant tool turns from a local cache keyed like DeepSeek's
+ * reasoning replay cache.
+ */
+export declare function prepareEncryptedReasoningReplay(request: UnifiedChatRequest, provider: Pick<LLMProvider, "name" | "baseUrl"> | undefined, context?: TransformerContext): {
+    restoredFromCache: number;
+    includeRequested: boolean;
+};
+export declare function hasEncryptedReasoningContext(context?: TransformerContext): boolean;
+export declare function recordEncryptedReasoningResponseMessage(message: MessageLike | null | undefined, context?: TransformerContext): number;
+/**
+ * Build a cacheable assistant message from a Responses `output` array.
+ * Ciphertext often arrives only on the terminal reasoning item.
+ */
+export declare function assistantMessageFromResponsesOutput(output: any[] | undefined): MessageLike | null;
+export {};

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 CacheAffinityHeaders, type CachePrefixDiff, type CachePrefixIdSource, type CachePrefixStage } from "./cache-prefix-debug";
+import { type CachePrediction, type CursorCacheLifecycle } from "./cache-outcome";
 import type { MessageDebugDirection } from "./message-debug";
 export type UpstreamSSEDebugOptions = {
     logger?: any;
@@ -8,6 +9,9 @@ export type UpstreamSSEDebugOptions = {
     model?: string;
     /** Conversation / Claude session id used to pair consecutive cache snapshots. */
     conversationId?: string;
+    conversationIdSource?: CachePrefixIdSource;
+    /** When false, diff against the last baseline but do not replace it. */
+    commitCachePrefix?: boolean;
     /** Pipeline position this body was captured at. Defaults to `wire`. */
     stage?: CachePrefixStage;
     /** Codex (and similar) routing headers that pin prompt-cache affinity. */
@@ -18,6 +22,12 @@ export type UpstreamSSEDebugOptions = {
     clientStageDiff?: CachePrefixDiff | null;
     /** Outbound diff for this request, joined with the observed cache usage. */
     cacheDiff?: CachePrefixDiff | null;
+    /** Outbound body used to resolve Anthropic/Gemini family signals. */
+    outboundBody?: Record<string, any> | null;
+    /** Precomputed prediction; built from cacheDiff + family when absent. */
+    cachePrediction?: CachePrediction | null;
+    /** Cursor lifecycle plan for conversation-cache prediction. */
+    cursorLifecycle?: CursorCacheLifecycle | null;
     /** Cap for a single logged payload string (raw `data` field). */
     maxBytes?: number;
     /**
@@ -50,7 +60,7 @@ export type ClientSSEDebugOptions = {
  * Byte-preserving upstream response debug tap.
  *
  * For SSE: mirrors bytes to a background consumer that emits Codex-parity
- * `recieved data` / `Original Response` logs (including Anthropic usage /
+ * `received data` / `Original Response` logs (including Anthropic usage /
  * cache fields on message_start / message_delta).
  *
  * Important: do **not** use `ReadableStream.tee()` here. Tee couples

package/dist/utils/stream-peek.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Sniff a response body as JSON vs SSE without Response.clone().
+ *
+ * Cloudflare (Codex) often strips Content-Type from SSE. The first
+ * non-whitespace byte is `{`/`[` for a JSON object/array and anything
+ * else (typically `d` from `data:`) for SSE. JSON drains into text;
+ * SSE returns a new Response that replays the peeked chunk then
+ * continues from the same reader.
+ */
+export type PeekedResponseBody = {
+    kind: "json";
+    firstChar: string;
+    text: string;
+} | {
+    kind: "sse";
+    response: Response;
+} | {
+    kind: "empty";
+};
+export declare function peekResponseBody(response: Response): Promise<PeekedResponseBody>;

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

@@ -0,0 +1,54 @@
+/**
+ * Multimodal tool-result helpers.
+ *
+ * Responses / OpenCode attach images (and files) on function_call_output as
+ * structured parts. Unified carries them as text / image_url / file parts on
+ * role:"tool". Destinations differ:
+ *   - Responses/Codex: re-emit input_image / input_file in output[]
+ *   - Anthropic: image / document blocks inside tool_result.content
+ *   - Gemini: text in functionResponse + sibling inlineData parts
+ *   - Chat Completions / Mistral: string tool content only — extract media
+ *     into a follow-up user message (OpenCode's pattern for non-supporting APIs)
+ */
+export type UnifiedToolPart = {
+    type: "text";
+    text: string;
+    cache_control?: any;
+} | {
+    type: "image_url";
+    image_url: {
+        url: string;
+        detail?: string;
+    };
+    media_type?: string;
+    cache_control?: any;
+} | {
+    type: "file";
+    filename?: string;
+    file_data?: string;
+    file_url?: string;
+    media_type?: string;
+    cache_control?: any;
+};
+export declare function isUnifiedToolMediaPart(part: any): part is Extract<UnifiedToolPart, {
+    type: "image_url" | "file";
+}>;
+/** Normalize string | part[] tool content into a part list. */
+export declare function normalizeUnifiedToolParts(content: unknown): UnifiedToolPart[];
+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 inbound tool_result.content → Unified tool content
+ * (string or text/image_url/file parts).
+ */
+export declare function anthropicToolResultToUnified(content: unknown): string | any[];
+/** Gemini sibling inlineData / fileData parts for tool media. */
+export declare function unifiedToolMediaToGeminiParts(content: unknown): any[];
+/**
+ * Chat Completions / Mistral: string-only tool content. Pull media out of
+ * tool messages and insert a synthetic user message after each contiguous
+ * tool-result group so vision still reaches the model.
+ */
+export declare function extractToolMediaForStringToolApis(messages: any[]): any[];

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

@@ -17,5 +17,14 @@ export declare function compileTransformerPlan(providerUse: Transformer[] | unde
     skipName?: string;
 }): CompiledTransformerPlan;
 export declare function isExactProtocolResponsePlan(plan: CompiledTransformerPlan, endpointTransformer: Transformer, clientProtocolOwnerName: string | undefined): boolean;
+export declare function isExactProtocolRequestPlan(plan: CompiledTransformerPlan, endpointTransformer: Transformer, clientProtocolOwnerName: string | undefined): boolean;
+/**
+ * v1 allowlist: middleware known to be safe on a kept native wire.
+ * `OpenAI` is handled separately — it always runs. `reasoning` is
+ * Chat-shaped and only allowed with an OpenAI owner. Everything else
+ * (Anthropic/Responses owners) does not run Unified-only middleware.
+ */
+export declare function isWireSafeMiddlewareForKeep(name: string | undefined, ownerName: string | undefined): boolean;
+export declare function planContains(plan: CompiledTransformerPlan, name: string): 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/dist/utils/vertex-claude.util.d.ts

@@ -2,7 +2,7 @@ import { UnifiedChatRequest } from "../types/llm";
 interface ClaudeMessage {
     role: "user" | "assistant";
     content: Array<{
-        type: "text" | "image" | "tool_use" | "tool_result";
+        type: "text" | "image" | "document" | "tool_use" | "tool_result";
         text?: string;
         source?: {
             type: "base64";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@caeliq/llms",
-  "version": "1.0.66",
+  "version": "1.0.67",
   "description": "A universal LLM API transformation server",
   "main": "dist/cjs/server.cjs",
   "module": "dist/esm/server.mjs",
@@ -30,7 +30,7 @@
   ],
   "dependencies": {
     "@anthropic-ai/sdk": "^0.120.0",
-    "@caeliq/ccr-shared": "^2.1.8",
+    "@caeliq/ccr-shared": "^2.1.9",
     "@cursor/sdk": "^1.0.30",
     "@fastify/cors": "^11.3.0",
     "@fastify/rate-limit": "^11.2.0",