@yourgpt/llm-sdk 0.1.0 → 1.0.0

package/dist/index.d.ts

@@ -1,318 +1,181 @@
-import { ToolDefinition, UnifiedToolCall, UnifiedToolResult, LLMConfig, ActionDefinition, AgentLoopConfig, KnowledgeBaseConfig, StreamEvent, DoneEventMessage, Message, AIProvider as AIProvider$1, ToolResponse } from '@yourgpt/copilot-sdk/core';
+import { G as GenerateTextParams, a as GenerateTextResult, S as StreamTextParams, b as StreamTextResult, T as ToolContext, c as Tool } from './types-CdORv1Yu.js';
+export { A as AssistantMessage, C as CoreMessage, t as DEFAULT_CAPABILITIES, D as DoGenerateParams, d as DoGenerateResult, E as ErrorChunk, F as FilePart, q as FinishChunk, s as FinishReason, k as GenerateStep, I as ImagePart, L as LanguageModel, M as ModelCapabilities, R as ResponseOptions, m as StreamChunk, l as StreamPart, e as SystemMessage, n as TextDeltaChunk, h as TextPart, r as TokenUsage, i as ToolCall, o as ToolCallChunk, f as ToolMessage, j as ToolResult, p as ToolResultChunk, g as UserContentPart, U as UserMessage } from './types-CdORv1Yu.js';
+import { z } from 'zod';
+export { createOpenAI, openai } from './providers/openai/index.js';
+export { anthropic, createAnthropic } from './providers/anthropic/index.js';
+export { createXAI, xai } from './providers/xai/index.js';
+export { createGoogle, google } from './providers/google/index.js';
+import { LLMConfig, ActionDefinition, ToolDefinition, AgentLoopConfig, KnowledgeBaseConfig, DoneEventMessage, StreamEvent, 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.js';
-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.js';
+import { A as AIProvider, P as ProviderCapabilities, d as ProviderFormatter } from './types-DcoCaVVC.js';
+export { c as AnthropicProviderConfig, e as AnthropicTool, g as AnthropicToolResult, f as AnthropicToolUse, a as AzureProviderConfig, B as BaseProviderConfig, l as GeminiFunctionCall, k as GeminiFunctionDeclaration, m as GeminiFunctionResponse, G as GoogleProviderConfig, O as OllamaProviderConfig, b as OpenAIProviderConfig, h as OpenAITool, i as OpenAIToolCall, j as OpenAIToolResult, X as XAIProviderConfig } from './types-DcoCaVVC.js';
+import { L as LLMAdapter } from './base-D_FyHFKj.js';
+export { A as AdapterFactory, C as ChatCompletionRequest } from './base-D_FyHFKj.js';
 import * as hono from 'hono';
 import { Hono } from 'hono';
+export { AnthropicAdapter, AnthropicAdapterConfig, AzureAdapter, AzureAdapterConfig, GoogleAdapter, GoogleAdapterConfig, OllamaAdapter, OllamaAdapterConfig, OpenAIAdapter, OpenAIAdapterConfig, XAIAdapter, XAIAdapterConfig, createAnthropicAdapter, createAzureAdapter, createGoogleAdapter, createOllamaAdapter, createOpenAIAdapter, createXAIAdapter } from './adapters/index.js';
+export { createOllama } from './providers/ollama/index.js';
+export { createAzure } from './providers/azure/index.js';
 
 /**
- * Provider Types
+ * generateText - Generate text using a language model
  *
- * Defines interfaces for:
- * 1. Provider Formatters (for tool transformations in agent loop)
- * 2. Multi-provider architecture (AIProvider, capabilities, configs)
+ * @example
+ * ```ts
+ * import { generateText } from '@yourgpt/llm-sdk';
+ * import { openai } from '@yourgpt/llm-sdk/openai';
+ *
+ * // Simple usage
+ * const result = await generateText({
+ *   model: openai('gpt-4o'),
+ *   prompt: 'Explain quantum computing in simple terms.',
+ * });
+ * console.log(result.text);
+ *
+ * // With tools (agentic)
+ * const result = await generateText({
+ *   model: openai('gpt-4o'),
+ *   prompt: 'What is the weather in Tokyo?',
+ *   tools: { weather: weatherTool },
+ *   maxSteps: 5,
+ * });
+ * ```
  */
 
 /**
- * Provider formatter interface
+ * Generate text using a language model
  *
- * 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
+ * @param params - Generation parameters
+ * @returns Promise resolving to generation result with text, usage, and tool interactions
  */
-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;
-}
+declare function generateText(params: GenerateTextParams): Promise<GenerateTextResult>;
+
 /**
- * AI Provider interface
- *
- * Wraps existing LLMAdapter with additional metadata:
- * - Supported models list
- * - Per-model capabilities
- * - Provider name
+ * streamText - Stream text from a language model
  *
  * @example
- * ```typescript
- * const openai = createOpenAI({ apiKey: '...' });
+ * ```ts
+ * import { streamText } from '@yourgpt/llm-sdk';
+ * import { openai } from '@yourgpt/llm-sdk/openai';
  *
- * // Get adapter for a specific model
- * const adapter = openai.languageModel('gpt-4o');
+ * // Simple streaming
+ * const result = await streamText({
+ *   model: openai('gpt-4o'),
+ *   prompt: 'Tell me a story.',
+ * });
  *
- * // Check capabilities
- * const caps = openai.getCapabilities('gpt-4o');
- * if (caps.supportsVision) {
- *   // Show image upload button
+ * // Option 1: Iterate text chunks
+ * for await (const chunk of result.textStream) {
+ *   process.stdout.write(chunk);
  * }
+ *
+ * // Option 2: Get full text
+ * const text = await result.text;
+ *
+ * // Option 3: Return as Response (for API routes)
+ * return result.toTextStreamResponse();
  * ```
  */
