Models and messages

export declare function anthropic(modelId: string, config?: {
    apiKey?: string;
}): ModelProvider;

export declare class AnthropicProvider implements ModelProvider {
    readonly providerId = "anthropic";
    readonly modelId: string;
    constructor(modelId: string, config?: AnthropicConfig);
    generate(messages: ChatMessage[], options?: ModelConfig & {
        tools?: ToolDefinition[];
    }): Promise<ModelResponse>;
    stream(messages: ChatMessage[], options?: ModelConfig & {
        tools?: ToolDefinition[];
    }): AsyncGenerator<StreamChunk>;
}

export interface AudioPart {
    type: "audio";
    /** Base64-encoded audio data. */
    data: string;
    mimeType?: "audio/mp3" | "audio/wav" | "audio/ogg" | "audio/webm";
}

export declare function awsBedrock(modelId: string, config?: AwsBedrockConfig): ModelProvider;

export interface AwsBedrockConfig {
    region?: string;
    accessKeyId?: string;
    secretAccessKey?: string;
    sessionToken?: string;
}

/**
 * Generic AWS Bedrock provider using the Converse API from
 * `@aws-sdk/client-bedrock-runtime`. Works with any model available on
 * Bedrock (Anthropic, Meta, Mistral, Amazon Titan, etc.).
 *
 * For Claude-specific features (like extended thinking) prefer `AwsClaudeProvider`.
 */
export declare class AwsBedrockProvider implements ModelProvider {
    readonly providerId = "aws-bedrock";
    readonly modelId: string;
    constructor(modelId: string, config?: AwsBedrockConfig);
    generate(messages: ChatMessage[], options?: ModelConfig & {
        tools?: ToolDefinition[];
    }): Promise<ModelResponse>;
    stream(messages: ChatMessage[], options?: ModelConfig & {
        tools?: ToolDefinition[];
    }): AsyncGenerator<StreamChunk>;
}

export declare function awsClaude(modelId: string, config?: AwsClaudeConfig): ModelProvider;

export interface AwsClaudeConfig {
    awsAccessKey?: string;
    awsSecretKey?: string;
    awsRegion?: string;
    awsSessionToken?: string;
}

/**
 * Claude models on AWS Bedrock via the `@anthropic-ai/bedrock-sdk`.
 *
 * Uses the Anthropic Messages API routed through AWS Bedrock — same message
 * format as the direct Anthropic API but authenticated with AWS credentials.
 */
export declare class AwsClaudeProvider implements ModelProvider {
    readonly providerId = "aws-claude";
    readonly modelId: string;
    constructor(modelId: string, config?: AwsClaudeConfig);
    generate(messages: ChatMessage[], options?: ModelConfig & {
        tools?: ToolDefinition[];
    }): Promise<ModelResponse>;
    stream(messages: ChatMessage[], options?: ModelConfig & {
        tools?: ToolDefinition[];
    }): AsyncGenerator<StreamChunk>;
}

export declare function azureFoundry(modelId: string, config?: AzureFoundryConfig): ModelProvider;

export interface AzureFoundryConfig {
    apiKey?: string;
    endpoint?: string;
    apiVersion?: string;
}

/**
 * Azure AI Foundry provider — access Phi, Llama, Mistral, Cohere and other
 * open-source models hosted on Azure's model catalog.
 *
 * Uses the standard OpenAI SDK pointed at the Azure AI Foundry endpoint, since
 * Azure AI Foundry exposes an OpenAI-compatible API. GPT-5.4+ / GPT-6 tool
 * calls use Responses when the endpoint supports it.
 *
 * Requires: `npm install openai`
 */
export declare class AzureFoundryProvider implements ModelProvider {
    readonly providerId = "azure-foundry";
    readonly modelId: string;
    constructor(modelId: string, config?: AzureFoundryConfig);
    generate(messages: ChatMessage[], options?: ModelConfig & {
        tools?: ToolDefinition[];
    }): Promise<ModelResponse>;
    stream(messages: ChatMessage[], options?: ModelConfig & {
        tools?: ToolDefinition[];
    }): AsyncGenerator<StreamChunk>;
}

