@caeliq/llms 1.0.55 → 1.0.57

package/dist/transformer/maxtoken.transformer.d.ts

@@ -0,0 +1,9 @@
+import { UnifiedChatRequest } from "../types/llm";
+import { Transformer, TransformerOptions } from "../types/transformer";
+export declare class MaxTokenTransformer implements Transformer {
+    private readonly options?;
+    static TransformerName: string;
+    max_tokens: number;
+    constructor(options?: TransformerOptions | undefined);
+    transformRequestIn(request: UnifiedChatRequest): Promise<UnifiedChatRequest>;
+}

package/dist/transformer/mistral.transformer.d.ts

@@ -0,0 +1,25 @@
+import { LLMProvider, UnifiedChatRequest } from "../types/llm";
+import { Transformer, TransformerContext } from "../types/transformer";
+import { transformRequestOut } from "../utils/mistral.util";
+/**
+ * Mistral Transformer for Claude Code Router
+ *
+ * Transforms Anthropic-style requests to Mistral's OpenAI-compatible API format.
+ */
+export declare class MistralTransformer implements Transformer {
+    name: string;
+    logger?: any;
+    /**
+     * Transform incoming request to Mistral-compatible format
+     */
+    transformRequestIn(request: UnifiedChatRequest, provider: LLMProvider, context: TransformerContext): Promise<Record<string, any>>;
+    /**
+     * Transform Mistral-specific request back to UnifiedChatRequest
+     */
+    transformRequestOut: typeof transformRequestOut;
+    /**
+     * Transform response back — convert Mistral's content-array thinking format
+     * to the delta.thinking / delta.content shape expected by @caeliq/llms.
+     */
+    transformResponseOut(response: Response, _context: TransformerContext): Promise<Response>;
+}

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

@@ -0,0 +1,13 @@
+import { UnifiedChatRequest } from "../types/llm";
+import { Transformer } from "../types/transformer";
+export declare class OpenAIResponsesTransformer implements Transformer {
+    logger?: any;
+    name: string;
+    endPoint: string;
+    transformRequestIn(request: UnifiedChatRequest, provider?: any, context?: any): Promise<UnifiedChatRequest>;
+    transformResponseOut(response: Response): Promise<Response>;
+    private convertStreamEvent;
+    private normalizeRequestContent;
+    private convertResponseToChat;
+    private buildImageContent;
+}

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

@@ -0,0 +1,52 @@
+import { Transformer } from "../types/transformer";
+import { UnifiedChatRequest } from "../types/llm";
+/**
+ * Server-side route handler for the OpenAI Chat Completions API.
+ *
+ * ## How endPoint works
+ *
+ * At startup, `registerApiRoutes` (see `api/routes.ts`) scans all registered
+ * transformers for ones that define `endPoint`. For each, it registers a
+ * `POST` route at that path. When a request hits the route,
+ * `handleTransformerEndpoint` is invoked with the matching transformer as
+ * the "endpoint transformer" — the one responsible for converting between
+ * the external wire format and the internal Unified format.
+ *
+ * ## Request handling
+ *
+ * The Unified format IS the OpenAI Chat Completions format. The conversion
+ * from Anthropic → Unified already happened in
+ * `AnthropicTransformer.transformRequestOut()` (which runs first in the
+ * pipeline). So by the time the provider chain executes, the body is already
+ * in the right shape — no further conversion is needed.
+ *
+ * `transformRequestIn` also translates Claude Code cache intent to the
+ * selected provider's native Chat Completions behavior. The provider identity
+ * is checked before adding request-level fields so OpenAI-compatible services
+ * do not receive OpenAI-only parameters.
+ *
+ * ## Relationship to OpenAIResponsesTransformer
+ *
+ * `OpenAIResponsesTransformer` (in `openai.responses.transformer.ts`) is the
+ * counterpart for the Responses API (`/v1/responses`). Unlike this
+ * transformer, it defines `transformRequestIn` / `transformResponseOut`
+ * because the Responses API uses a different wire format (e.g. `messages`
+ * → `input`, function tools → flat tool definitions). It also uses the
+ * shared utilities in `openai.util.ts` (`validateOpenAIToolCalls`,
+ * `injectPromptCaching`) to sanitize the Unified body before converting it.
+ *
+ * ## Full request pipeline (for context)
+ *
+ *     Client → POST /v1/messages
+ *       → AnthropicTransformer.transformRequestOut()        // Anthropic → Unified (OpenAI)
+ *       → provider.transformer.use[].transformRequestIn()   // provider middleware
+ *       → sendRequestToProvider()                           // HTTP call upstream
+ *       → provider.transformer.use[].transformResponseOut() // provider middleware (reversed)
+ *       → AnthropicTransformer.transformResponseIn()        // Unified (OpenAI) → Anthropic
+ *       → Client
+ */
+export declare class OpenAITransformer implements Transformer {
+    name: string;
+    endPoint: string;
+    transformRequestIn(request: UnifiedChatRequest, provider: any, context: any): Promise<UnifiedChatRequest>;
+}

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

