@caeliq/llms 1.0.55 → 1.0.57

package/dist/utils/cacheControl.d.ts

@@ -0,0 +1,44 @@
+import { UnifiedChatRequest, UnifiedMessage, UnifiedTool } from "../types/llm";
+type CacheableLocation = {
+    kind: "message";
+    messageIndex: number;
+} | {
+    kind: "content";
+    messageIndex: number;
+    contentIndex: number;
+} | {
+    kind: "tool";
+    toolIndex: number;
+};
+export interface CacheIntent {
+    sessionKey?: string;
+    breakpoints: CacheableLocation[];
+}
+/**
+ * Strip cache_control from a single object (shallow clone).
+ */
+export declare function stripCacheControl<T extends Record<string, any>>(obj: T): T;
+/**
+ * Strip cache_control from all messages and their content items.
+ */
+export declare function stripMessagesCacheControl(messages: UnifiedMessage[]): UnifiedMessage[];
+/**
+ * Strip cache_control from tool definitions. Anthropic → Unified preserves
+ * cache_control on tools so the Anthropic round-trip keeps prompt-cache hits,
+ * but non-Anthropic providers reject it on tool definitions.
+ */
+export declare function stripToolsCacheControl(tools: UnifiedTool[] | undefined): UnifiedTool[] | undefined;
+export declare function deriveCacheSessionKey(context: any, request: UnifiedChatRequest): string | undefined;
+export declare function selectCacheBreakpoints(request: UnifiedChatRequest, options: {
+    maxBreakpoints: number;
+    includeTools?: boolean;
+}): CacheIntent;
+export declare function applyAnthropicPromptCaching(request: UnifiedChatRequest, options?: {
+    maxBreakpoints?: number;
+    includeTools?: boolean;
+}): UnifiedChatRequest;
+export declare function applyRawAnthropicPromptCaching<T extends Record<string, any>>(request: T, options?: {
+    maxBreakpoints?: number;
+}): T;
+export declare function applyQwenPromptCaching(request: UnifiedChatRequest): UnifiedChatRequest;
+export {};

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

@@ -0,0 +1,22 @@
+declare const CLAUDE_AUTH_FILE: string;
+declare const OAUTH_CONFIG: {
+    client_id: string;
+    authorization_endpoint: string;
+    token_endpoint: string;
+    scope: string;
+};
+export interface ClaudeTokens {
+    access_token: string;
+    refresh_token?: string;
+    id_token?: string;
+    token_type: string;
+    scope?: string;
+    expires_at: number;
+    last_refresh?: number;
+}
+export declare function loadTokens(): ClaudeTokens | null;
+export declare function saveTokens(tokens: ClaudeTokens): void;
+export declare function isTokenExpired(tokens: ClaudeTokens, leewaySeconds?: number): boolean;
+export declare function refreshTokens(refreshToken: string): Promise<ClaudeTokens>;
+export declare function getValidAccessToken(): Promise<ClaudeTokens>;
+export { OAUTH_CONFIG, CLAUDE_AUTH_FILE };

package/dist/utils/codex-auth.d.ts

@@ -0,0 +1,33 @@
+declare const OAUTH_CONFIG: {
+    client_id: string;
+    token_endpoint: string;
+};
+export interface CodexTokens {
+    access_token: string;
+    refresh_token?: string;
+    id_token?: string;
+    token_type: string;
+    scope?: string;
+    expires_at: number;
+    account_id?: string;
+    last_refresh?: number;
+}
+export interface CodexOAuthAuth {
+    mode: "oauth";
+    token: string;
+    accountId?: string;
+    isFedramp: boolean;
+}
+export interface RefreshOptions {
+    force?: boolean;
+    previousAccessToken?: string;
+    expectedAccountId?: string;
+}
+declare function getAuthFilePath(): string;
+export declare function loadTokens(): CodexTokens | null;
+export declare function saveTokens(tokens: CodexTokens): void;
+export declare function isTokenExpired(tokens: CodexTokens, leewaySeconds?: number): boolean;
+export declare function refreshTokens(refreshToken: string): Promise<CodexTokens>;
+export declare function getValidAccessToken(options?: RefreshOptions): Promise<CodexTokens>;
+export declare function toCodexOAuthAuth(tokens: CodexTokens): CodexOAuthAuth;
+export { getAuthFilePath, OAUTH_CONFIG };