export declare function azureOpenai(modelId: string, config?: AzureOpenAIConfig): ModelProvider;

export interface AzureOpenAIConfig {
    apiKey?: string;
    endpoint?: string;
    deployment?: string;
    apiVersion?: string;
}

/**
 * OpenAI models hosted on Azure via the `openai` SDK's `AzureOpenAI` class.
 *
 * GPT-5.4+ / GPT-6 tool calls go through Azure's Responses API when available,
 * and fall back to Chat Completions with `reasoning_effort: "none"`.
 *
 * Requires: `npm install openai`
 */
export declare class AzureOpenAIProvider implements ModelProvider {
    readonly providerId = "azure-openai";
    readonly modelId: string;
    constructor(modelId: string, config?: AzureOpenAIConfig);
    generate(messages: ChatMessage[], options?: ModelConfig & {
        tools?: ToolDefinition[];
    }): Promise<ModelResponse>;
    stream(messages: ChatMessage[], options?: ModelConfig & {
        tools?: ToolDefinition[];
    }): AsyncGenerator<StreamChunk>;
}

export interface ChatMessage {
    role: MessageRole;
    content: MessageContent | null;
    toolCalls?: ToolCall[];
    toolCallId?: string;
    name?: string;
    /**
     * Opaque provider payload replayed on the next request. Anthropic needs the
     * original `thinking` / `redacted_thinking` blocks (with signatures) before
     * `tool_use`; Gemini 2.5/3 needs `thoughtSignature` on function-call parts.
     * Dropping these 400s a tools + reasoning loop.
     */
    providerExtras?: Record<string, unknown>;
}

/** Lazy TypeSafe `choice()`, or the wire-format object if the SDK is not installed. */
export declare function choice(instructions: unknown, criteria: Record<string, unknown>): unknown;

export declare class CircuitBreaker {
    constructor(config?: Partial<CircuitBreakerConfig>);
    get state(): CircuitState;
    canAttempt(): boolean;
    recordSuccess(): void;
    recordFailure(error: unknown): ErrorClassification;
    reset(): void;
    get metrics(): {
        state: CircuitState;
        failureCount: number;
        lastFailureTime: number;
    };
}

export interface CircuitBreakerConfig {
    failureThreshold: number;
    cooldownMs: number;
    halfOpenMaxAttempts: number;
    classifyError?: (error: unknown) => ErrorClassification;
}

export type CircuitState = "closed" | "open" | "half-open";

export declare function classifyComplexity(messages: ChatMessage[], options?: ModelConfig & {
    tools?: ToolDefinition[];
}): number;

export declare function cohere(modelId: string, config?: CohereConfig): ModelProvider;

export interface CohereConfig {
    apiKey?: string;
}

/**
 * Cohere provider using the `cohere-ai` SDK (v2 Chat API).
 *
 * Falls back to the `openai` SDK pointed at Cohere's OpenAI-compatible
 * endpoint if the native SDK is not installed.
 */
export declare class CohereProvider implements ModelProvider {
    readonly providerId = "cohere";
    readonly modelId: string;
    constructor(modelId: string, config?: CohereConfig);
    generate(messages: ChatMessage[], options?: ModelConfig & {
        tools?: ToolDefinition[];
    }): Promise<ModelResponse>;
    stream(messages: ChatMessage[], options?: ModelConfig & {
        tools?: ToolDefinition[];
    }): AsyncGenerator<StreamChunk>;
}

export type ContentPart = TextPart | ImagePart | AudioPart | FilePart;

export declare function deepseek(modelId: string, config?: DeepSeekConfig): ModelProvider;

export type DeepSeekConfig = OpenAICompatibleConfig;