-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
+ * Stream text from a language model
+ *
+ * @param params - Stream parameters
+ * @returns Promise resolving to stream result with text stream and helpers
  */
-interface GoogleProviderConfig extends BaseProviderConfig {
-    /** Safety settings */
-    safetySettings?: GoogleSafetySetting[];
-    /** Grounding configuration (for web search) */
-    groundingConfig?: GoogleGroundingConfig;
-}
+declare function streamText(params: StreamTextParams): Promise<StreamTextResult>;
+
 /**
- * Google safety setting
+ * Tool Helper
+ *
+ * Create type-safe tools with Zod schema validation.
+ *
+ * @example
+ * ```ts
+ * import { tool } from '@yourgpt/llm-sdk';
+ * import { z } from 'zod';
+ *
+ * const weatherTool = tool({
+ *   description: 'Get current weather for a city',
+ *   parameters: z.object({
+ *     city: z.string().describe('City name'),
+ *     unit: z.enum(['celsius', 'fahrenheit']).optional(),
+ *   }),
+ *   execute: async ({ city, unit }) => {
+ *     const data = await fetchWeather(city);
+ *     return { temperature: data.temp, condition: data.condition };
+ *   },
+ * });
+ * ```
  */
-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
+ * Configuration for creating a tool
  */
-interface GoogleGroundingConfig {
-    /** Enable Google Search grounding */
-    googleSearchRetrieval?: boolean;
+interface ToolConfig<TParams extends z.ZodType, TResult = unknown> {
+    /** Description of what the tool does (shown to LLM) */
+    description: string;
+    /** Zod schema defining the tool's parameters */
+    parameters: TParams;
+    /** Function to execute when the tool is called */
+    execute: (params: z.infer<TParams>, context: ToolContext) => Promise<TResult>;
 }
 /**
- * xAI provider configuration
+ * Create a type-safe tool definition
+ *
+ * @param config - Tool configuration with description, parameters, and execute function
+ * @returns A Tool object that can be passed to generateText/streamText
+ *
+ * @example
+ * ```ts
+ * const searchTool = tool({
+ *   description: 'Search for products in the database',
+ *   parameters: z.object({
+ *     query: z.string(),
+ *     maxResults: z.number().optional().default(10),
+ *   }),
+ *   execute: async ({ query, maxResults }) => {
+ *     return await db.products.search(query, maxResults);
+ *   },
+ * });
+ *
+ * const result = await generateText({
+ *   model: openai('gpt-4o'),
+ *   prompt: 'Find me some headphones',
+ *   tools: { search: searchTool },
+ * });
+ * ```
  */
-interface XAIProviderConfig extends BaseProviderConfig {
-}
+declare function tool<TParams extends z.ZodType, TResult = unknown>(config: ToolConfig<TParams, TResult>): Tool<z.infer<TParams>, TResult>;
 /**
- * Azure OpenAI provider configuration
+ * Format tools for OpenAI API format
  */
-interface AzureProviderConfig extends BaseProviderConfig {
-    /** Azure resource name */
-    resourceName: string;
-    /** Deployment name */
-    deploymentName: string;
-    /** API version (default: 2024-02-15-preview) */
-    apiVersion?: string;
-}
+declare function formatToolsForOpenAI(tools: Record<string, Tool>): Array<{
+    type: "function";
+    function: {
+        name: string;
+        description: string;
+        parameters: object;
+    };
+}>;
 /**
- * Groq provider configuration
+ * Format tools for Anthropic API format
  */
-interface GroqProviderConfig extends BaseProviderConfig {
-}
+declare function formatToolsForAnthropic(tools: Record<string, Tool>): Array<{
+    name: string;
+    description: string;
+    input_schema: object;
+}>;
 /**
- * Ollama provider configuration
+ * Format tools for Google Gemini API format
  */
-interface OllamaProviderConfig extends BaseProviderConfig {
-}
+declare function formatToolsForGoogle(tools: Record<string, Tool>): Array<{
+    functionDeclarations: Array<{
+        name: string;
+        description: string;
+        parameters?: object;
+    }>;
+}>;
 
 /**
  * Runtime configuration with LLM config
@@ -503,6 +366,45 @@ interface RequestContext {
     body: ChatRequest;
 }
 
+/**
+ * Result passed to onFinish callback after stream completes
+ */
+interface HandleRequestResult {
+    /** All messages from this request (assistant messages + tool results) */
+    messages: DoneEventMessage[];
+    /** Thread ID if provided in request */
+    threadId?: string;
+    /** Token usage information */
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+}
+/**
+ * Options for handleRequest method
+ *
+ * @example
+ * ```typescript
+ * runtime.handleRequest(request, {
+ *   onFinish: async ({ messages, threadId }) => {
+ *     await db.thread.upsert({
+ *       where: { id: threadId },
+ *       update: { messages, updatedAt: new Date() },
+ *       create: { id: threadId, messages },
+ *     });
+ *   },
+ * });
+ * ```
+ */
+interface HandleRequestOptions {
+    /**
+     * Called after the stream completes successfully.
+     * Use this for server-side persistence of messages.
+     */
+    onFinish?: (result: HandleRequestResult) => Promise<void> | void;
+}
+
 /**
  * Copilot SDK Runtime
  *
@@ -524,8 +426,32 @@ declare class Runtime {
     processChat(request: ChatRequest, signal?: AbortSignal): AsyncGenerator<StreamEvent>;
     /**
      * Handle HTTP request (for use with any framework)
+     *
+     * @param request - The HTTP request
+     * @param options - Optional configuration including onFinish callback for persistence
+     *
+     * @example
+     * ```typescript
+     * // Basic usage
+     * return runtime.handleRequest(request);
+     *
+     * // With server-side persistence
+     * return runtime.handleRequest(request, {
+     *   onFinish: async ({ messages, threadId }) => {
+     *     await db.thread.upsert({
+     *       where: { id: threadId },
+     *       update: { messages, updatedAt: new Date() },
+     *       create: { id: threadId, messages },
+     *     });
+     *   },
+     * });
+     * ```
+     */
+    handleRequest(request: Request, options?: HandleRequestOptions): Promise<Response>;
+    /**
+     * Wrap a generator to intercept the done event and call onFinish
      */
-    handleRequest(request: Request): Promise<Response>;
+    private wrapGeneratorWithOnFinish;
     /**
      * Handle non-streaming request - returns JSON instead of SSE
      */
@@ -795,174 +721,6 @@ declare function getAvailableProviders(): Array<{
  */
 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
  *
@@ -1045,4 +803,4 @@ declare function isProviderSupported(provider: string): boolean;
  */
 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 };
+export { AIProvider, type ActionRequest, type AgentLoopOptions, type ChatRequest, DEFAULT_MAX_ITERATIONS, GenerateTextParams, GenerateTextResult, LLMAdapter, ProviderCapabilities, ProviderFormatter, type RequestContext, Runtime, type RuntimeConfig, StreamTextParams, StreamTextResult, Tool, ToolContext, anthropicFormatter, createEventStream, createExpressMiddleware, createHonoApp, createNextHandler, createNodeHandler, createRuntime, createSSEHeaders, createSSEResponse, formatSSEData, formatToolsForAnthropic, formatToolsForGoogle, formatToolsForOpenAI, geminiFormatter, generateText, getAvailableProviders, getFormatter, getModelCapabilities, getProvider, getSupportedProviders, hasProvider, isProviderSupported, listProviders, openaiFormatter, registerProvider, runAgentLoop, streamText, tool };