package/dist/utils/converter.d.ts

@@ -0,0 +1,11 @@
+import type { ChatCompletionTool } from "openai/resources/chat/completions";
+import type { Tool as AnthropicTool } from "@anthropic-ai/sdk/resources/messages";
+import { UnifiedChatRequest, UnifiedTool, OpenAIChatRequest, AnthropicChatRequest, ConversionOptions } from "../types/llm";
+export declare function convertToolsToOpenAI(tools: UnifiedTool[]): ChatCompletionTool[];
+export declare function convertToolsToAnthropic(tools: UnifiedTool[]): AnthropicTool[];
+export declare function convertToolsFromOpenAI(tools: ChatCompletionTool[]): UnifiedTool[];
+export declare function convertToolsFromAnthropic(tools: AnthropicTool[]): UnifiedTool[];
+export declare function convertToOpenAI(request: UnifiedChatRequest): OpenAIChatRequest;
+export declare function convertFromOpenAI(request: OpenAIChatRequest): UnifiedChatRequest;
+export declare function convertFromAnthropic(request: AnthropicChatRequest): UnifiedChatRequest;
+export declare function convertRequest(request: OpenAIChatRequest | AnthropicChatRequest | UnifiedChatRequest, options: ConversionOptions): OpenAIChatRequest | AnthropicChatRequest;

package/dist/utils/cursor-auth.d.ts

@@ -0,0 +1,3 @@
+export declare function resolveCursorApiKey(provider?: {
+    apiKey?: string;
+}): string;

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

@@ -0,0 +1,28 @@
+import { LLMProvider, UnifiedChatRequest, UnifiedMessage } from "../types/llm";
+import { TransformerContext } from "../types/transformer";
+type ToolCallLike = NonNullable<UnifiedMessage["tool_calls"]>[number];
+type MessageLike = Pick<UnifiedMessage, "role" | "content" | "thinking" | "tool_calls" | "tool_call_id" | "reasoning_content"> & {
+    name?: string;
+};
+type AssistantResponseRecorder = {
+    content: string;
+    reasoning: string;
+    toolCalls: Map<number, ToolCallLike>;
+};
+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 prepareReasoningReplay(request: UnifiedChatRequest, provider: Pick<LLMProvider, "name" | "baseUrl"> | undefined, context?: TransformerContext): {
+    restoredFromCache: number;
+    restoredFromThinking: number;
+};
+export declare function hasDeepSeekReasoningContext(context?: TransformerContext): boolean;
+export declare function recordReasoningResponseMessage(message: MessageLike | null | undefined, context?: TransformerContext): number;
+export declare function createAssistantResponseRecorder(): AssistantResponseRecorder;
+export declare function appendAssistantResponseDelta(recorder: AssistantResponseRecorder, delta: {
+    content?: unknown;
+    reasoning_content?: unknown;
+    tool_calls?: Array<Record<string, any>>;
+}): void;
+export declare function buildAssistantResponseMessage(recorder: AssistantResponseRecorder): MessageLike | null;
+export {};

package/dist/utils/gemini-cache.d.ts

@@ -0,0 +1,8 @@
+export declare function attachGeminiCachedContent(options: {
+    body: Record<string, any>;
+    modelResource: string;
+    createUrl: string | URL;
+    headers: Record<string, string | undefined>;
+    logger?: any;
+}): Promise<Record<string, any>>;
+export declare function clearGeminiCachedContentForTests(): void;

package/dist/utils/gemini-thinking.d.ts