@@ -0,0 +1,30 @@
+import { Transformer } from "../types/transformer";
+export declare class OpencodeHeadersTransformer implements Transformer {
+    name: string;
+    private sessionCache;
+    private readonly MAX_SESSIONS;
+    private lastTimestamp;
+    private counter;
+    transformRequestIn(request: any, provider: any, context: any): Promise<Record<string, any>>;
+    /**
+     * Own the full upstream call so a `No provider available` 401 can be retried
+     * with a fresh session in isolation. Any other non-ok response is re-thrown in
+     * the exact shape sendRequestToProvider would have produced, so genuine
+     * auth/rate/server errors keep flowing through the normal error + fallback
+     * path unchanged.
+     */
+    private sendWithSessionRetry;
+    private buildHeaders;
+    /**
+     * True only for the two Zen session-hash routing failures — a re-roll can
+     * recover these. Kept deliberately narrow (exact status + message) so genuine
+     * auth errors (401 invalid key) and request errors (400 validation) are never
+     * mistaken for routing failures and pass straight through.
+     */
+    private isZenRoutingFailure;
+    private retryAfterHeaders;
+    private fingerprintConversation;
+    private getOrCreateSessionId;
+    private invalidateSession;
+    private generateId;
+}

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

@@ -0,0 +1,10 @@
+import { UnifiedChatRequest } from "../types/llm";
+import { Transformer, TransformerOptions } from "../types/transformer";
+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>;
+    transformResponseOut(response: Response): Promise<Response>;
+}

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

@@ -0,0 +1,9 @@
+import { Transformer } from "../types/transformer";
+export declare class QwenAuthTransformer implements Transformer {
+    name: string;
+    logger?: any;
+    private buildAuthConfig;
+    transformRequestIn(request: any, provider: any): Promise<Record<string, any>>;
+    auth(_request: any, provider: any): Promise<any>;
+    transformResponseOut(response: Response): Promise<Response>;
+}

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

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

package/dist/transformer/sampling.transformer.d.ts

@@ -0,0 +1,13 @@
+import { UnifiedChatRequest } from "../types/llm";
+import { Transformer, TransformerOptions } from "../types/transformer";
+export declare class SamplingTransformer implements Transformer {
+    private readonly options?;
+    static TransformerName: string;
+    max_tokens: number;
+    temperature: number;
+    top_p: number;
+    top_k: number;
+    repetition_penalty: number;
+    constructor(options?: TransformerOptions | undefined);
+    transformRequestIn(request: UnifiedChatRequest): Promise<UnifiedChatRequest>;
+}

package/dist/transformer/streamoptions.transformer.d.ts

@@ -0,0 +1,6 @@
+import { UnifiedChatRequest } from "../types/llm";
+import { Transformer } from "../types/transformer";
+export declare class StreamOptionsTransformer implements Transformer {
+    name: string;
+    transformRequestIn(request: UnifiedChatRequest): Promise<UnifiedChatRequest>;
+}

package/dist/transformer/tooluse.transformer.d.ts

@@ -0,0 +1,7 @@
+import { UnifiedChatRequest } from "../types/llm";
+import { Transformer } from "../types/transformer";
+export declare class TooluseTransformer implements Transformer {
+    name: string;
+    transformRequestIn(request: UnifiedChatRequest, provider?: any, context?: any): Promise<any>;
+    transformResponseOut(response: Response): Promise<Response>;
+}

