@amux.ai/llm-bridge 0.2.0

package/dist/index.d.cts

@@ -0,0 +1,1328 @@
+/**
+ * Message role types
+ */
+type Role = 'system' | 'user' | 'assistant' | 'tool';
+/**
+ * Text content part
+ */
+interface TextContent {
+    type: 'text';
+    text: string;
+}
+/**
+ * Image source types
+ */
+type ImageSource = {
+    type: 'url';
+    url: string;
+} | {
+    type: 'base64';
+    mediaType: string;
+    data: string;
+};
+/**
+ * Image content part
+ */
+interface ImageContent {
+    type: 'image';
+    source: ImageSource;
+}
+/**
+ * Content part union type
+ * Note: Tool calls use OpenAI-style toolCalls field on Message, not content parts
+ */
+type ContentPart = TextContent | ImageContent;
+/**
+ * Message content can be a string or an array of content parts
+ */
+type MessageContent = string | ContentPart[];
+/**
+ * Tool call (OpenAI-style)
+ * This is the unified format for tool calls in IR
+ */
+interface ToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+/**
+ * Message structure supporting multimodal content
+ */
+interface Message {
+    role: Role;
+    content: MessageContent;
+    name?: string;
+    /**
+     * Tool call ID (for tool role messages - tool results)
+     * When role is 'tool', this identifies which tool call this is a response to
+     */
+    toolCallId?: string;
+    /**
+     * Tool calls made by the assistant (OpenAI-style)
+     * When role is 'assistant' and the model wants to call tools
+     */
+    toolCalls?: ToolCall[];
+    /**
+     * Reasoning/thinking content (DeepSeek, Qwen QwQ, Anthropic extended thinking)
+     * Contains the model's chain-of-thought reasoning process
+     */
+    reasoningContent?: string;
+}
+
+/**
+ * JSON Schema definition
+ */
+interface JSONSchema {
+    type: string;
+    properties?: Record<string, unknown>;
+    required?: string[];
+    additionalProperties?: boolean;
+    description?: string;
+    [key: string]: unknown;
+}
+/**
+ * Function definition
+ */
+interface FunctionDefinition {
+    name: string;
+    description?: string;
+    parameters?: JSONSchema;
+    strict?: boolean;
+}
+/**
+ * Tool definition
+ */
+interface Tool {
+    type: 'function';
+    function: FunctionDefinition;
+}
+/**
+ * Tool choice options
+ */
+type ToolChoice = 'auto' | 'none' | 'required' | {
+    type: 'function';
+    function: {
+        name: string;
+    };
+};
+
+/**
+ * Response format configuration
+ */
+interface ResponseFormat {
+    /**
+     * Response type: 'text' | 'json_object' | 'json_schema'
+     */
+    type: 'text' | 'json_object' | 'json_schema';
+    /**
+     * JSON schema for structured output (when type is 'json_schema')
+     */
+    jsonSchema?: {
+        name: string;
+        description?: string;
+        schema: Record<string, unknown>;
+        strict?: boolean;
+    };
+}
+/**
+ * Thinking/reasoning configuration
+ * Supported by: DeepSeek, Qwen, Anthropic (extended thinking)
+ */
+interface ThinkingConfig {
+    /**
+     * Enable thinking/reasoning mode
+     */
+    enabled: boolean;
+    /**
+     * Budget tokens for thinking (Anthropic)
+     */
+    budgetTokens?: number;
+}
+/**
+ * Generation configuration parameters
+ */
+interface GenerationConfig {
+    /**
+     * Temperature (0-2, typically 0-1)
+     * Higher values make output more random
+     */
+    temperature?: number;
+    /**
+     * Top-p sampling (nucleus sampling)
+     * Alternative to temperature
+     */
+    topP?: number;
+    /**
+     * Top-k sampling
+     * Only consider top k tokens
+     */
+    topK?: number;
+    /**
+     * Maximum tokens to generate
+     */
+    maxTokens?: number;
+    /**
+     * Stop sequences
+     * Generation stops when any of these sequences is encountered
+     */
+    stopSequences?: string[];
+    /**
+     * Presence penalty (-2.0 to 2.0)
+     * Positive values penalize new tokens based on whether they appear in the text so far
+     */
+    presencePenalty?: number;
+    /**
+     * Frequency penalty (-2.0 to 2.0)
+     * Positive values penalize new tokens based on their frequency in the text so far
+     */
+    frequencyPenalty?: number;
+    /**
+     * Number of completions to generate
+     */
+    n?: number;
+    /**
+     * Seed for deterministic generation
+     */
+    seed?: number;
+    /**
+     * Response format configuration
+     */
+    responseFormat?: ResponseFormat;
+    /**
+     * Thinking/reasoning configuration
+     * Supported by: DeepSeek (deepseek-reasoner), Qwen (QwQ), Anthropic (extended thinking)
+     */
+    thinking?: ThinkingConfig;
+    /**
+     * Enable web search (Qwen specific)
+     */
+    enableSearch?: boolean;
+    /**
+     * Log probabilities configuration
+     */
+    logprobs?: boolean;
+    /**
+     * Number of top log probabilities to return
+     */
+    topLogprobs?: number;
+}
+
+/**
+ * Unified Intermediate Representation for LLM Requests
+ * This is the core data structure that all adapters convert to/from
+ */
+interface LLMRequestIR {
+    /**
+     * Conversation messages
+     * Supports multi-turn dialogue with role-based messages
+     */
+    messages: Message[];
+    /**
+     * Model identifier (optional in IR, may be determined by router)
+     */
+    model?: string;
+    /**
+     * Tools/Functions available for the model to call
+     */
+    tools?: Tool[];
+    /**
+     * Tool choice strategy
+     */
+    toolChoice?: ToolChoice;
+    /**
+     * Streaming configuration
+     */
+    stream?: boolean;
+    /**
+     * Generation parameters
+     */
+    generation?: GenerationConfig;
+    /**
+     * System prompt (some providers use separate field)
+     */
+    system?: string;
+    /**
+     * Metadata for tracking and routing
+     */
+    metadata?: {
+        requestId?: string;
+        userId?: string;
+        sessionId?: string;
+        tags?: string[];
+        [key: string]: unknown;
+    };
+    /**
+     * Provider-specific extensions
+     * Allows passthrough of vendor-specific features
+     */
+    extensions?: {
+        [provider: string]: unknown;
+    };
+    /**
+     * Raw original request (for debugging/logging)
+     */
+    raw?: unknown;
+}
+
+/**
+ * Finish reason types
+ */
+type FinishReason = 'stop' | 'length' | 'tool_calls' | 'content_filter' | 'error';
+/**
+ * Token usage statistics
+ */
+interface Usage {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+    /**
+     * Detailed token breakdown (provider-specific)
+     */
+    details?: {
+        /**
+         * Reasoning/thinking tokens (DeepSeek, Qwen)
+         */
+        reasoningTokens?: number;
+        /**
+         * Cached prompt tokens (DeepSeek, Anthropic)
+         */
+        cachedTokens?: number;
+        /**
+         * Cache creation tokens (Anthropic)
+         */
+        cacheCreationTokens?: number;
+        /**
+         * Cache read tokens (Anthropic)
+         */
+        cacheReadTokens?: number;
+    };
+}
+/**
+ * Response choice
+ */
+interface Choice {
+    index: number;
+    message: Message;
+    finishReason?: FinishReason;
+    /**
+     * Log probabilities (if requested)
+     */
+    logprobs?: {
+        content?: Array<{
+            token: string;
+            logprob: number;
+            topLogprobs?: Array<{
+                token: string;
+                logprob: number;
+            }>;
+        }>;
+    };
+}
+/**
+ * Unified response structure
+ */
+interface LLMResponseIR {
+    /**
+     * Response ID
+     */
+    id: string;
+    /**
+     * Model used
+     */
+    model: string;
+    /**
+     * Generated message(s)
+     */
+    choices: Choice[];
+    /**
+     * Token usage statistics
+     */
+    usage?: Usage;
+    /**
+     * Response creation timestamp
+     */
+    created?: number;
+    /**
+     * System fingerprint (for reproducibility)
+     */
+    systemFingerprint?: string;
+    /**
+     * Metadata
+     */
+    metadata?: {
+        requestId?: string;
+        [key: string]: unknown;
+    };
+    /**
+     * Provider-specific extensions
+     */
+    extensions?: {
+        [provider: string]: unknown;
+    };
+    /**
+     * Raw original response (for debugging/logging)
+     */
+    raw?: unknown;
+}
+
+/**
+ * Stream event types
+ */
+type StreamEventType = 'start' | 'content' | 'reasoning' | 'tool_call' | 'end' | 'error';
+/**
+ * Content delta
+ */
+interface ContentDelta {
+    type: 'content';
+    delta: string;
+    index?: number;
+}
+/**
+ * Reasoning content delta (DeepSeek, Qwen, Anthropic)
+ */
+interface ReasoningDelta {
+    type: 'reasoning';
+    delta: string;
+    index?: number;
+}
+/**
+ * Tool call delta
+ */
+interface ToolCallDelta {
+    type: 'tool_call';
+    id?: string;
+    name?: string;
+    arguments?: string;
+    index?: number;
+}
+/**
+ * Stream event
+ */
+interface LLMStreamEvent {
+    /**
+     * Event type
+     */
+    type: StreamEventType;
+    /**
+     * Event ID
+     */
+    id?: string;
+    /**
+     * Model used
+     */
+    model?: string;
+    /**
+     * Content delta
+     */
+    content?: ContentDelta;
+    /**
+     * Reasoning/thinking content delta
+     */
+    reasoning?: ReasoningDelta;
+    /**
+     * Tool call delta
+     */
+    toolCall?: ToolCallDelta;
+    /**
+     * Finish reason (for end event)
+     */
+    finishReason?: FinishReason;
+    /**
+     * Complete message (for end event)
+     */
+    message?: Message;
+    /**
+     * Usage statistics (for end event, if stream_options.include_usage is true)
+     */
+    usage?: Usage;
+    /**
+     * Error (for error event)
+     */
+    error?: {
+        message: string;
+        code?: string;
+        [key: string]: unknown;
+    };
+    /**
+     * Raw original event (for debugging)
+     */
+    raw?: unknown;
+}
+/**
+ * SSE (Server-Sent Events) event for streaming responses
+ * This is the formatted event that can be directly written to HTTP response
+ */
+interface SSEEvent {
+    /**
+     * Event type (e.g., 'message_start', 'content_block_delta', 'data')
+     */
+    event: string;
+    /**
+     * Event data payload
+     */
+    data: unknown;
+}
+
+/**
+ * Error types
+ */
+type ErrorType = 'network' | 'api' | 'validation' | 'rate_limit' | 'authentication' | 'permission' | 'not_found' | 'server' | 'unknown';
+/**
+ * Unified error structure
+ */
+interface LLMErrorIR {
+    /**
+     * Error type
+     */
+    type: ErrorType;
+    /**
+     * Error message
+     */
+    message: string;
+    /**
+     * Error code (provider-specific)
+     */
+    code?: string;
+    /**
+     * HTTP status code
+     */
+    status?: number;
+    /**
+     * Whether the error is retryable
+     */
+    retryable?: boolean;
+    /**
+     * Additional error details
+     */
+    details?: {
+        [key: string]: unknown;
+    };
+    /**
+     * Original error (for debugging)
+     */
+    raw?: unknown;
+}
+
+/**
+ * Provider endpoint configuration
+ */
+interface ProviderEndpoint {
+    /**
+     * Base URL for the API
+     */
+    baseUrl: string;
+    /**
+     * Chat completions path (default: '/v1/chat/completions')
+     */
+    chatPath?: string;
+    /**
+     * Models list path (default: '/v1/models')
+     */
+    modelsPath?: string;
+}
+/**
+ * Adapter capabilities
+ */
+interface AdapterCapabilities {
+    /**
+     * Supports streaming
+     */
+    streaming: boolean;
+    /**
+     * Supports tool/function calling
+     */
+    tools: boolean;
+    /**
+     * Supports vision (image input)
+     */
+    vision: boolean;
+    /**
+     * Supports multimodal content (images, audio, video, documents)
+     */
+    multimodal: boolean;
+    /**
+     * Supports system prompt
+     */
+    systemPrompt: boolean;
+    /**
+     * Supports tool choice
+     */
+    toolChoice: boolean;
+    /**
+     * Supports reasoning/thinking mode (DeepSeek, Qwen QwQ, Anthropic)
+     */
+    reasoning?: boolean;
+    /**
+     * Supports web search (Qwen)
+     */
+    webSearch?: boolean;
+    /**
+     * Supports JSON mode / structured output
+     */
+    jsonMode?: boolean;
+    /**
+     * Supports log probabilities
+     */
+    logprobs?: boolean;
+    /**
+     * Supports seed for reproducibility
+     */
+    seed?: boolean;
+}
+/**
+ * Validation result
+ */
+interface ValidationResult {
+    valid: boolean;
+    errors?: string[];
+    warnings?: string[];
+}
+/**
+ * Adapter information
+ */
+interface AdapterInfo {
+    name: string;
+    version: string;
+    capabilities: AdapterCapabilities;
+    /**
+     * Default endpoint configuration
+     */
+    endpoint?: ProviderEndpoint;
+}
+
+/**
+ * Stream handler function
+ */
+type StreamHandler = (chunk: unknown) => LLMStreamEvent | LLMStreamEvent[] | null;
+/**
+ * Error handler function
+ */
+type ErrorHandler = (error: unknown) => LLMErrorIR;
+/**
+ * Stream event builder interface
+ * Handles stateful conversion of IR stream events to provider-specific SSE events
+ */
+interface StreamEventBuilder {
+    /**
+     * Process an IR stream event and return SSE events
+     * May return multiple events (e.g., message_start + content_block_start)
+     * May return empty array if no events should be emitted
+     */
+    process(event: LLMStreamEvent): SSEEvent[];
+    /**
+     * Get any final events that should be emitted when the stream ends
+     * Called after all events have been processed
+     */
+    finalize?(): SSEEvent[];
+}
+/**
+ * LLM Adapter interface
+ * Defines the contract for bidirectional conversion between provider formats and IR
+ */
+interface LLMAdapter {
+    /**
+     * Adapter name (e.g., 'openai', 'anthropic')
+     */
+    readonly name: string;
+    /**
+     * Adapter version
+     */
+    readonly version: string;
+    /**
+     * Adapter capabilities
+     */
+    readonly capabilities: AdapterCapabilities;
+    /**
+     * Inbound conversion (Provider format → IR)
+     */
+    inbound: {
+        /**
+         * Parse provider request to IR
+         */
+        parseRequest(request: unknown): LLMRequestIR;
+        /**
+         * Parse provider response to IR
+         */
+        parseResponse?(response: unknown): LLMResponseIR;
+        /**
+         * Parse provider stream chunk to IR stream event
+         */
+        parseStream?(chunk: unknown): LLMStreamEvent | LLMStreamEvent[] | null;
+        /**
+         * Parse provider error to IR error
+         */
+        parseError?(error: unknown): LLMErrorIR;
+    };
+    /**
+     * Outbound conversion (IR → Provider format)
+     */
+    outbound: {
+        /**
+         * Build provider request from IR
+         */
+        buildRequest(ir: LLMRequestIR): unknown;
+        /**
+         * Build provider response from IR
+         */
+        buildResponse?(ir: LLMResponseIR): unknown;
+        /**
+         * Build provider stream event from IR stream event
+         */
+        buildStreamEvent?(ir: LLMStreamEvent): unknown;
+        /**
+         * Get stream handler for provider
+         */
+        buildStreamHandler?(): StreamHandler;
+        /**
+         * Get error handler for provider
+         */
+        buildErrorHandler?(): ErrorHandler;
+        /**
+         * Create a stream event builder for converting IR events to provider SSE format
+         * The builder maintains state for proper event sequencing (e.g., tracking content blocks)
+         */
+        createStreamBuilder?(): StreamEventBuilder;
+    };
+    /**
+     * Validate IR request for this adapter
+     */
+    validateRequest?(ir: LLMRequestIR): ValidationResult;
+    /**
+     * Check if adapter supports a specific capability
+     */
+    supportsCapability?(capability: keyof AdapterCapabilities): boolean;
+    /**
+     * Get adapter information
+     */
+    getInfo(): AdapterInfo;
+}
+
+/**
+ * Adapter registry for managing adapters
+ */
+declare class AdapterRegistry {
+    private adapters;
+    /**
+     * Register an adapter
+     */
+    register(adapter: LLMAdapter): void;
+    /**
+     * Unregister an adapter
+     */
+    unregister(name: string): boolean;
+    /**
+     * Get an adapter by name
+     */
+    get(name: string): LLMAdapter | undefined;
+    /**
+     * Check if an adapter is registered
+     */
+    has(name: string): boolean;
+    /**
+     * List all registered adapters
+     */
+    list(): AdapterInfo[];
+    /**
+     * Clear all adapters
+     */
+    clear(): void;
+}
+/**
+ * Global adapter registry instance
+ */
+declare const globalRegistry: AdapterRegistry;
+
+/**
+ * Bridge configuration
+ */
+interface BridgeConfig {
+    /**
+     * API key for the target provider
+     */
+    apiKey: string;
+    /**
+     * Base URL for the target provider API
+     * Overrides adapter's default baseUrl
+     */
+    baseURL?: string;
+    /**
+     * Custom chat endpoint path
+     * Overrides adapter's default chatPath
+     * Example: '/v1/chat/completions', '/responses'
+     */
+    chatPath?: string;
+    /**
+     * Custom models endpoint path
+     * Overrides adapter's default modelsPath
+     * Example: '/v1/models', '/models'
+     */
+    modelsPath?: string;
+    /**
+     * Request timeout in milliseconds
+     */
+    timeout?: number;
+    /**
+     * Maximum number of retries for failed requests
+     */
+    maxRetries?: number;
+    /**
+     * Custom headers
+     */
+    headers?: Record<string, string>;
+    /**
+     * Authentication header name (default: 'Authorization')
+     */
+    authHeaderName?: string;
+    /**
+     * Authentication header prefix (default: 'Bearer')
+     * Set to empty string if no prefix is needed
+     */
+    authHeaderPrefix?: string;
+    /**
+     * Additional provider-specific options
+     */
+    [key: string]: unknown;
+}
+/**
+ * Bridge lifecycle hooks
+ *
+ * Hooks allow external code to intercept and observe the Bridge's request/response flow
+ * at the IR (Intermediate Representation) layer, where all data is in a unified format.
+ *
+ * Use cases:
+ * - Logging and monitoring (track token usage, latency, errors)
+ * - Cost tracking (calculate costs based on token usage)
+ * - Debugging and tracing (inspect IR transformations)
+ * - Rate limiting and alerting (implement usage-based limits)
+ * - Audit logging (record all LLM API calls)
+ */
+interface BridgeHooks {
+    /**
+     * Called after parsing the inbound request into IR, before building the outbound request
+     *
+     * @param ir - The unified request IR
+     * @returns void or Promise<void>
+     *
+     * @example
+     * ```typescript
+     * onRequest: async (ir) => {
+     *   console.log(`Request to model: ${ir.model}`)
+     *   console.log(`Message count: ${ir.messages.length}`)
+     * }
+     * ```
+     */
+    onRequest?: (ir: LLMRequestIR) => void | Promise<void>;
+    /**
+     * Called after parsing the provider response into IR, before building the final response
+     *
+     * This is the ideal place to extract metadata like token usage, as all providers'
+     * responses have been normalized to the same IR format.
+     *
+     * @param ir - The unified response IR
+     * @returns void or Promise<void>
+     *
+     * @example
+     * ```typescript
+     * onResponse: async (ir) => {
+     *   if (ir.usage) {
+     *     console.log(`Input tokens: ${ir.usage.promptTokens}`)
+     *     console.log(`Output tokens: ${ir.usage.completionTokens}`)
+     *     await recordTokenUsage(ir.usage)
+     *   }
+     * }
+     * ```
+     */
+    onResponse?: (ir: LLMResponseIR) => void | Promise<void>;
+    /**
+     * Called for each streaming event after parsing into IR, before building the SSE event
+     *
+     * @param event - The unified stream event IR
+     * @returns void or Promise<void>
+     *
+     * @example
+     * ```typescript
+     * onStreamEvent: async (event) => {
+     *   if (event.type === 'end' && event.usage) {
+     *     await recordTokenUsage(event.usage)
+     *   }
+     * }
+     * ```
+     */
+    onStreamEvent?: (event: LLMStreamEvent) => void | Promise<void>;
+    /**
+     * Called when an error occurs during the request/response flow
+     *
+     * @param error - The unified error IR
+     * @returns void or Promise<void>
+     *
+     * @example
+     * ```typescript
+     * onError: async (error) => {
+     *   console.error(`Bridge error: ${error.message}`)
+     *   await logError(error)
+     * }
+     * ```
+     */
+    onError?: (error: LLMErrorIR) => void | Promise<void>;
+}
+/**
+ * Bridge options
+ */
+interface BridgeOptions {
+    /**
+     * Inbound adapter (parses incoming requests)
+     */
+    inbound: LLMAdapter;
+    /**
+     * Outbound adapter (builds outgoing requests)
+     */
+    outbound: LLMAdapter;
+    /**
+     * Configuration for the target provider
+     */
+    config: BridgeConfig;
+    /**
+     * Lifecycle hooks for intercepting IR-level events
+     *
+     * Hooks are called at key points in the request/response flow, allowing
+     * external code to observe and react to events at the IR layer where all
+     * data is in a unified format.
+     *
+     * @example
+     * ```typescript
+     * const bridge = createBridge({
+     *   inbound: openaiAdapter,
+     *   outbound: anthropicAdapter,
+     *   config: { apiKey: '...' },
+     *   hooks: {
+     *     onResponse: async (ir) => {
+     *       // Track token usage in unified format
+     *       await recordTokens({
+     *         input: ir.usage?.promptTokens ?? 0,
+     *         output: ir.usage?.completionTokens ?? 0
+     *       })
+     *     }
+     *   }
+     * })
+     * ```
+     */
+    hooks?: BridgeHooks;
+    /**
+     * Fixed target model (highest priority)
+     * If set, ignores the inbound model and always uses this model
+     */
+    targetModel?: string;
+    /**
+     * Model mapping function (second priority)
+     * Receives the inbound model name and returns the outbound model name
+     */
+    modelMapper?: (inboundModel: string) => string;
+    /**
+     * Model mapping table (third priority)
+     * Maps inbound model names to outbound model names
+     */
+    modelMapping?: {
+        [inboundModel: string]: string;
+    };
+}
+/**
+ * Compatibility report
+ */
+interface CompatibilityReport {
+    compatible: boolean;
+    issues?: string[];
+    warnings?: string[];
+}
+/**
+ * Amux Bridge interface
+ */
+interface LLMBridge {
+    /**
+     * Send a chat request
+     * Returns response in inbound adapter's format
+     */
+    chat(request: unknown): Promise<unknown>;
+    /**
+     * Send a chat request (raw IR response)
+     * Returns raw IR response for custom processing
+     * Use this when you need to access the IR directly
+     */
+    chatRaw(request: unknown): Promise<LLMResponseIR>;
+    /**
+     * Send a streaming chat request
+     * Returns SSE events in inbound adapter's format
+     * This is the recommended method for streaming - events can be directly written to HTTP response
+     */
+    chatStream(request: unknown): AsyncIterable<SSEEvent>;
+    /**
+     * Send a streaming chat request (raw IR events)
+     * Returns raw IR stream events for custom processing
+     * Use this when you need to customize the stream handling
+     */
+    chatStreamRaw(request: unknown): AsyncIterable<LLMStreamEvent>;
+    /**
+     * List available models from the provider
+     * Returns the raw model list response from the provider
+     */
+    listModels(): Promise<unknown>;
+    /**
+     * Check compatibility between inbound and outbound adapters
+     */
+    checkCompatibility(): CompatibilityReport;
+    /**
+     * Get adapter information
+     */
+    getAdapters(): {
+        inbound: {
+            name: string;
+            version: string;
+        };
+        outbound: {
+            name: string;
+            version: string;
+        };
+    };
+}
+/**
+ * HTTP request options
+ */
+interface HTTPRequestOptions {
+    method: string;
+    url: string;
+    headers?: Record<string, string>;
+    body?: unknown;
+    timeout?: number;
+    signal?: AbortSignal;
+}
+/**
+ * HTTP response
+ */
+interface HTTPResponse<T = unknown> {
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    data: T;
+}
+
+/**
+ * Bridge implementation
+ */
+declare class Bridge implements LLMBridge {
+    private inboundAdapter;
+    private outboundAdapter;
+    private config;
+    private httpClient;
+    private hooks?;
+    private targetModel?;
+    private modelMapper?;
+    private modelMapping?;
+    constructor(options: BridgeOptions);
+    /**
+     * Map model name from inbound to outbound
+     * Priority: targetModel > modelMapper > modelMapping > original model
+     */
+    private mapModel;
+    /**
+     * Validate that the IR request features are supported by outbound adapter
+     * @private
+     */
+    private validateCapabilities;
+    /**
+     * Send a chat request
+     */
+    chat(request: unknown): Promise<unknown>;
+    /**
+     * Send a chat request (raw IR response)
+     * Returns raw IR response for custom processing
+     */
+    chatRaw(request: unknown): Promise<LLMResponseIR>;
+    /**
+     * Send a streaming chat request
+     * Returns SSE events in inbound adapter's format
+     */
+    chatStream(request: unknown): AsyncIterable<SSEEvent>;
+    /**
+     * Send a streaming chat request (raw IR events)
+     * Returns raw IR stream events for custom processing
+     */
+    chatStreamRaw(request: unknown): AsyncIterable<LLMStreamEvent>;
+    /**
+     * Process SSE lines and yield stream events
+     * @private
+     */
+    private processSSELines;
+    /**
+     * List available models from the provider
+     */
+    listModels(): Promise<unknown>;
+    /**
+     * Check compatibility between adapters
+     */
+    checkCompatibility(): CompatibilityReport;
+    /**
+     * Get adapter information
+     */
+    getAdapters(): {
+        inbound: {
+            name: string;
+            version: string;
+        };
+        outbound: {
+            name: string;
+            version: string;
+        };
+    };
+    /**
+     * Get default base URL from outbound adapter
+     * Note: config.baseURL is checked before calling this method
+     */
+    private getDefaultBaseURL;
+    /**
+     * Get chat endpoint path
+     * Supports dynamic model replacement for endpoints like /v1beta/models/{model}:generateContent
+     * Priority: config.chatPath > adapter.endpoint.chatPath
+     */
+    private getEndpoint;
+    /**
+     * Get models endpoint path
+     * Priority: config.modelsPath > adapter.endpoint.modelsPath
+     */
+    private getModelsPath;
+}
+
+/**
+ * Create a new Amux Bridge instance
+ *
+ * @example
+ * ```typescript
+ * import { createBridge } from '@amux.ai/llm-bridge'
+ * import { openaiAdapter } from '@amux.ai/adapter-openai'
+ * import { anthropicAdapter } from '@amux.ai/adapter-anthropic'
+ *
+ * const bridge = createBridge({
+ *   inbound: openaiAdapter,
+ *   outbound: anthropicAdapter,
+ *   config: {
+ *     apiKey: process.env.ANTHROPIC_API_KEY,
+ *   }
+ * })
+ *
+ * const response = await bridge.chat({
+ *   model: 'gpt-4',
+ *   messages: [{ role: 'user', content: 'Hello!' }]
+ * })
+ * ```
+ */
+declare function createBridge(options: BridgeOptions): LLMBridge;
+
+/**
+ * Simple HTTP client for making requests to LLM APIs
+ */
+declare class HTTPClient {
+    private defaultHeaders;
+    private defaultTimeout;
+    private maxRetries;
+    private provider;
+    private maxResponseSize;
+    constructor(options?: {
+        headers?: Record<string, string>;
+        timeout?: number;
+        maxRetries?: number;
+        provider?: string;
+        maxResponseSize?: number;
+    });
+    /**
+     * Determine if a status code should be retried
+     * @private
+     */
+    private shouldRetry;
+    /**
+     * Calculate backoff delay with jitter
+     * @private
+     */
+    private getBackoffDelay;
+    /**
+     * Make an HTTP request with retry logic
+     */
+    request<T = unknown>(options: HTTPRequestOptions, retries?: number): Promise<HTTPResponse<T>>;
+    /**
+     * Make a streaming HTTP request
+     */
+    requestStream(options: HTTPRequestOptions): AsyncIterable<string>;
+}
+
+/**
+ * Base error class for all Amux errors
+ */
+declare class LLMBridgeError extends Error {
+    code: string;
+    retryable: boolean;
+    details?: unknown;
+    constructor(message: string, code: string, retryable?: boolean, details?: unknown);
+}
+/**
+ * Error from provider API calls
+ */
+declare class APIError extends LLMBridgeError {
+    status: number;
+    provider: string;
+    data?: unknown;
+    response?: {
+        headers?: Record<string, string>;
+    };
+    constructor(message: string, status: number, provider: string, data?: unknown, response?: {
+        headers?: Record<string, string>;
+    });
+}
+/**
+ * Network-related errors (connection failures, timeouts, etc.)
+ */
+declare class NetworkError extends LLMBridgeError {
+    cause?: unknown;
+    constructor(message: string, cause?: unknown);
+}
+/**
+ * Request timeout errors
+ */
+declare class TimeoutError extends LLMBridgeError {
+    timeout: number;
+    constructor(message: string, timeout: number);
+}
+/**
+ * Validation errors (invalid request format, missing required fields, etc.)
+ */
+declare class ValidationError extends LLMBridgeError {
+    errors: string[];
+    constructor(message: string, errors: string[]);
+}
+/**
+ * Adapter-related errors (conversion failures, unsupported features, etc.)
+ */
+declare class AdapterError extends LLMBridgeError {
+    adapterName: string;
+    constructor(message: string, adapterName: string, details?: unknown);
+}
+/**
+ * Bridge orchestration errors
+ */
+declare class BridgeError extends LLMBridgeError {
+    constructor(message: string, details?: unknown);
+}
+
+/**
+ * Efficient SSE (Server-Sent Events) line parser
+ * Handles incomplete chunks and extracts complete lines efficiently
+ */
+declare class SSELineParser {
+    private buffer;
+    /**
+     * Process a chunk of SSE data and extract complete lines
+     * @param chunk - The data chunk to process
+     * @returns Array of complete lines
+     */
+    processChunk(chunk: string): string[];
+    /**
+     * Extract all complete lines from the buffer
+     * Incomplete lines remain in the buffer
+     * @private
+     */
+    private extractLines;
+    /**
+     * Get any remaining data in the buffer and clear it
+     * Call this when the stream ends to get the last incomplete line
+     */
+    flush(): string[];
+    /**
+     * Check if buffer has any remaining data
+     */
+    hasRemaining(): boolean;
+    /**
+     * Clear the buffer
+     */
+    clear(): void;
+}
+
+/**
+ * Map finish reason string to IR finish reason
+ * @param reason - The finish reason string from the provider
+ * @param customMappings - Optional custom mappings to extend/override standard mappings
+ * @param defaultReason - Default reason if not found (default: 'stop')
+ */
+declare function mapFinishReason(reason?: string, customMappings?: Record<string, FinishReason>, defaultReason?: FinishReason): FinishReason;
+/**
+ * Map error type or code string to IR error type
+ * @param type - The error type string from the provider
+ * @param code - The error code string from the provider (optional)
+ * @param customTypeMappings - Optional custom type mappings to extend/override standard mappings
+ * @param customCodeMappings - Optional custom code mappings to extend/override standard mappings
+ */
+declare function mapErrorType(type?: string, code?: string, customTypeMappings?: Record<string, ErrorType>, customCodeMappings?: Record<string, ErrorType>): ErrorType;
+/**
+ * Parse OpenAI-compatible error response to IR
+ * Works for OpenAI, DeepSeek, Moonshot, Qwen, Zhipu, and other compatible APIs
+ *
+ * @param error - The error object from the provider
+ * @param customTypeMappings - Optional custom error type mappings
+ * @param customCodeMappings - Optional custom error code mappings
+ */
+declare function parseOpenAICompatibleError(error: unknown, customTypeMappings?: Record<string, ErrorType>, customCodeMappings?: Record<string, ErrorType>): LLMErrorIR;
+
+/**
+ * Convert message content to string
+ * Used by response builders to convert IR content to provider format
+ *
+ * @param content - Message content (string or ContentPart array)
+ * @returns String content or null if empty
+ */
+declare function contentToString(content: MessageContent): string | null;
+/**
+ * Check if content contains only text
+ * @param content - Message content
+ * @returns True if content is string or contains only text parts
+ */
+declare function isTextOnlyContent(content: MessageContent): boolean;
+/**
+ * Extract text from content
+ * @param content - Message content
+ * @returns Array of text strings
+ */
+declare function extractTextFromContent(content: MessageContent): string[];
+/**
+ * Check if content has images
+ * @param content - Message content
+ * @returns True if content contains image parts
+ */
+declare function hasImageContent(content: MessageContent): boolean;
+
+/**
+ * Standard OpenAI-compatible usage object structure
+ */
+interface StandardUsage {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+    completion_tokens_details?: {
+        reasoning_tokens?: number;
+    };
+    prompt_cache_hit_tokens?: number;
+    prompt_cache_miss_tokens?: number;
+}
+/**
+ * Parse OpenAI-compatible usage to IR usage
+ * @param usage - Usage object from provider response
+ * @returns IR usage object or undefined
+ */
+declare function parseOpenAIUsage(usage?: StandardUsage): Usage | undefined;
+/**
+ * Build OpenAI-compatible usage from IR usage
+ * @param usage - IR usage object
+ * @param includeReasoningTokens - Whether to include reasoning tokens (default: true)
+ * @param includeCacheTokens - Whether to include cache tokens (default: false)
+ * @returns OpenAI-compatible usage object or undefined
+ */
+declare function buildOpenAIUsage(usage?: Usage, includeReasoningTokens?: boolean, includeCacheTokens?: boolean): StandardUsage | undefined;
+
+export { APIError, type AdapterCapabilities, AdapterError, type AdapterInfo, AdapterRegistry, Bridge, type BridgeConfig, BridgeError, type BridgeHooks, type BridgeOptions, type Choice, type CompatibilityReport, type ContentDelta, type ContentPart, type ErrorHandler, type ErrorType, type FinishReason, type FunctionDefinition, type GenerationConfig, HTTPClient, type HTTPRequestOptions, type HTTPResponse, type ImageContent, type ImageSource, type JSONSchema, type LLMAdapter, type LLMBridge, LLMBridgeError, type LLMErrorIR, type LLMRequestIR, type LLMResponseIR, type LLMStreamEvent, type Message, type MessageContent, NetworkError, type ProviderEndpoint, type ReasoningDelta, type ResponseFormat, type Role, type SSEEvent, SSELineParser, type StandardUsage, type StreamEventBuilder, type StreamEventType, type StreamHandler, type TextContent, type ThinkingConfig, TimeoutError, type Tool, type ToolCall, type ToolCallDelta, type ToolChoice, type Usage, ValidationError, type ValidationResult, buildOpenAIUsage, contentToString, createBridge, extractTextFromContent, globalRegistry, hasImageContent, isTextOnlyContent, mapErrorType, mapFinishReason, parseOpenAICompatibleError, parseOpenAIUsage };