@@ -0,0 +1,66 @@
+import { UnifiedChatRequest } from "../types/llm";
+/**
+ * Translate Claude Code's effort setting into the thinking dialect each Gemini
+ * family expects.
+ *
+ * Claude Code is authoritative: the effort it sends (`output_config.effort`,
+ * surfaced as `reasoning.effort`) decides how much the model thinks. The model
+ * id is never rewritten — a user who configured `gemini-3-pro-low` keeps talking
+ * to `gemini-3-pro-low`; only the request's thinkingConfig changes. Antigravity
+ * tier-suffixed ids accept the whole level set for their family, so the suffix
+ * caps nothing here (it does still select the upstream quota bucket).
+ *
+ * Two upstream dialects, never mixed — sending thinkingLevel and thinkingBudget
+ * in one request is a documented 400:
+ *
+ *  - level  (Gemini 3+): thinkingLevel, per-family value set
+ *  - budget (Gemini 2.5, Claude served through Antigravity): thinkingBudget in tokens
+ */
+/** Upstream `thinkingLevel` values, ascending. */
+type GeminiThinkingLevel = "minimal" | "low" | "medium" | "high";
+type ThinkingDialect = {
+    kind: "level";
+    levels: GeminiThinkingLevel[];
+} | {
+    kind: "budget";
+    min: number;
+    max: number;
+    requireMin?: boolean;
+}
+/** Unknown family: only ask for thought parts, never guess a level or budget. */
+ | {
+    kind: "includeOnly";
+}
+/** Image models must not carry thinking config at all. */
+ | {
+    kind: "none";
+};
+export type GeminiThinkingConfig = {
+    includeThoughts?: boolean;
+    thinkingLevel?: GeminiThinkingLevel;
+    thinkingBudget?: number;
+};
+/**
+ * Which thinking dialect a model speaks. Matching is by family prefix so tier
+ * and preview suffixes (`-low`, `-high`, `-tiered`, `-preview`, `-agent`) all
+ * resolve to their family.
+ */
+export declare function resolveThinkingDialect(model: string): ThinkingDialect;
+/**
+ * Clamp a requested effort onto the levels a family accepts.
+ *
+ * Rounds *up* when the exact level is missing so a request never silently loses
+ * reasoning depth: `medium` on Gemini 3 Pro (low|high) becomes `high`, and
+ * Claude's `xhigh`/`max` — which are not Gemini enum values — become `high`.
+ */
+export declare function translateThinkingLevel(effort: string, levels: GeminiThinkingLevel[]): GeminiThinkingLevel;
+/**
+ * Build the `generationConfig.thinkingConfig` for a request.
+ *
+ * Returns undefined when the request asks for no thinking at all, or when the
+ * model cannot carry the config.
+ */
+export declare function buildGeminiThinkingConfig(request: Pick<UnifiedChatRequest, "model" | "reasoning" | "max_tokens"> & {
+    thinking?: UnifiedChatRequest["thinking"];
+}): GeminiThinkingConfig | undefined;
+export {};

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

@@ -0,0 +1,43 @@
+import { UnifiedChatRequest } from "../types/llm";
+/**
+ * Transform a tool object
+ * @param {Object} tool - The tool object to transform
+ * @returns {Object} - The transformed tool object
+ */
+export declare function tTool(tool: any, opts?: {
+    collapseUnions?: boolean;
+}): any;
+export declare const SKIP_THOUGHT_SIGNATURE = "skip_thought_signature_validator";
+export type GeminiBuildOptions = {
+    /**
+     * How to replay functionCall parts whose thought signature is missing (Claude
+     * Code strips the field from tool_use blocks).
+     *
+     * - "skip" (default): stamp the documented `skip_thought_signature_validator`
+     *   sentinel on the first functionCall part of the turn. Gemini 3 and
+     *   Antigravity return 400 without it.
+     * - "none": never stamp the sentinel — escape hatch for endpoints that reject
+     *   it, at the cost of 400s on unsigned tool replays.
+     *
+     * The sentinel is only reached when the real signature is unavailable: CCR
+     * caches signatures per tool-call id (see thought-signature-cache) precisely
+     * so that unsigned replays stop degrading the model.
+     */
+    thoughtSignatureFallback?: "skip" | "none";
+    /**
+     * Cache scope for remembered thought signatures — the provider name. A
+     * signature is only valid at the upstream that minted it, so a mismatch must
+     * miss the cache and fall back to the sentinel.
+     */
+    signatureScope?: string;
+};
+/**
+ * Build a Gemini generateContent body from UnifiedChatRequest.
+ *
+ * Whitelist-by-construction: messages/tools/system are rebuilt from named fields,
+ * so Anthropic `cache_control` markers never reach upstream. Do not refactor toward
+ * pass-through of content objects without stripping cache_control first.
+ */
+export declare function buildRequestBody(request: UnifiedChatRequest, opts?: GeminiBuildOptions): Record<string, any>;
+export declare function transformRequestOut(request: Record<string, any>): UnifiedChatRequest;
+export declare function transformResponseOut(response: Response, providerName: string, logger?: any, signatureScope?: string): Promise<Response>;

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