export declare class DeepSeekProvider extends OpenAICompatibleProvider implements ModelProvider {
    constructor(modelId: string, config?: DeepSeekConfig);
}

export declare function defaultClassifyError(error: unknown): ErrorClassification;

export type ErrorClassification = "retry" | "cascade" | "fatal";

export declare class FallbackProvider implements ModelProvider {
    readonly providerId = "fallback";
    readonly modelId: string;
    constructor(config: FallbackProviderConfig);
    generate(messages: ChatMessage[], options?: ModelConfig & {
        tools?: ToolDefinition[];
    }): Promise<ModelResponse>;
    stream(messages: ChatMessage[], options?: ModelConfig & {
        tools?: ToolDefinition[];
    }): AsyncGenerator<StreamChunk>;
    getBreaker(providerKey: string): CircuitBreaker | undefined;
    get providerKeys(): string[];
    resetAll(): void;
}

export interface FallbackProviderConfig {
    providers: ModelProvider[];
    circuitBreaker?: Partial<CircuitBreakerConfig>;
    onFallback?: (from: string, to: string, error: unknown) => void;
}

export interface FilePart {
    type: "file";
    /** Base64-encoded file data OR a URL. */
    data: string;
    mimeType: string;
    filename?: string;
}

/**
 * Shorthand for `new GoogleVisionLiveProvider(modelId, config)`.
 *
 * @example
 * const agent = new VisionAgent({
 *   provider: geminiVisionLive(),
 * });
 */
export declare function geminiVisionLive(modelId?: string, config?: GoogleVisionLiveConfig): VisionProvider;

/** Extract the text content from a MessageContent value. */
export declare function getTextContent(content: MessageContent | null): string;

export declare function google(modelId: string, config?: {
    apiKey?: string;
}): ModelProvider;

/**
 * Shorthand for `new GoogleLiveProvider(modelId, config)`.
 *
 * @example
 * const agent = new VoiceAgent({
 *   provider: googleLive(),
 * });
 */
export declare function googleLive(modelId?: string, config?: GoogleLiveConfig): RealtimeProvider;

export declare class GoogleProvider implements ModelProvider {
    readonly providerId = "google";
    readonly modelId: string;
    constructor(modelId: string, config?: GoogleConfig);
    generate(messages: ChatMessage[], options?: ModelConfig & {
        tools?: ToolDefinition[];
    }): Promise<ModelResponse>;
    stream(messages: ChatMessage[], options?: ModelConfig & {
        tools?: ToolDefinition[];
    }): AsyncGenerator<StreamChunk>;
}

export interface ImagePart {
    type: "image";
    /** Base64-encoded image data OR a URL. */
    data: string;
    mimeType?: "image/png" | "image/jpeg" | "image/gif" | "image/webp";
}

/** Check if content has multi-modal parts. */
export declare function isMultiModal(content: MessageContent | null): content is ContentPart[];

/**
 * Jev (TypeSafe System One). Not a chat model — pass `questions`,
 * `structuredOutput`, or closed-set tools.
 *
 * @example
 * ```ts
 * const agent = new Agent({ name: "triage", model: jev("jev-latest") });
 * await agent.run(ticket, { questions: { urgent: noul("Is this urgent?") } });
 * ```
 */
export declare function jev(modelId?: string, config?: JevConfig): ModelProvider;

export interface JevConfig {
    /** TypeSafe API key. Falls back to `TYPESAFE_API_KEY`. */
    apiKey?: string;
    /** TypeSafe API root. Falls back to `TYPESAFE_BASE_URL`, then `https://api.typesafe.ai`. */
    baseURL?: string;
    /**
     * Default TypeSafe questions (`choice` / `noul` / `score`).
     * Overridden by `agent.run(input, { questions })`.
     */
    questions?: JevQuestions;
}

/**
 * Jev (TypeSafe System One) — decisions, not chat.
 *
 * `generate()` maps messages → `state`, asks typed questions, and returns
 * JSON answers (or a single closed-set `tool_calls` finish).
 */