package/dist/transformer/vercel.transformer.d.ts

@@ -0,0 +1,11 @@
+import { UnifiedChatRequest } from "../types/llm";
+import { Transformer, TransformerOptions } from "../types/transformer";
+export declare class VercelTransformer implements Transformer {
+    private readonly options?;
+    static TransformerName: string;
+    logger?: any;
+    endPoint: string;
+    constructor(options?: TransformerOptions | undefined);
+    transformRequestIn(request: UnifiedChatRequest, provider?: any, context?: any): Promise<UnifiedChatRequest>;
+    transformResponseOut(response: Response): Promise<Response>;
+}

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

@@ -0,0 +1,9 @@
+import { LLMProvider, UnifiedChatRequest } from "../types/llm";
+import { Transformer } from "../types/transformer";
+export declare class VertexClaudeTransformer implements Transformer {
+    logger?: any;
+    name: string;
+    transformRequestIn(request: UnifiedChatRequest, provider: LLMProvider): Promise<Record<string, any>>;
+    transformRequestOut(request: Record<string, any>): Promise<UnifiedChatRequest>;
+    transformResponseOut(response: Response): Promise<Response>;
+}

package/dist/transformer/vertex-gemini.transformer.d.ts

@@ -0,0 +1,12 @@
+import { LLMProvider, UnifiedChatRequest } from "../types/llm";
+import { Transformer, TransformerContext, TransformerOptions } from "../types/transformer";
+export declare class VertexGeminiTransformer implements Transformer {
+    static TransformerName: string;
+    logger?: any;
+    name: string;
+    private readonly thoughtSignatureFallback;
+    constructor(options?: TransformerOptions);
+    transformRequestIn(request: UnifiedChatRequest, provider: LLMProvider, context?: any): Promise<Record<string, any>>;
+    transformRequestOut(request: Record<string, any>): Promise<UnifiedChatRequest>;
+    transformResponseOut(response: Response, context?: TransformerContext): Promise<Response>;
+}

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

@@ -0,0 +1,19 @@
+import { UnifiedChatRequest } from "../types/llm";
+import { Transformer, TransformerOptions } from "../types/transformer";
+export interface VertexOpenaiOptions extends TransformerOptions {
+    client_email?: string;
+    private_key?: string;
+}
+/**
+ * Auth-only transformer for Vertex AI OpenAI-compatible endpoints.
+ * Injects a Google service-account Bearer token into outbound requests.
+ */
+export declare class VertexOpenaiTransformer implements Transformer {
+    static TransformerName: string;
+    private client?;
+    private readonly client_email?;
+    private readonly private_key?;
+    constructor(options?: VertexOpenaiOptions);
+    private getClient;
+    transformRequestIn(request: UnifiedChatRequest): Promise<Record<string, any>>;
+}

package/dist/types/llm.d.ts