@@ -0,0 +1,160 @@
+import { MessageContent } from "../types/llm";
+/** Marker that prefixes CCR's upstream-failure notice; used to strip it on replay. */
+export declare const UPSTREAM_STOP_NOTICE = "\u26A0\uFE0F Upstream ended the turn without a reply";
+export declare function normalizeGoogleFinishReason(raw?: string | null): string | null;
+/**
+ * Text to show when the upstream ends a turn abnormally with nothing to show:
+ * no text, no tool calls. Returns null for normal completions.
+ *
+ * Gemini 3 / Antigravity return e.g. `MALFORMED_FUNCTION_CALL` ("Function call
+ * is empty - no input to parse") after streaming only thinking. Without this the
+ * turn reached Claude Code as a silent, successful `end_turn`, so the user saw
+ * an assistant turn that said nothing and had to prompt again.
+ */
+export declare function buildAbnormalFinishNotice(candidate?: any): string | null;
+/**
+ * Callbacks used by ThinkingSequencer to emit SSE chunks.
+ * The caller provides implementations that handle actual SSE serialization.
+ */
+export interface ThinkingSequencerEmit {
+    thinking: (content: string, chunk?: any) => void;
+    signature: (sig: string, chunk?: any) => void;
+    content: (text: string, meta?: {
+        chunk?: any;
+        candidate?: any;
+        mode?: "direct" | "buffered" | "placeholder" | "finish";
+        finishReason?: string | null;
+    }) => void;
+}
+/**
+ * State machine that enforces Anthropic-safe emission order for Gemini thinking:
+ *   Thinking Content → Thinking Signature → Final Content
+ *
+ * Supports two upstream stream dialects:
+ *
+ * 1) Public Gemini API (and Vertex):
+ *    - Happy path: thought:true → thoughtSignature → text
+ *    - Gemini 3 out-of-order: thought:true → text (buffer) → signature (flush)
+ *    - Empty thinking: signature first → emit "(no content)" thinking → text
+ *
+ * 2) Antigravity:
+ *    - Visible text first (often with no thought:true parts)
+ *    - Final event: thoughtSignature + empty text + STOP
+ *    - Must NOT open a late thinking block after text (Claude Code drops the turn)
+ *
+ * Rule: if visible content was already emitted when a signature arrives, record
+ * the signature as handled and skip thinking/signature emission.
+ */
+export declare class ThinkingSequencer {
+    private emit;
+    private _hasThinking;
+    private _sigSent;
+    private _contentSent;
+    private _buffer;
+    constructor(emit: ThinkingSequencerEmit);
+    /** Called when thinking text arrives. Emits immediately. */
+    processThinking(text: string, chunk?: any): void;
+    /**
+     * Called when a signature arrives.
+     * - Public Gemini: emit thinking placeholder if needed, emit signature, flush buffer
+     * - Antigravity trailer after content: no-op emission (see class docs)
+     */
+    processSignature(sig: string, chunk?: any): void;
+    processSignatureWithMeta(sig: string, chunk?: any, meta?: {
+        beforeFlush?: () => void;
+        flushMeta?: {
+            chunk?: any;
+            candidate?: any;
+            mode?: "direct" | "buffered" | "placeholder" | "finish";
+            finishReason?: string | null;
+        };
+    }): void;
+    /**
+     * Called when content text arrives.
+     * - Signature already sent or no thinking at all: emit immediately
+     * - Thinking seen but no signature yet: buffer (public Gemini / Gemini 3)
+     */
+    processContent(text: string, chunk?: any, candidate?: any): void;
+    emitContentPlaceholder(text: string, meta?: {
+        chunk?: any;
+        candidate?: any;
+        finishReason?: string | null;
+    }): void;
+    /** Explicitly buffer content (for Gemini 3 out-of-order delivery). */
+    bufferContent(text: string): void;
+    /**
+     * Finalize the stream:
+     * - Emits fallback signature if thinking was seen but no signature arrived
+     * - Flushes any remaining buffered content
+     */
+    finalize(chunk?: any, candidate?: any, options?: {
+        beforeFlush?: () => void;
+    }): void;
+    flushBufferedContent(meta?: {
+        chunk?: any;
+        candidate?: any;
+        mode?: "direct" | "buffered" | "placeholder" | "finish";
+        finishReason?: string | null;
+    }): void;
+    /**
+     * Whether Gemini 3 content should be deferred (signature not yet seen,
+     * not finishing, no tool calls). Public Gemini 3 out-of-order path.
+     */
+    shouldDeferContent(isFinish: boolean, hasToolCalls: boolean): boolean;
+    get hasBufferedContent(): boolean;
+    get hasThinkingContent(): boolean;
+    get signatureSent(): boolean;
+    get contentSent(): boolean;
+    get needsContentPlaceholder(): boolean;
+    /**
+     * Mark a thoughtSignature as handled without emitting thinking/signature/content.
+     * Used when the signature belongs on functionCall parts (tool turns) and must
+     * not invent "(no content)" thinking/text placeholders.
+     */
+    acknowledgeSignature(): void;
+}
+/**
+ * Interface for normalized image data before provider-specific wrapping
+ */
+export interface NormalizedImage {
+    url: string;
+    mediaType: string;
+    isBase64: boolean;
+}
+/**
+ * Maps a role based on a provided mapping object.
+ * Example mapping: { assistant: 'model' }
+ */
+export declare function mapRole(role: string, mapping: Record<string, string>): string;
+/**
+ * Identifies image_url content and normalizes it into a consistent format.
+ * Returns an array of NormalizedImage for any images found in the content.
+ */
+export declare function extractImageParts(content: string | null | MessageContent[]): NormalizedImage[];
+/**
+ * Merges consecutive messages with the same role into a single message
+ * by combining their contents in the specified field.
+ */
+export declare function consolidateMessages<T extends {
+    role: string;
+    [key: string]: any;
+}>(messages: T[], contentField: keyof T): T[];
+/**
+ * Normalizes a tool definition to a standard { name, description, parameters } shape.
+ * Handles both OpenAI-style and Anthropic-style tool definitions.
+ */
+export declare function normalizeTool(tool: any): {
+    name: string;
+    description: string;
+    parameters: any;
+};
+/**
+ * Wraps normalized image data into provider-specific JSON structures.
+ */
+export declare function processImageContent(normalizedImage: NormalizedImage, provider: "gemini" | "claude"): any;
+export declare function replaceLatexSymbols(text: string): string;
+/**
+ * Sanitize a function name for Gemini's naming rules:
+ * Must start with a letter or underscore, contain only [a-zA-Z0-9_.:\-], max 128 chars
+ */
+export declare function sanitizeGeminiFunctionName(name: string): string;