export declare class JevProvider implements ModelProvider {
    readonly providerId = "jev";
    readonly modelId: string;
    /** Tests assign a mock client here. */
    client: any;
    constructor(modelId?: string, config?: JevConfig);
    generate(messages: ChatMessage[], options?: ModelConfig & {
        tools?: ToolDefinition[];
    }): Promise<ModelResponse>;
    stream(messages: ChatMessage[], options?: ModelConfig & {
        tools?: ToolDefinition[];
    }): AsyncGenerator<StreamChunk>;
}

export type JevQuestions = Record<string, unknown>;

/** Convenience: plain string, or an array of multi-modal content parts. */
export type MessageContent = string | ContentPart[];

export type MessageRole = "system" | "user" | "assistant" | "tool";

export declare function meta(modelId: string, config?: MetaLlamaConfig): ModelProvider;

export type MetaLlamaConfig = OpenAICompatibleConfig;

export declare class MetaLlamaProvider extends OpenAICompatibleProvider implements ModelProvider {
    constructor(modelId: string, config?: MetaLlamaConfig);
}

export declare function mistral(modelId: string, config?: MistralConfig): ModelProvider;

export interface MistralConfig {
    apiKey?: string;
    baseURL?: string;
}

/**
 * Mistral provider using the `@mistralai/mistralai` SDK.
 *
 * Falls back to the `openai` SDK pointed at Mistral's OpenAI-compatible
 * endpoint (https://api.mistral.ai/v1) if the native SDK is not installed.
 */
export declare class MistralProvider implements ModelProvider {
    readonly providerId = "mistral";
    readonly modelId: string;
    constructor(modelId: string, config?: MistralConfig);
    generate(messages: ChatMessage[], options?: ModelConfig & {
        tools?: ToolDefinition[];
    }): Promise<ModelResponse>;
    stream(messages: ChatMessage[], options?: ModelConfig & {
        tools?: ToolDefinition[];
    }): AsyncGenerator<StreamChunk>;
}

export interface ModelConfig {
    /** Cooperative cancellation, forwarded by compatible providers. */
    signal?: AbortSignal;
    temperature?: number;
    maxTokens?: number;
    topP?: number;
    stop?: string[];
    responseFormat?: "text" | "json" | {
        type: "json_schema";
        schema: Record<string, unknown>;
        name?: string;
    };
    /** Per-request API key override. When provided, the provider uses this key instead of the one set at construction. */
    apiKey?: string;
    /** Enable extended thinking / reasoning. */
    reasoning?: ReasoningConfig;
    /** Provider-specific request options (cache, compaction, Gemini grounding). */
    providerOptions?: ProviderOptions;
    /**
     * Jev questions for this call (`choice` / `noul` / `score`).
     * Ignored by chat providers.
     */
    questions?: Record<string, unknown>;
}

export interface ModelProvider {
    readonly providerId: string;
    readonly modelId: string;
    generate(messages: ChatMessage[], options?: ModelConfig & {
        tools?: ToolDefinition[];
    }): Promise<ModelResponse>;
    stream(messages: ChatMessage[], options?: ModelConfig & {
        tools?: ToolDefinition[];
    }): AsyncGenerator<StreamChunk>;
}

export declare const modelRegistry: ModelRegistry;

export declare class ModelRegistry {
    register(providerId: string, factory: ProviderFactory): void;
    resolve(providerId: string, modelId: string, config?: any): ModelProvider;
    has(providerId: string): boolean;
}

export interface ModelResponse {
    message: ChatMessage;
    usage: TokenUsage;
    finishReason: "stop" | "tool_calls" | "length" | "content_filter";
    raw: unknown;
}

