@yourgpt/llm-sdk 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,1048 @@
+import { ToolDefinition, UnifiedToolCall, UnifiedToolResult, LLMConfig, ActionDefinition, AgentLoopConfig, KnowledgeBaseConfig, StreamEvent, DoneEventMessage, Message, AIProvider as AIProvider$1, ToolResponse } from '@yourgpt/copilot-sdk/core';
+export { ActionDefinition, AgentLoopConfig, LLMConfig, LLMProvider, Message, StreamEvent, ToolDefinition, ToolExecution, ToolLocation, ToolResponse, UnifiedToolCall, UnifiedToolResult } from '@yourgpt/copilot-sdk/core';
+import { LLMAdapter } from './adapters/index.mjs';
+export { AdapterFactory, AnthropicAdapter, AnthropicAdapterConfig, AzureAdapter, AzureAdapterConfig, ChatCompletionRequest, GoogleAdapter, GoogleAdapterConfig, GroqAdapter, GroqAdapterConfig, OllamaAdapter, OllamaAdapterConfig, OpenAIAdapter, OpenAIAdapterConfig, XAIAdapter, XAIAdapterConfig, createAnthropicAdapter, createAzureAdapter, createGoogleAdapter, createGroqAdapter, createOllamaAdapter, createOpenAIAdapter, createXAIAdapter } from './adapters/index.mjs';
+import * as hono from 'hono';
+import { Hono } from 'hono';
+
+/**
+ * Provider Types
+ *
+ * Defines interfaces for:
+ * 1. Provider Formatters (for tool transformations in agent loop)
+ * 2. Multi-provider architecture (AIProvider, capabilities, configs)
+ */
+
+/**
+ * Provider formatter interface
+ *
+ * Each provider implements this interface to handle:
+ * - Tool definition transformation
+ * - Tool call parsing from responses
+ * - Tool result formatting
+ * - Stop reason detection
+ */
+interface ProviderFormatter {
+    /**
+     * Transform unified tool definitions to provider format
+     */
+    transformTools(tools: ToolDefinition[]): unknown[];
+    /**
+     * Parse tool calls from provider response
+     */
+    parseToolCalls(response: unknown): UnifiedToolCall[];
+    /**
+     * Format tool results for provider
+     */
+    formatToolResults(results: UnifiedToolResult[]): unknown[];
+    /**
+     * Check if response indicates tool use is requested
+     */
+    isToolUseStop(response: unknown): boolean;
+    /**
+     * Check if response indicates end of turn
+     */
+    isEndTurnStop(response: unknown): boolean;
+    /**
+     * Get stop reason string from response
+     */
+    getStopReason(response: unknown): string;
+    /**
+     * Extract text content from response
+     */
+    extractTextContent(response: unknown): string;
+    /**
+     * Build assistant message with tool calls for conversation history
+     */
+    buildAssistantToolMessage(toolCalls: UnifiedToolCall[], textContent?: string): unknown;
+    /**
+     * Build user message with tool results for conversation history
+     */
+    buildToolResultMessage(results: UnifiedToolResult[]): unknown;
+}
+/**
+ * Anthropic tool definition format
+ */
+interface AnthropicTool {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: Record<string, unknown>;
+        required?: string[];
+    };
+}
+/**
+ * Anthropic tool_use block from response
+ */
+interface AnthropicToolUse {
+    type: "tool_use";
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+}
+/**
+ * Anthropic tool_result block
+ */
+interface AnthropicToolResult {
+    type: "tool_result";
+    tool_use_id: string;
+    content: string;
+}
+/**
+ * OpenAI tool definition format
+ */
+interface OpenAITool {
+    type: "function";
+    function: {
+        name: string;
+        description: string;
+        parameters: {
+            type: "object";
+            properties: Record<string, unknown>;
+            required?: string[];
+        };
+    };
+}
+/**
+ * OpenAI tool call from response
+ */
+interface OpenAIToolCall {
+    id: string;
+    type: "function";
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+/**
+ * OpenAI tool result message
+ */
+interface OpenAIToolResult {
+    role: "tool";
+    tool_call_id: string;
+    content: string;
+}
+/**
+ * Google Gemini function declaration
+ */
+interface GeminiFunctionDeclaration {
+    name: string;
+    description: string;
+    parameters?: {
+        type: "object";
+        properties: Record<string, unknown>;
+        required?: string[];
+    };
+}
+/**
+ * Gemini function call from response
+ */
+interface GeminiFunctionCall {
+    name: string;
+    args: Record<string, unknown>;
+}
+/**
+ * Gemini function response
+ */
+interface GeminiFunctionResponse {
+    name: string;
+    response: Record<string, unknown>;
+}
+/**
+ * Capabilities of a model for UI feature flags
+ * UI components can use this to enable/disable features
+ */
+interface ProviderCapabilities {
+    /** Supports image inputs */
+    supportsVision: boolean;
+    /** Supports tool/function calling */
+    supportsTools: boolean;
+    /** Supports extended thinking (Claude, DeepSeek) */
+    supportsThinking: boolean;
+    /** Supports streaming responses */
+    supportsStreaming: boolean;
+    /** Supports PDF document inputs */
+    supportsPDF: boolean;
+    /** Supports audio inputs */
+    supportsAudio: boolean;
+    /** Supports video inputs */
+    supportsVideo: boolean;
+    /** Maximum context tokens */
+    maxTokens: number;
+    /** Supported image MIME types */
+    supportedImageTypes: string[];
+    /** Supported audio MIME types */
+    supportedAudioTypes?: string[];
+    /** Supported video MIME types */
+    supportedVideoTypes?: string[];
+    /** Supports JSON mode / structured output */
+    supportsJsonMode?: boolean;
+    /** Supports system messages */
+    supportsSystemMessages?: boolean;
+}
+/**
+ * AI Provider interface
+ *
+ * Wraps existing LLMAdapter with additional metadata:
+ * - Supported models list
+ * - Per-model capabilities
+ * - Provider name
+ *
+ * @example
+ * ```typescript
+ * const openai = createOpenAI({ apiKey: '...' });
+ *
+ * // Get adapter for a specific model
+ * const adapter = openai.languageModel('gpt-4o');
+ *
+ * // Check capabilities
+ * const caps = openai.getCapabilities('gpt-4o');
+ * if (caps.supportsVision) {
+ *   // Show image upload button
+ * }
+ * ```
+ */
+interface AIProvider {
+    /** Provider name (e.g., 'openai', 'anthropic') */
+    readonly name: string;
+    /** List of supported model IDs */
+    readonly supportedModels: string[];
+    /**
+     * Get a language model adapter for the given model ID
+     * Returns the existing LLMAdapter interface - no breaking changes
+     */
+    languageModel(modelId: string): LLMAdapter;
+    /**
+     * Get capabilities for a specific model
+     * UI components use this to enable/disable features
+     */
+    getCapabilities(modelId: string): ProviderCapabilities;
+    /**
+     * Optional: Get an embedding model (future expansion)
+     */
+    embeddingModel?(modelId: string): EmbeddingModel;
+}
+/**
+ * Embedding model interface (for future expansion)
+ */
+interface EmbeddingModel {
+    readonly provider: string;
+    readonly modelId: string;
+    embed(texts: string[]): Promise<number[][]>;
+}
+/**
+ * Base provider configuration
+ */
+interface BaseProviderConfig {
+    /** API key (falls back to environment variable) */
+    apiKey?: string;
+    /** Custom base URL */
+    baseUrl?: string;
+    /** Request timeout in milliseconds */
+    timeout?: number;
+    /** Custom headers to include */
+    headers?: Record<string, string>;
+}
+/**
+ * OpenAI provider configuration
+ */
+interface OpenAIProviderConfig extends BaseProviderConfig {
+    /** OpenAI organization ID */
+    organization?: string;
+    /** OpenAI project ID */
+    project?: string;
+    /** Vision detail level for images */
+    imageDetail?: "auto" | "low" | "high";
+}
+/**
+ * Anthropic provider configuration
+ */
+interface AnthropicProviderConfig extends BaseProviderConfig {
+    /** Extended thinking budget in tokens (minimum 1024) */
+    thinkingBudget?: number;
+    /** Enable prompt caching */
+    cacheControl?: boolean;
+}
+/**
+ * Google provider configuration
+ */
+interface GoogleProviderConfig extends BaseProviderConfig {
+    /** Safety settings */
+    safetySettings?: GoogleSafetySetting[];
+    /** Grounding configuration (for web search) */
+    groundingConfig?: GoogleGroundingConfig;
+}
+/**
+ * Google safety setting
+ */
+interface GoogleSafetySetting {
+    category: "HARM_CATEGORY_HARASSMENT" | "HARM_CATEGORY_HATE_SPEECH" | "HARM_CATEGORY_SEXUALLY_EXPLICIT" | "HARM_CATEGORY_DANGEROUS_CONTENT";
+    threshold: "BLOCK_NONE" | "BLOCK_LOW_AND_ABOVE" | "BLOCK_MEDIUM_AND_ABOVE" | "BLOCK_HIGH_AND_ABOVE";
+}
+/**
+ * Google grounding configuration
+ */
+interface GoogleGroundingConfig {
+    /** Enable Google Search grounding */
+    googleSearchRetrieval?: boolean;
+}
+/**
+ * xAI provider configuration
+ */
+interface XAIProviderConfig extends BaseProviderConfig {
+}
+/**
+ * Azure OpenAI provider configuration
+ */
+interface AzureProviderConfig extends BaseProviderConfig {
+    /** Azure resource name */
+    resourceName: string;
+    /** Deployment name */
+    deploymentName: string;
+    /** API version (default: 2024-02-15-preview) */
+    apiVersion?: string;
+}
+/**
+ * Groq provider configuration
+ */
+interface GroqProviderConfig extends BaseProviderConfig {
+}
+/**
+ * Ollama provider configuration
+ */
+interface OllamaProviderConfig extends BaseProviderConfig {
+}
+
+/**
+ * Runtime configuration with LLM config
+ */
+interface RuntimeConfigWithLLM {
+    /** LLM configuration */
+    llm: LLMConfig & {
+        apiKey: string;
+    };
+    /** Custom LLM adapter (overrides llm config) */
+    adapter?: LLMAdapter;
+    /** System prompt */
+    systemPrompt?: string;
+    /** Available actions (legacy) */
+    actions?: ActionDefinition[];
+    /** Available tools (new - supports location: server/client) */
+    tools?: ToolDefinition[];
+    /** Agent loop configuration */
+    agentLoop?: AgentLoopConfig;
+    /** Knowledge base configuration (enables search_knowledge tool) */
+    knowledgeBase?: KnowledgeBaseConfig;
+    /** Enable debug logging */
+    debug?: boolean;
+    /**
+     * Custom context data passed to all tool handlers.
+     * Useful for passing auth tokens, user info, tenant data, etc.
+     *
+     * @example
+     * ```typescript
+     * const runtime = createRuntime({
+     *   llm: { ... },
+     *   toolContext: { userId: session.userId, tenantId: tenant.id },
+     * });
+     * ```
+     */
+    toolContext?: Record<string, unknown>;
+}
+/**
+ * Runtime configuration with adapter
+ */
+interface RuntimeConfigWithAdapter {
+    /** Custom LLM adapter */
+    adapter: LLMAdapter;
+    /** LLM configuration (optional when adapter provided) */
+    llm?: LLMConfig & {
+        apiKey: string;
+    };
+    /** System prompt */
+    systemPrompt?: string;
+    /** Available actions (legacy) */
+    actions?: ActionDefinition[];
+    /** Available tools (new - supports location: server/client) */
+    tools?: ToolDefinition[];
+    /** Agent loop configuration */
+    agentLoop?: AgentLoopConfig;
+    /** Knowledge base configuration (enables search_knowledge tool) */
+    knowledgeBase?: KnowledgeBaseConfig;
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Custom context data passed to all tool handlers */
+    toolContext?: Record<string, unknown>;
+}
+/**
+ * Runtime configuration with AIProvider
+ *
+ * @example
+ * ```typescript
+ * import { createOpenAI } from '@yourgpt/llm-sdk';
+ *
+ * const openai = createOpenAI({ apiKey: '...' });
+ * const runtime = createRuntime({
+ *   provider: openai,
+ *   model: 'gpt-4o',
+ * });
+ * ```
+ */
+interface RuntimeConfigWithProvider {
+    /** AI Provider instance */
+    provider: AIProvider;
+    /** Model ID to use (required when using provider) */
+    model: string;
+    /** System prompt */
+    systemPrompt?: string;
+    /** Available actions (legacy) */
+    actions?: ActionDefinition[];
+    /** Available tools (new - supports location: server/client) */
+    tools?: ToolDefinition[];
+    /** Agent loop configuration */
+    agentLoop?: AgentLoopConfig;
+    /** Knowledge base configuration (enables search_knowledge tool) */
+    knowledgeBase?: KnowledgeBaseConfig;
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Custom context data passed to all tool handlers */
+    toolContext?: Record<string, unknown>;
+}
+/**
+ * Runtime configuration - either provide llm config, adapter, or provider
+ */
+type RuntimeConfig = RuntimeConfigWithLLM | RuntimeConfigWithAdapter | RuntimeConfigWithProvider;
+/**
+ * Message attachment (images, files, etc.)
+ */
+interface MessageAttachment {
+    type: "image" | "file" | "audio" | "video";
+    data: string;
+    mimeType?: string;
+    filename?: string;
+}
+/**
+ * Chat request body
+ */
+interface ChatRequest {
+    /** Conversation messages */
+    messages: Array<{
+        role: string;
+        content: string;
+        /** Attachments like images (for vision support) */
+        attachments?: MessageAttachment[];
+        /** Tool call ID (for tool result messages) */
+        tool_call_id?: string;
+        /** Tool calls from assistant (for continuing agent loop) */
+        tool_calls?: Array<{
+            id: string;
+            type: string;
+            function: {
+                name: string;
+                arguments: string;
+            };
+        }>;
+    }>;
+    /** Thread/conversation ID */
+    threadId?: string;
+    /** Bot ID (for cloud) */
+    botId?: string;
+    /** LLM config overrides */
+    config?: Partial<LLMConfig>;
+    /** System prompt override */
+    systemPrompt?: string;
+    /** Actions from client (legacy) */
+    actions?: Array<{
+        name: string;
+        description: string;
+        parameters?: Record<string, unknown>;
+    }>;
+    /** Tools from client (location is always "client" for tools from request) */
+    tools?: Array<{
+        name: string;
+        description: string;
+        inputSchema: {
+            type: "object";
+            properties: Record<string, unknown>;
+            required?: string[];
+        };
+    }>;
+    /** Enable agentic loop mode */
+    useAgentLoop?: boolean;
+    /** Enable streaming responses (default: true). Set to false for non-streaming mode. */
+    streaming?: boolean;
+    /** Knowledge Base configuration (enables search_knowledge tool) */
+    knowledgeBase?: {
+        /** Project UID for the knowledge base */
+        projectUid: string;
+        /** Auth token for API calls */
+        token: string;
+        /** App ID (default: "1") */
+        appId?: string;
+        /** Results limit (default: 5) */
+        limit?: number;
+    };
+}
+/**
+ * Action execution request
+ */
+interface ActionRequest {
+    /** Action name */
+    name: string;
+    /** Action arguments */
+    args: Record<string, unknown>;
+}
+/**
+ * Request context
+ */
+interface RequestContext {
+    /** Request headers */
+    headers: Record<string, string>;
+    /** Parsed request body */
+    body: ChatRequest;
+}
+
+/**
+ * Copilot SDK Runtime
+ *
+ * Handles chat requests and manages LLM interactions.
+ */
+declare class Runtime {
+    private adapter;
+    private config;
+    private actions;
+    private tools;
+    constructor(config: RuntimeConfig);
+    /**
+     * Create LLM adapter based on config
+     */
+    private createAdapter;
+    /**
+     * Process a chat request and return streaming response
+     */
+    processChat(request: ChatRequest, signal?: AbortSignal): AsyncGenerator<StreamEvent>;
+    /**
+     * Handle HTTP request (for use with any framework)
+     */
+    handleRequest(request: Request): Promise<Response>;
+    /**
+     * Handle non-streaming request - returns JSON instead of SSE
+     */
+    private handleNonStreamingRequest;
+    /**
+     * Get registered actions
+     */
+    getActions(): ActionDefinition[];
+    /**
+     * Register a new action
+     */
+    registerAction(action: ActionDefinition): void;
+    /**
+     * Unregister an action
+     */
+    unregisterAction(name: string): void;
+    /**
+     * Register a new tool
+     */
+    registerTool(tool: ToolDefinition): void;
+    /**
+     * Unregister a tool
+     */
+    unregisterTool(name: string): void;
+    /**
+     * Get registered tools
+     */
+    getTools(): ToolDefinition[];
+    /**
+     * Get the AI provider name from config
+     */
+    private getProviderName;
+    /**
+     * Get the AI provider instance (if using provider config)
+     */
+    getProvider(): AIProvider | null;
+    /**
+     * Get the current model ID
+     */
+    getModel(): string;
+    /**
+     * Process a chat request with tool support (Vercel AI SDK pattern)
+     *
+     * This method:
+     * 1. Streams response from adapter
+     * 2. Detects tool calls from streaming events
+     * 3. Server-side tools are executed immediately
+     * 4. Client-side tool calls are yielded for client to execute
+     * 5. Loop continues until no more tool calls or max iterations reached
+     * 6. Returns all new messages in the done event for client to append
+     */
+    processChatWithLoop(request: ChatRequest, signal?: AbortSignal, _accumulatedMessages?: DoneEventMessage[], _isRecursive?: boolean, _httpRequest?: Request): AsyncGenerator<StreamEvent>;
+    /**
+     * Non-streaming agent loop implementation
+     *
+     * Uses adapter.complete() instead of stream() for:
+     * - Better comparison with original studio-ai behavior
+     * - Easier debugging (full response at once)
+     * - More predictable retry behavior
+     */
+    private processChatWithLoopNonStreaming;
+    /**
+     * Convert tools to legacy action format (for adapter compatibility)
+     */
+    private convertToolsToActions;
+    /**
+     * Convert JSON Schema property to ActionParameter format recursively
+     */
+    private convertSchemaProperty;
+    /**
+     * Convert JSON Schema to legacy parameters format
+     */
+    private convertInputSchemaToParameters;
+}
+/**
+ * Create runtime instance
+ */
+declare function createRuntime(config: RuntimeConfig): Runtime;
+
+/**
+ * Create SSE response headers
+ */
+declare function createSSEHeaders(): Record<string, string>;
+/**
+ * Format event as SSE data
+ */
+declare function formatSSEData(event: StreamEvent): string;
+/**
+ * Create a ReadableStream from an async generator of events
+ */
+declare function createEventStream(generator: AsyncGenerator<StreamEvent>): ReadableStream<Uint8Array>;
+/**
+ * Create SSE Response object
+ */
+declare function createSSEResponse(generator: AsyncGenerator<StreamEvent>): Response;
+
+/**
+ * Create Hono app with chat endpoint
+ */
+declare function createHonoApp(runtime: Runtime): Hono;
+/**
+ * Next.js App Router handler
+ *
+ * @example
+ * ```ts
+ * // app/api/chat/route.ts
+ * import { createNextHandler } from '@yourgpt/llm-sdk';
+ *
+ * const handler = createNextHandler({
+ *   llm: { provider: 'openai', apiKey: process.env.OPENAI_API_KEY! },
+ * });
+ *
+ * export const POST = handler;
+ * ```
+ */
+declare function createNextHandler(config: RuntimeConfig): (request: Request) => Promise<Response>;
+/**
+ * Express middleware
+ *
+ * @example
+ * ```ts
+ * import express from 'express';
+ * import { createExpressMiddleware } from '@yourgpt/llm-sdk';
+ *
+ * const app = express();
+ *
+ * app.use('/api/chat', createExpressMiddleware({
+ *   llm: { provider: 'openai', apiKey: process.env.OPENAI_API_KEY! },
+ * }));
+ * ```
+ */
+declare function createExpressMiddleware(config: RuntimeConfig): (req: {
+    method: string;
+    url: string;
+    headers: Record<string, string>;
+    body: unknown;
+}, res: {
+    status: (code: number) => {
+        json: (data: unknown) => void;
+    };
+    setHeader: (name: string, value: string) => void;
+    write: (data: string) => void;
+    end: () => void;
+}) => Promise<void>;
+/**
+ * Node.js HTTP handler
+ *
+ * @example
+ * ```ts
+ * import http from 'http';
+ * import { createNodeHandler } from '@yourgpt/llm-sdk';
+ *
+ * const handler = createNodeHandler({
+ *   llm: { provider: 'openai', apiKey: process.env.OPENAI_API_KEY! },
+ * });
+ *
+ * const server = http.createServer(handler);
+ * server.listen(3001);
+ * ```
+ */
+declare function createNodeHandler(config: RuntimeConfig): (request: Request, Env?: unknown, executionCtx?: hono.ExecutionContext) => Response | Promise<Response>;
+
+/**
+ * Agent Loop Implementation
+ *
+ * Server-side agentic loop that:
+ * 1. Calls LLM with tools
+ * 2. Parses tool calls from response
+ * 3. Executes server-side tools or requests client execution
+ * 4. Loops until LLM returns end_turn or max iterations reached
+ *
+ * Streams events to client via SSE for real-time updates
+ */
+
+/** Default maximum iterations */
+declare const DEFAULT_MAX_ITERATIONS = 20;
+/**
+ * Agent loop options
+ */
+interface AgentLoopOptions {
+    /** Initial messages */
+    messages: Message[];
+    /** Available tools */
+    tools: ToolDefinition[];
+    /** System prompt */
+    systemPrompt?: string;
+    /** AI provider */
+    provider: AIProvider$1;
+    /** Abort signal for cancellation */
+    signal?: AbortSignal;
+    /** Loop configuration */
+    config?: AgentLoopConfig;
+    /**
+     * LLM call function
+     * Should call the LLM and return the raw response
+     */
+    callLLM: (messages: unknown[], tools: unknown[]) => Promise<unknown>;
+    /**
+     * Server-side tool executor
+     * Called when a server-side tool needs to be executed
+     */
+    executeServerTool?: (name: string, args: Record<string, unknown>) => Promise<ToolResponse>;
+    /**
+     * Callback to wait for client tool result
+     * Called when a client-side tool needs to be executed
+     * Should return a Promise that resolves when client sends result
+     */
+    waitForClientToolResult?: (toolCallId: string, name: string, args: Record<string, unknown>) => Promise<ToolResponse>;
+}
+/**
+ * Run the agentic loop
+ *
+ * @yields Stream events for each step of the loop
+ */
+declare function runAgentLoop(options: AgentLoopOptions): AsyncGenerator<StreamEvent>;
+
+/**
+ * Provider Registry
+ *
+ * Central registry for AI providers.
+ * Allows dynamic registration and lookup of providers.
+ */
+
+/**
+ * Register a provider factory
+ *
+ * @param name Provider name (e.g., 'openai')
+ * @param factory Factory function that creates the provider
+ *
+ * @example
+ * ```typescript
+ * registerProvider('openai', (config) => createOpenAI(config));
+ * ```
+ */
+declare function registerProvider(name: string, factory: (config?: Record<string, unknown>) => AIProvider): void;
+/**
+ * Get a provider by name
+ *
+ * @param name Provider name
+ * @param config Optional configuration
+ * @returns Provider instance or undefined if not found
+ *
+ * @example
+ * ```typescript
+ * const openai = getProvider('openai', { apiKey: '...' });
+ * ```
+ */
+declare function getProvider(name: string, config?: Record<string, unknown>): AIProvider | undefined;
+/**
+ * Check if a provider is registered
+ */
+declare function hasProvider(name: string): boolean;
+/**
+ * List all registered provider names
+ */
+declare function listProviders(): string[];
+/**
+ * Get all available providers with their models
+ * Useful for building UI model selectors
+ */
+declare function getAvailableProviders(): Array<{
+    name: string;
+    models: string[];
+}>;
+/**
+ * Get capabilities for a specific provider and model
+ */
+declare function getModelCapabilities(providerName: string, modelId: string): ProviderCapabilities | undefined;
+
+/**
+ * OpenAI Provider
+ *
+ * Wraps the existing OpenAIAdapter with provider interface.
+ * Adds model capabilities and metadata.
+ */
+
+/**
+ * Create an OpenAI provider
+ *
+ * @example
+ * ```typescript
+ * const openai = createOpenAI({ apiKey: '...' });
+ * const adapter = openai.languageModel('gpt-4o');
+ * const caps = openai.getCapabilities('gpt-4o');
+ * ```
+ */
+declare function createOpenAI(config?: OpenAIProviderConfig): AIProvider;
+
+/**
+ * Anthropic Provider
+ *
+ * Wraps the existing AnthropicAdapter with provider interface.
+ * Adds model capabilities and metadata including extended thinking support.
+ */
+
+/**
+ * Create an Anthropic provider
+ *
+ * @example
+ * ```typescript
+ * const anthropic = createAnthropic({
+ *   apiKey: '...',
+ *   thinkingBudget: 10000, // Enable extended thinking
+ * });
+ * const adapter = anthropic.languageModel('claude-sonnet-4-20250514');
+ * const caps = anthropic.getCapabilities('claude-sonnet-4-20250514');
+ * ```
+ */
+declare function createAnthropic(config?: AnthropicProviderConfig): AIProvider;
+
+/**
+ * Groq Provider
+ *
+ * Wraps the existing GroqAdapter with provider interface.
+ * Groq provides fast inference for open-source models.
+ */
+
+/**
+ * Create a Groq provider
+ *
+ * @example
+ * ```typescript
+ * const groq = createGroq({ apiKey: '...' });
+ * const adapter = groq.languageModel('llama-3.3-70b-versatile');
+ * ```
+ */
+declare function createGroq(config?: GroqProviderConfig): AIProvider;
+
+/**
+ * Ollama Provider
+ *
+ * Wraps the existing OllamaAdapter with provider interface.
+ * Ollama runs models locally on your machine.
+ */
+
+/**
+ * Create an Ollama provider
+ *
+ * @example
+ * ```typescript
+ * const ollama = createOllama({ baseUrl: 'http://localhost:11434' });
+ * const adapter = ollama.languageModel('llama3');
+ * ```
+ */
+declare function createOllama(config?: OllamaProviderConfig): AIProvider;
+
+/**
+ * Google Provider
+ *
+ * Wraps the GoogleAdapter with provider interface.
+ * Adds model capabilities and metadata for multimodal support.
+ *
+ * Features:
+ * - Vision (images)
+ * - Audio input
+ * - Video input
+ * - PDF documents
+ * - Tools/Function calling
+ * - Massive context windows (up to 2M tokens)
+ */
+
+/**
+ * Create a Google provider
+ *
+ * @example
+ * ```typescript
+ * const google = createGoogle({
+ *   apiKey: '...',
+ * });
+ * const adapter = google.languageModel('gemini-2.0-flash');
+ * const caps = google.getCapabilities('gemini-2.0-flash');
+ *
+ * if (caps.supportsVideo) {
+ *   // Show video upload button
+ * }
+ * ```
+ */
+declare function createGoogle(config?: GoogleProviderConfig): AIProvider;
+
+/**
+ * xAI Provider
+ *
+ * Wraps the XAIAdapter with provider interface.
+ * xAI's Grok models are cutting-edge AI models with vision and tool support.
+ *
+ * Features:
+ * - Vision (images)
+ * - Tools/Function calling
+ * - Real-time information (trained on X/Twitter data)
+ */
+
+/**
+ * Create an xAI provider
+ *
+ * @example
+ * ```typescript
+ * const xai = createXAI({
+ *   apiKey: '...',
+ * });
+ * const adapter = xai.languageModel('grok-2');
+ * const caps = xai.getCapabilities('grok-2');
+ * ```
+ */
+declare function createXAI(config?: XAIProviderConfig): AIProvider;
+
+/**
+ * Azure OpenAI Provider
+ *
+ * Wraps the AzureAdapter with provider interface.
+ * Azure OpenAI provides enterprise-grade OpenAI models with Azure security.
+ *
+ * Features:
+ * - Vision (for supported deployments)
+ * - Tools/Function calling
+ * - Enterprise security & compliance
+ * - Private networking options
+ *
+ * Note: Capabilities depend on which model is deployed, not a model ID.
+ * The provider attempts to detect capabilities from the deployment name.
+ */
+
+/**
+ * Create an Azure OpenAI provider
+ *
+ * @example
+ * ```typescript
+ * const azure = createAzure({
+ *   apiKey: '...',
+ *   resourceName: 'my-azure-resource',
+ *   deploymentName: 'gpt-4o-deployment',
+ * });
+ * const adapter = azure.languageModel('gpt-4o-deployment');
+ * const caps = azure.getCapabilities('gpt-4o-deployment');
+ * ```
+ */
+declare function createAzure(config: AzureProviderConfig): AIProvider;
+
+/**
+ * OpenAI Provider Formatter
+ *
+ * Transformation functions for OpenAI API format
+ * Also used by xAI/Grok (they use OpenAI-compatible format)
+ */
+
+/**
+ * OpenAI provider formatter
+ */
+declare const openaiFormatter: ProviderFormatter;
+
+/**
+ * Anthropic/Claude Provider Formatter
+ *
+ * Transformation functions for Anthropic API format
+ */
+
+/**
+ * Anthropic provider formatter
+ */
+declare const anthropicFormatter: ProviderFormatter;
+
+/**
+ * Google Gemini Provider Formatter
+ *
+ * Transformation functions for Google Gemini API format
+ */
+
+/**
+ * Gemini provider formatter
+ */
+declare const geminiFormatter: ProviderFormatter;
+
+/**
+ * Provider Formatter Registry
+ *
+ * Maps provider names to their formatters for the agent loop.
+ * Formatters handle tool transformations between unified format and provider-specific formats.
+ */
+
+/**
+ * Get a formatter for a specific provider
+ *
+ * @param provider - Provider name (e.g., 'openai', 'anthropic', 'google')
+ * @returns The provider's formatter
+ * @throws Error if provider is not supported
+ *
+ * @example
+ * ```typescript
+ * const formatter = getFormatter('openai');
+ * const tools = formatter.transformTools(unifiedTools);
+ * ```
+ */
+declare function getFormatter(provider: string): ProviderFormatter;
+/**
+ * Check if a provider is supported
+ *
+ * @param provider - Provider name to check
+ * @returns True if provider has a formatter
+ *
+ * @example
+ * ```typescript
+ * if (isProviderSupported('openai')) {
+ *   // Use the provider
+ * }
+ * ```
+ */
+declare function isProviderSupported(provider: string): boolean;
+/**
+ * Get list of supported providers
+ *
+ * @returns Array of supported provider names
+ *
+ * @example
+ * ```typescript
+ * const providers = getSupportedProviders();
+ * // ['openai', 'anthropic', 'google', ...]
+ * ```
+ */
+declare function getSupportedProviders(): string[];
+
+export { type AIProvider, type ActionRequest, type AgentLoopOptions, type AnthropicProviderConfig, type AnthropicTool, type AnthropicToolResult, type AnthropicToolUse, type AzureProviderConfig, type BaseProviderConfig, type ChatRequest, DEFAULT_MAX_ITERATIONS, type GeminiFunctionCall, type GeminiFunctionDeclaration, type GeminiFunctionResponse, type GoogleProviderConfig, type GroqProviderConfig, LLMAdapter, type OllamaProviderConfig, type OpenAIProviderConfig, type OpenAITool, type OpenAIToolCall, type OpenAIToolResult, type ProviderCapabilities, type ProviderFormatter, type RequestContext, Runtime, type RuntimeConfig, type XAIProviderConfig, anthropicFormatter, createAnthropic, createAzure, createEventStream, createExpressMiddleware, createGoogle, createGroq, createHonoApp, createNextHandler, createNodeHandler, createOllama, createOpenAI, createRuntime, createSSEHeaders, createSSEResponse, createXAI, formatSSEData, geminiFormatter, getAvailableProviders, getFormatter, getModelCapabilities, getProvider, getSupportedProviders, hasProvider, isProviderSupported, listProviders, openaiFormatter, registerProvider, runAgentLoop };