package/dist/utils/image.d.ts

@@ -0,0 +1 @@
+export declare const formatBase64: (data: string, media_type: string) => string;

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

@@ -0,0 +1,14 @@
+import { UnifiedChatRequest } from "../types/llm";
+/**
+ * Transform incoming request to Mistral-compatible format
+ */
+export declare function buildRequestBody(request: UnifiedChatRequest, context?: any, provider?: any): Record<string, any>;
+/**
+ * Transform a Mistral provider request back into a UnifiedChatRequest
+ */
+export declare function transformRequestOut(request: any): Promise<UnifiedChatRequest>;
+/**
+ * Transform response back — convert Mistral's content-array thinking format
+ * to the delta.thinking / delta.content shape expected by @caeliq/llms.
+ */
+export declare function transformResponseOut(response: Response, providerName: string, logger?: any): Promise<Response>;

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

@@ -0,0 +1,17 @@
+import { UnifiedChatRequest } from "../types/llm";
+/**
+ * Validates OpenAI format messages to ensure complete tool_calls/tool message pairing.
+ * Requires tool messages to immediately follow assistant messages with tool_calls.
+ * Enforces strict immediate following sequence between tool_calls and tool messages.
+ */
+export declare function validateOpenAIToolCalls(messages: any[]): any[];
+/**
+ * Injects prompt caching hints into messages for Anthropic models.
+ * Adds cache_control: { type: "ephemeral" } to system messages when model is Claude.
+ */
+export declare function injectPromptCaching(messages: any[], model: string): any[];
+export declare function supportsOpenAIExplicitPromptCache(model: string): boolean;
+export declare function applyOpenAIChatCaching(request: UnifiedChatRequest, _provider?: any, context?: any): UnifiedChatRequest;
+export declare function openAIContentCacheBreakpoint(content: any, model: string): any;
+export declare function applyRequestCacheKey(request: UnifiedChatRequest, context?: any): UnifiedChatRequest;
+export declare function applyProviderNativeChatCaching(request: UnifiedChatRequest, provider?: any, context?: any): UnifiedChatRequest;