export declare class ModelRouter implements ModelProvider {
    readonly providerId = "router";
    readonly modelId: string;
    constructor(config: ModelRouterConfig);
    selectTier(messages: ChatMessage[], options?: ModelConfig & {
        tools?: ToolDefinition[];
    }): {
        tierIndex: number;
        complexity: number;
        model: ModelProvider;
    };
    generate(messages: ChatMessage[], options?: ModelConfig & {
        tools?: ToolDefinition[];
    }): Promise<ModelResponse>;
    stream(messages: ChatMessage[], options?: ModelConfig & {
        tools?: ToolDefinition[];
    }): AsyncGenerator<StreamChunk>;
    getOutcomeStats(): {
        tierIndex: number;
        total: number;
        successes: number;
        rate: number;
    }[];
}

export interface ModelRouterConfig {
    tiers: ModelTier[];
    classifier?: "builtin" | ModelProvider;
    fallbackTier?: number;
    rules?: RoutingRule[];
    outcomeTracking?: boolean;
}

export interface ModelTier {
    model: ModelProvider;
    maxComplexity: number;
}

/** Lazy TypeSafe `noul()`, or the wire-format object if the SDK is not installed. */
export declare function noul(instructions?: unknown, criteria?: unknown): unknown;

export declare function ollama(modelId: string, config?: {
    host?: string;
}): ModelProvider;

export declare class OllamaProvider implements ModelProvider {
    readonly providerId = "ollama";
    readonly modelId: string;
    constructor(modelId: string, config?: OllamaConfig);
    generate(messages: ChatMessage[], options?: ModelConfig & {
        tools?: ToolDefinition[];
    }): Promise<ModelResponse>;
    stream(messages: ChatMessage[], options?: ModelConfig & {
        tools?: ToolDefinition[];
    }): AsyncGenerator<StreamChunk>;
}

export declare function openai(modelId: string, config?: {
    apiKey?: string;
    baseURL?: string;
}): ModelProvider;

export interface OpenAICompatibleConfig {
    apiKey?: string;
    baseURL?: string;
}

/**
 * Generic provider for any API that follows the OpenAI Chat Completions
 * format. Subclasses only need to supply a `providerId`, default `baseURL`,
 * and the environment-variable name that holds the API key.
 *
 * GPT-5.4+ / GPT-6 with tools use `/v1/responses` when the gateway exposes it
 * (LiteLLM, OpenRouter, Azure). Otherwise Chat Completions gets
 * `reasoning_effort: "none"` so function tools do not 400.
 */
export declare class OpenAICompatibleProvider implements ModelProvider {
    readonly providerId: string;
    readonly modelId: string;
    constructor(providerId: string, modelId: string, defaults: ProviderDefaults, config?: OpenAICompatibleConfig);
    generate(messages: ChatMessage[], options?: ModelConfig & {
        tools?: ToolDefinition[];
    }): Promise<ModelResponse>;
    stream(messages: ChatMessage[], options?: ModelConfig & {
        tools?: ToolDefinition[];
    }): AsyncGenerator<StreamChunk>;
}

export declare class OpenAIProvider implements ModelProvider {
    readonly providerId = "openai";
    readonly modelId: string;
    constructor(modelId: string, config?: OpenAIConfig);
    generate(messages: ChatMessage[], options?: ModelConfig & {
        tools?: ToolDefinition[];
    }): Promise<ModelResponse>;
    stream(messages: ChatMessage[], options?: ModelConfig & {
        tools?: ToolDefinition[];
    }): AsyncGenerator<StreamChunk>;
}

/**
 * Shorthand for `new OpenAIRealtimeProvider(modelId, config)`.
 *
 * @example
 * const agent = new VoiceAgent({
 *   provider: openaiRealtime("gpt-realtime-2.1"),
 * });
 */
export declare function openaiRealtime(modelId?: string, config?: OpenAIRealtimeConfig): RealtimeProvider;

export declare function perplexity(modelId: string, config?: PerplexityConfig): ModelProvider;