@@ -0,0 +1,255 @@
+import type { ChatCompletionMessageParam as OpenAIMessage } from "openai/resources/chat/completions";
+import type { MessageParam as AnthropicMessage } from "@anthropic-ai/sdk/resources/messages";
+import type { ChatCompletionChunk } from "openai/resources/chat/completions";
+import type { MessageStreamEvent } from "@anthropic-ai/sdk/resources/messages";
+import type { ChatCompletionTool } from "openai/resources/chat/completions";
+import type { Tool as AnthropicTool } from "@anthropic-ai/sdk/resources/messages";
+import { Transformer } from "./transformer";
+import type { ProviderTokenizerConfig } from "./tokenizer";
+export type TransformerConfigEntry = string | [string, Record<string, any>?];
+export interface UrlCitation {
+    url: string;
+    title: string;
+    content: string;
+    start_index: number;
+    end_index: number;
+}
+export interface Annotation {
+    type: "url_citation";
+    url_citation?: UrlCitation;
+}
+export interface TextContent {
+    type: "text";
+    text: string;
+    cache_control?: {
+        type?: string;
+        ttl?: "5m" | "1h";
+    };
+}
+export interface ImageContent {
+    type: "image_url";
+    image_url: {
+        url: string;
+    };
+    media_type: string;
+    cache_control?: {
+        type?: string;
+        ttl?: "5m" | "1h";
+    };
+}
+export type MessageContent = TextContent | ImageContent;
+export interface UnifiedMessage {
+    role: "user" | "assistant" | "system" | "tool";
+    content: string | null | MessageContent[];
+    reasoning_content?: string;
+    tool_calls?: Array<{
+        id: string;
+        type: "function";
+        function: {
+            name: string;
+            arguments: string;
+        };
+        /** Gemini/Antigravity thought signature; must round-trip on functionCall parts. */
+        thought_signature?: string;
+        cache_control?: {
+            type?: string;
+            ttl?: "5m" | "1h";
+        };
+    }>;
+    tool_call_id?: string;
+    cache_control?: {
+        type?: string;
+        ttl?: "5m" | "1h";
+    };
+    thinking?: {
+        content: string;
+        signature?: string;
+    };
+}
+export interface UnifiedTool {
+    type: "function";
+    function: {
+        name: string;
+        description: string;
+        parameters: {
+            type: "object";
+            properties: Record<string, any>;
+            required?: string[];
+            additionalProperties?: boolean;
+            $schema?: string;
+        };
+    };
+    cache_control?: {
+        type?: string;
+        ttl?: "5m" | "1h";
+    };
+}
+export type ThinkLevel = "none" | "low" | "medium" | "high" | "xhigh" | "max";
+export interface UnifiedChatRequest {
+    messages: UnifiedMessage[];
+    model: string;
+    system?: string | MessageContent[];
+    max_tokens?: number;
+    max_completion_tokens?: number;
+    temperature?: number;
+    top_p?: number;
+    top_k?: number;
+    repetition_penalty?: number;
+    stream?: boolean;
+    stream_options?: {
+        include_usage?: boolean;
+        [key: string]: any;
+    };
+    tools?: UnifiedTool[];
+    tool_choice?: "auto" | "none" | "required" | string | {
+        type: "function";
+        function: {
+            name: string;
+        };
+    };
+    reasoning?: {
+        effort?: ThinkLevel;
+        max_tokens?: number;
+        enabled?: boolean;
+    };
+    enable_thinking?: boolean;
+    thinking?: {
+        type: "enabled" | "disabled";
+        budget_tokens?: number;
+    };
+    parallel_tool_calls?: boolean;
+    cache_control?: {
+        type?: string;
+        ttl?: "5m" | "1h";
+    };
+    anthropic_thinking?: Record<string, any>;
+    anthropic_output_config?: Record<string, any>;
+    anthropic_metadata?: Record<string, any>;
+    anthropic_stop_sequences?: string[];
+    reasoning_effort?: string;
+}
+export interface UnifiedChatResponse {
+    id: string;
+    model: string;
+    content: string | null;
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+    tool_calls?: Array<{
+        id: string;
+        type: "function";
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }>;
+    annotations?: Annotation[];
+}
+export interface StreamChunk {
+    id: string;
+    object: string;
+    created: number;
+    model: string;
+    choices?: Array<{
+        index: number;
+        delta: {
+            role?: string;
+            content?: string;
+            thinking?: {
+                content?: string;
+                signature?: string;
+            };
+            tool_calls?: Array<{
+                id?: string;
+                type?: "function";
+                function?: {
+                    name?: string;
+                    arguments?: string;
+                };
+                thought_signature?: string;
+            }>;
+            annotations?: Annotation[];
+        };
+        finish_reason?: string | null;
+    }>;
+}
+export type AnthropicStreamEvent = MessageStreamEvent;
+export type OpenAIStreamChunk = ChatCompletionChunk;
+export interface OpenAIChatRequest {
+    messages: OpenAIMessage[];
+    model: string;
+    max_tokens?: number;
+    temperature?: number;
+    stream?: boolean;
+    tools?: ChatCompletionTool[];
+    tool_choice?: "auto" | "none" | {
+        type: "function";
+        function: {
+            name: string;
+        };
+    };
+}
+export interface AnthropicChatRequest {
+    messages: AnthropicMessage[];
+    model: string;
+    max_tokens: number;
+    temperature?: number;
+    stream?: boolean;
+    system?: string;
+    tools?: AnthropicTool[];
+    tool_choice?: {
+        type: "auto";
+    } | {
+        type: "tool";
+        name: string;
+    };
+}
+export interface ConversionOptions {
+    targetProvider: "openai" | "anthropic";
+    sourceProvider: "openai" | "anthropic";
+}
+export interface LLMProvider {
+    name: string;
+    baseUrl: string;
+    apiKey: string;
+    models: string[];
+    /** Optional GCP / Antigravity project id (provider-specific). */
+    project_id?: string;
+    transformer?: {
+        [key: string]: {
+            use?: Transformer[];
+        } | any;
+    } & {
+        use?: Transformer[];
+        passthrough?: any;
+    };
+}
+export type RegisterProviderRequest = LLMProvider;
+export interface ModelRoute {
+    provider: string;
+    model: string;
+    fullModel: string;
+}
+export interface RequestRouteInfo {
+    provider: LLMProvider;
+    originalModel: string;
+    targetModel: string;
+}
+export interface ConfigProvider {
+    name: string;
+    api_base_url: string;
+    api_key: string;
+    models: string[];
+    /** Optional GCP / Antigravity project id (kept as `$ENV` placeholders in config). */
+    project_id?: string;
+    transformer: {
+        use?: TransformerConfigEntry[];
+    } & {
+        [key: string]: {
+            use?: TransformerConfigEntry[];
+        } | any;
+    };
+    tokenizer?: ProviderTokenizerConfig;
+}