package/dist/utils/qwen-auth.d.ts

@@ -0,0 +1,13 @@
+interface QwenTokens {
+    token: string;
+    expiresAt: number | null;
+    updatedAt: number;
+}
+/**
+ * Load a valid (non-expired) Qwen access token, transparently refreshing it
+ * via the upstream rotation endpoint when the token is within 6 hours of
+ * expiry. Throws with an actionable message if no token is configured or if
+ * the refresh attempt fails.
+ */
+export declare function getValidAccessToken(): Promise<QwenTokens>;
+export {};

package/dist/utils/redact.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Privacy-safe redaction for upstream errors and debug logs.
+ * Keep enough diagnostic signal (status, error type) without leaking secrets.
+ */
+export declare function sanitizeUpstreamErrorText(value: string): string;
+export declare function sanitizeErrorForLog(error: unknown): {
+    message: string;
+    code?: string;
+    name?: string;
+    statusCode?: number;
+    stack?: string;
+    cause?: string;
+};
+/** Flatten Fastify/Node header values to a single string for logging. */
+export declare function normalizeHeaderValue(value: unknown): string | undefined;
+/** Strip auth headers from a headers object for debug logging. */
+export declare function sanitizeHeadersForLog(headers: Headers | Record<string, unknown> | undefined): Record<string, string>;
+/**
+ * Compare two header maps (case-insensitive names).
+ * Values are sanitized the same way as sanitizeHeadersForLog.
+ */
+export declare function diffHeadersForLog(left: Headers | Record<string, unknown> | undefined, right: Headers | Record<string, unknown> | undefined): {
+    onlyInLeft: Record<string, string>;
+    onlyInRight: Record<string, string>;
+    changed: Record<string, {
+        from: string;
+        to: string;
+    }>;
+    sameCount: number;
+};

package/dist/utils/request.d.ts

@@ -0,0 +1,4 @@
+import { UnifiedChatRequest } from "../types/llm";
+/** Loopback and NO_PROXY/no_proxy hosts should not go through HTTPS_PROXY. */
+export declare function shouldBypassProxy(target: URL | string): boolean;
+export declare function sendUnifiedRequest(url: URL | string, request: UnifiedChatRequest, config: any, context: any, logger?: any): Promise<Response>;

package/dist/utils/retry.d.ts

@@ -0,0 +1,27 @@
+import type { FastifyReply, FastifyRequest } from "fastify";
+export declare const CLIENT_DISCONNECT_REASON = "client disconnected";
+export type ClientDisconnectHandle = {
+    signal: AbortSignal;
+    /** Attach response close/error listeners for the full upstream lifecycle. */
+    arm: () => void;
+};
+export declare function delay(ms: number, signal?: AbortSignal): Promise<void>;
+/**
+ * AbortSignal that fires when the HTTP client disconnects mid-response.
+ * Used to cancel upstream provider fetches and tear down streams.
+ *
+ * Important: never treat request close/destroyed state as a disconnect after
+ * Fastify has parsed the body. A response `close` event is also insufficient by
+ * itself: only abort when the response or its socket is actually gone.
+ */
+export declare function createClientDisconnectSignal(_req: FastifyRequest, reply?: FastifyReply): ClientDisconnectHandle;
+export declare function parseRetryAfterHeaderMs(value: string | null | undefined): number | undefined;
+export declare function exponentialRetryBackoffMs(failedAttemptIndex: number): number;
+/** Prefer Retry-After when present; otherwise exponential backoff. */
+export declare function retryDelayAfterFailure(failedAttemptIndex: number, retryAfterHeader?: string | null): number;
+export declare function selectFallbackModels(fallbackConfig: Record<string, unknown> | undefined, scenarioType: string): string[] | undefined;
+export declare function toClientAbortError(reason?: unknown): Error;
+export declare function isClientAbortError(error: unknown): boolean;
+export declare function isResponseSocketGone(reply: FastifyReply): boolean;
+export declare function isProviderNetworkError(error: unknown): boolean;
+export declare function isFallbackEligibleError(error: unknown): boolean;

package/dist/utils/router.d.ts