export interface PerplexityConfig {
    apiKey?: string;
    baseURL?: string;
    /** Search-specific options (only available with the native SDK). */
    search?: PerplexitySearchOptions;
}

/**
 * Perplexity provider using the `@perplexity-ai/perplexity_ai` SDK.
 *
 * Falls back to the `openai` SDK pointed at Perplexity's OpenAI-compatible
 * endpoint (https://api.perplexity.ai) if the native SDK is not installed.
 *
 * The native SDK unlocks search-specific parameters (domain filtering,
 * recency, academic mode) and typed citation/source responses.
 */
export declare class PerplexityProvider implements ModelProvider {
    readonly providerId = "perplexity";
    readonly modelId: string;
    constructor(modelId: string, config?: PerplexityConfig);
    generate(messages: ChatMessage[], options?: ModelConfig & {
        tools?: ToolDefinition[];
    }): Promise<ModelResponse>;
    stream(messages: ChatMessage[], options?: ModelConfig & {
        tools?: ToolDefinition[];
    }): AsyncGenerator<StreamChunk>;
}

export interface PerplexitySearchOptions {
    /** Search mode: web (default), academic, or SEC filings. */
    searchMode?: "web" | "academic" | "sec";
    /** Restrict search to specific domains. */
    searchDomainFilter?: string[];
    /** Restrict search to a recent time window. */
    searchRecencyFilter?: "hour" | "day" | "week" | "month" | "year";
    /** Only return results after this date (YYYY-MM-DD). */
    searchAfterDate?: string;
    /** Only return results before this date (YYYY-MM-DD). */
    searchBeforeDate?: string;
    /** Return images in the response. */
    returnImages?: boolean;
    /** Return related questions. */
    returnRelatedQuestions?: boolean;
    /** Disable search entirely (use model as a pure LLM). */
    disableSearch?: boolean;
    /** Web search context size: low (default), medium, or high. */
    searchContextSize?: "low" | "medium" | "high";
}

export interface ReasoningConfig {
    enabled: boolean;
    /**
     * Reasoning effort for OpenAI-family models (o-series, GPT-5.x, GPT-6).
     * `none` keeps function tools on Chat Completions; any other value with
     * tools is sent through the Responses API on GPT-5.4+ / GPT-6.
     * Anthropic maps this onto `output_config.effort`. DeepSeek accepts `low` / `high` / `max`.
     */
    effort?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
    /** Token budget for thinking (Anthropic / Gemini / Cohere). */
    budgetTokens?: number;
    /** OpenAI Responses summary. Default `detailed`. */
    summary?: "auto" | "concise" | "detailed";
    /** GPT-5.6 / GPT-6 Responses execution mode. */
    mode?: "standard" | "pro";
    /** Which reasoning items later turns send back. Default is the model's own. */
    context?: "auto" | "current_turn" | "all_turns";
}

/** JSON-persistable Responses output; never expose opaque items as display text. */
export interface ResponsesReplayEnvelope {
    version: 1;
    /** Normalized endpoint origin/path; credentials and query strings are excluded. */
    owner: string;
    /** Model identity when produced by an adapter. Switching it needs an explicit new continuation. */
    model?: string;
    items: unknown[];
}

export interface RoutingRule {
    condition: (messages: ChatMessage[], options?: ModelConfig & {
        tools?: ToolDefinition[];
    }) => boolean;
    tier: number;
}

/** Lazy TypeSafe `score()`. Criteria is an ordered rubric of at least two levels. */
export declare function score(instructions: unknown, criteria: unknown[]): unknown;

export type StreamChunk = {
    type: "text";
    text: string;
} | {
    type: "thinking";
    text: string;
} | {
    type: "tool_call_start";
    toolCall: {
        id: string;
        name: string;
    };
} | {
    type: "tool_call_delta";
    toolCallId: string;
    argumentsDelta: string;
} | {
    type: "tool_call_end";
    toolCallId: string;
} | {
    type: "finish";
    finishReason: string;
    usage?: TokenUsage;
    providerExtras?: Record<string, unknown>;
};