package/dist/types/transformer.d.ts

@@ -0,0 +1,23 @@
+import { LLMProvider, UnifiedChatRequest } from "./llm";
+export interface TransformerOptions {
+    [key: string]: any;
+}
+interface TransformerWithStaticName {
+    new (options?: TransformerOptions): Transformer;
+    TransformerName?: string;
+}
+export type TransformerConstructor = TransformerWithStaticName;
+export interface TransformerContext {
+    [key: string]: any;
+}
+export type Transformer = {
+    transformRequestIn?: (request: UnifiedChatRequest, provider: LLMProvider, context: TransformerContext) => Promise<Record<string, any>>;
+    transformResponseIn?: (response: Response, context?: TransformerContext) => Promise<Response>;
+    transformRequestOut?: (request: any, context: TransformerContext) => Promise<UnifiedChatRequest>;
+    transformResponseOut?: (response: Response, context: TransformerContext) => Promise<Response>;
+    endPoint?: string;
+    name?: string;
+    auth?: (request: any, provider: LLMProvider, context: TransformerContext) => Promise<any>;
+    logger?: any;
+};
+export {};

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

@@ -0,0 +1,75 @@
+export declare const ANTIGRAVITY_CLIENT_ID = "1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com";
+export declare const ANTIGRAVITY_CLIENT_SECRET = "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";
+export declare const ANTIGRAVITY_REDIRECT_URI = "http://localhost:51121/oauth-callback";
+export declare const ANTIGRAVITY_SCOPES: readonly ["https://www.googleapis.com/auth/cloud-platform", "https://www.googleapis.com/auth/userinfo.email", "https://www.googleapis.com/auth/userinfo.profile", "https://www.googleapis.com/auth/cclog", "https://www.googleapis.com/auth/experimentsandconfigs"];
+export declare const ANTIGRAVITY_ENDPOINT_DAILY = "https://daily-cloudcode-pa.sandbox.googleapis.com";
+export declare const ANTIGRAVITY_ENDPOINT_AUTOPUSH = "https://autopush-cloudcode-pa.sandbox.googleapis.com";
+export declare const ANTIGRAVITY_ENDPOINT_PROD = "https://cloudcode-pa.googleapis.com";
+/** generateContent fallback order */
+export declare const ANTIGRAVITY_ENDPOINT_FALLBACKS: readonly ["https://daily-cloudcode-pa.sandbox.googleapis.com", "https://autopush-cloudcode-pa.sandbox.googleapis.com", "https://cloudcode-pa.googleapis.com"];
+/** loadCodeAssist / fetchAvailableModels prefer prod first */
+export declare const ANTIGRAVITY_LOAD_ENDPOINTS: readonly ["https://cloudcode-pa.googleapis.com", "https://daily-cloudcode-pa.sandbox.googleapis.com", "https://autopush-cloudcode-pa.sandbox.googleapis.com"];
+export declare const ANTIGRAVITY_VERSION = "1.18.3";
+export interface AntigravityTokens {
+    access_token: string;
+    refresh_token: string;
+    expires_at: number;
+    email?: string;
+    project_id?: string;
+}
+export declare function getAuthFilePath(): string;
+export declare function getAntigravityHeaders(): Record<string, string>;
+export declare function loadTokens(): AntigravityTokens | null;
+export declare function saveTokens(tokens: AntigravityTokens): void;
+/**
+ * Load a valid access token, refreshing with single-flight dedupe when near expiry.
+ */
+export declare function getValidAccessToken(options?: {
+    force?: boolean;
+}): Promise<AntigravityTokens>;
+/**
+ * Resolve GCP project id: provider config → auth file → loadCodeAssist/onboardUser.
+ * Optional — many Antigravity accounts work with OAuth alone; missing project is fine.
+ */
+export declare function resolveProjectId(provider: {
+    project_id?: string;
+} | undefined, accessToken: string): Promise<string | undefined>;
+export declare function getPreferredEndpoint(): string;
+export declare function rememberEndpoint(endpoint: string): void;
+export declare function clearPreferredEndpoint(): void;
+/** A 403 SERVICE_DISABLED means the host's API is not enabled for the project. */
+export declare function isEndpointDisabledError(body: string): boolean;
+export declare function markEndpointUnusable(endpoint: string): void;
+export declare function isEndpointUnusable(endpoint: string): boolean;
+export declare function clearUnusableEndpoints(): void;
+/**
+ * Whether a failing response should move on to the next endpoint rather than be
+ * reported to the client.
+ *
+ * 404 and 5xx are the classic "wrong or unhealthy host" signals. 403 belongs
+ * here too: the sandbox hosts answer with PERMISSION_DENIED / SERVICE_DISABLED
+ * when the account's project is not entitled to that deployment, which is not
+ * something the caller can act on — as long as another endpoint (prod is last)
+ * is still untried. The final endpoint's error is always surfaced.
+ */
+export declare function shouldWalkEndpoint(status: number, hasMoreEndpoints: boolean): boolean;
+/**
+ * Ordered endpoint candidates, skipping hosts already known to be unusable.
+ * Never returns an empty list: if every host is marked, re-probe them all.
+ */
+export declare function antigravityEndpointCandidates(preferredBase?: string): string[];
+export declare function buildGenerateContentUrl(endpoint: string, stream: boolean): string;
+export declare function wrapAntigravityRequest(options: {
+    project?: string;
+    model: string;
+    request: Record<string, any>;
+}): Record<string, any>;
+export declare function fetchUserEmail(accessToken: string): Promise<string | undefined>;
+export declare function exchangeAuthorizationCode(code: string, codeVerifier: string): Promise<AntigravityTokens>;
+/** Parse RetryInfo.retryDelay like "3.957525076s" into milliseconds. */
+export declare function parseRetryDelayMs(errorBody: string): number | undefined;
+/**
+ * List models available to the authenticated Antigravity account/project.
+ * POST /v1internal:fetchAvailableModels — Google requires a project for this call.
+ */
+export declare function fetchAvailableModels(accessToken: string, projectId?: string, baseUrl?: string): Promise<string[]>;

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

@@ -0,0 +1,2 @@
+export type UnauthorizedAuthRecovery = () => Promise<Record<string, string> | null>;
+export declare function sendWithUnauthorizedAuthRecovery(send: (headers: Record<string, string>) => Promise<Response>, requestHeaders: Record<string, string>, recover?: UnauthorizedAuthRecovery): Promise<Response>;

package/dist/utils/cache.d.ts

@@ -0,0 +1,14 @@
+export interface Usage {
+    input_tokens: number;
+    output_tokens: number;
+}
+declare class LRUCache<K, V> {
+    private capacity;
+    private cache;
+    constructor(capacity: number);
+    get(key: K): V | undefined;
+    put(key: K, value: V): void;
+    values(): V[];
+}
+export declare const sessionUsageCache: LRUCache<string, Usage>;
+export {};