@@ -0,0 +1,42 @@
+import { ConfigService } from "../services/config";
+import { TokenizerService } from "../services/tokenizer";
+interface Tool {
+    name: string;
+    description?: string;
+    input_schema: object;
+}
+interface ContentBlockParam {
+    type: string;
+    [key: string]: any;
+}
+interface MessageParam {
+    role: string;
+    content: string | ContentBlockParam[];
+}
+/** Normalize `provider/model` or `provider,model` into our `provider,model` form. */
+export declare function normalizeModelSelector(value: string | undefined | null): string | undefined;
+/**
+ * Strip Claude Code's billing helper system block.
+ * Returns true when that block marks the request as a subagent.
+ */
+export declare function removeClaudeCodeBillingSystemHeader(body: any): boolean;
+/** Prefer system tag, then early user-message tag; strip whichever matched. */
+export declare function extractAndRemoveClaudeCodeSubagentModelTag(body: any): string | undefined;
+export declare const calculateTokenCount: (messages: MessageParam[], system: any, tools: Tool[]) => number;
+export interface RouterContext {
+    configService: ConfigService;
+    tokenizerService?: TokenizerService;
+    event?: any;
+}
+export type RouterScenarioType = 'default' | 'background' | 'think' | 'longContext' | 'webSearch' | 'subagent';
+export interface RouterFallbackConfig {
+    default?: string[];
+    background?: string[];
+    think?: string[];
+    longContext?: string[];
+    webSearch?: string[];
+    subagent?: string[];
+}
+export declare const router: (req: any, _res: any, context: RouterContext) => Promise<void>;
+export declare const searchProjectBySession: (sessionId: string, logger?: any) => Promise<string | null>;
+export {};

package/dist/utils/schema.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Recursively sanitizes a JSON schema by:
+ * 1. Stripping unknown fields (not in VALID_SCHEMA_FIELDS)
+ * 2. Removing enum from non-string types
+ * 3. Removing format from string types (except "enum" and "date-time")
+ * 4. Removing format: 'uri' from any type
+ * 5. Removing $schema field
+ *
+ * This is a superset of normalizeJsonSchema that also handles
+ * field whitelisting and enum/format cleanup needed by providers
+ * like Gemini and Mistral.
+ */
+export declare function sanitizeJsonSchema(schema: any, parentKey?: string): any;
+/**
+ * Collapse union subschemas that carry no `type` of their own.
+ *
+ * Antigravity serves Claude models by parsing our Gemini `generateContent` body
+ * into the Gemini Schema proto and re-emitting it as an Anthropic tool schema. A
+ * subschema with `anyOf` and no sibling `type` has no proto type to carry, and
+ * what comes out the far side fails Anthropic's draft 2020-12 validation:
+ *
+ *   tools.18.custom.input_schema: JSON schema is invalid.
+ *
+ * Adding a sibling `type` is not an option — Gemini rejects that outright with
+ * "type and anyOf cannot be both populated" — so the union is collapsed onto its
+ * first typed branch instead, and the alternatives are recorded in the
+ * description so the model still knows they exist. Lossy, but the alternative is
+ * that every request carrying such a tool fails.
+ *
+ * Gemini itself handles typeless unions fine, so this is only for backends
+ * reached through the Gemini wire format.
+ */
+export declare function collapseTypelessUnions(schema: any): any;
+/**
+ * Normalizes a JSON schema by removing fields that may cause API rejections:
+ * - format: 'uri' from string types
+ * - $schema field
+ *
+ * For full sanitization (field whitelist, enum/format cleanup), use sanitizeJsonSchema instead.
+ */
+export declare function normalizeJsonSchema(schema: any): any;
+/**
+ * Normalizes tool function parameters by removing problematic fields.
+ * Uses sanitizeJsonSchema for thorough cleanup.
+ */
+export declare function normalizeToolParameters(parameters: any): any;

package/dist/utils/sse/SSEParser.transform.d.ts

@@ -0,0 +1,6 @@
+export declare class SSEParserTransform extends TransformStream<string, any> {
+    private buffer;
+    private currentEvent;
+    constructor();
+    private processLine;
+}

package/dist/utils/sse/SSESerializer.transform.d.ts

@@ -0,0 +1,3 @@
+export declare class SSESerializerTransform extends TransformStream<any, string> {
+    constructor();
+}

package/dist/utils/sse/index.d.ts

@@ -0,0 +1,3 @@
+export { SSEParserTransform } from './SSEParser.transform';
+export { SSESerializerTransform } from './SSESerializer.transform';
+export { rewriteStream } from './rewriteStream';