export interface TextPart {
    type: "text";
    text: string;
}

export interface TokenUsage {
    promptTokens: number;
    completionTokens: number;
    totalTokens: number;
    reasoningTokens?: number;
    cachedTokens?: number;
    audioInputTokens?: number;
    audioOutputTokens?: number;
    /** Raw usage / metrics object returned by the underlying provider API (unmodified). */
    providerMetrics?: Record<string, unknown>;
}

export interface ToolCall {
    id: string;
    name: string;
    arguments: Record<string, unknown>;
}

export interface ToolDefinition {
    name: string;
    description: string;
    parameters: Record<string, unknown>;
    strict?: boolean;
}

export declare function vercel(modelId: string, config?: VercelConfig): ModelProvider;

export type VercelConfig = OpenAICompatibleConfig;

export declare class VercelProvider extends OpenAICompatibleProvider implements ModelProvider {
    constructor(modelId: string, config?: VercelConfig);
}

export declare function vertex(modelId: string, config?: {
    project?: string;
    location?: string;
    credentials?: string;
}): ModelProvider;

export interface VertexAIConfig {
    project?: string;
    location?: string;
    /** Service account key JSON string or path (optional — uses ADC by default). */
    credentials?: string;
}

/**
 * Vertex AI provider using Google's @google/genai SDK in Vertex mode.
 *
 * Authentication (in order of precedence):
 *   1. Explicit `project` + `location` in config
 *   2. GOOGLE_CLOUD_PROJECT / GOOGLE_CLOUD_LOCATION env vars
 *   3. Application Default Credentials (gcloud auth)
 */
export declare class VertexAIProvider implements ModelProvider {
    readonly providerId = "vertex";
    readonly modelId: string;
    constructor(modelId: string, config?: VertexAIConfig);
    generate(messages: ChatMessage[], options?: ModelConfig & {
        tools?: ToolDefinition[];
    }): Promise<ModelResponse>;
    stream(messages: ChatMessage[], options?: ModelConfig & {
        tools?: ToolDefinition[];
    }): AsyncGenerator<StreamChunk>;
}

export declare function withFallback(providers: ModelProvider[], config?: Omit<FallbackProviderConfig, "providers">): FallbackProvider;

export declare function xai(modelId: string, config?: XAIConfig): ModelProvider;

export type XAIConfig = OpenAICompatibleConfig;

export declare class XAIProvider extends OpenAICompatibleProvider implements ModelProvider {
    constructor(modelId: string, config?: XAIConfig);
}

interface AnthropicConfig {
    apiKey?: string;
}

interface GoogleConfig {
    apiKey?: string;
}

/** Provider request options that are not shared sampling knobs. */
export interface ProviderOptions {
    /** Anthropic: cache the system prompt (`cache_control: ephemeral`). */
    promptCache?: boolean;
    /** OpenAI Responses `prompt_cache_retention`. */
    promptCacheRetention?: "in_memory" | "24h";
    /**
     * Anthropic server compaction once input exceeds this many tokens.
     * Values under 50000 are raised to 50000. Requires the compaction beta.
     */
    compactionTokens?: number;
    /** Anthropic: clear old tool results server-side. Requires the context-management beta. */
    clearToolResults?: boolean;
    /** Gemini media token budget. */
    mediaResolution?: "low" | "medium" | "high" | "ultra_high";
    /** Gemini explicit cache resource name (`cachedContents/...`). */
    cachedContent?: string;
    /** Gemini Google Search grounding tool. */
    googleSearch?: boolean;
}

type ProviderFactory = (modelId: string, config?: any) => ModelProvider;

interface OllamaConfig {
    host?: string;
}

interface ProviderDefaults {
    baseURL: string;
    apiKeyEnvVar: string;
}

interface OpenAIConfig {
    apiKey?: string;
    baseURL?: string;
}