@yourgpt/llm-sdk 2.5.0 → 2.5.1-beta.1

package/dist/types-D774b0dg.d.mts

@@ -0,0 +1,1018 @@
+import { z } from 'zod';
+
+/**
+ * Stream event types for llm-sdk
+ * These types are used internally by the SDK for streaming responses
+ */
+/**
+ * Stream event types
+ */
+type StreamEventType = "message:start" | "message:delta" | "message:end" | "thinking:start" | "thinking:delta" | "thinking:end" | "action:start" | "action:args" | "action:end" | "tool_calls" | "tool:result" | "citation" | "loop:iteration" | "loop:complete" | "error" | "thread:created" | "done";
+/**
+ * Base event interface
+ */
+interface BaseEvent {
+    type: StreamEventType;
+}
+/**
+ * Message started streaming
+ */
+interface MessageStartEvent extends BaseEvent {
+    type: "message:start";
+    id: string;
+}
+/**
+ * Message content delta (incremental update)
+ */
+interface MessageDeltaEvent extends BaseEvent {
+    type: "message:delta";
+    content: string;
+}
+/**
+ * Message finished streaming
+ */
+interface MessageEndEvent extends BaseEvent {
+    type: "message:end";
+}
+/**
+ * Thinking/reasoning started (for models like Claude, DeepSeek)
+ */
+interface ThinkingStartEvent extends BaseEvent {
+    type: "thinking:start";
+}
+/**
+ * Thinking content delta
+ */
+interface ThinkingDeltaEvent extends BaseEvent {
+    type: "thinking:delta";
+    content: string;
+}
+/**
+ * Thinking finished
+ */
+interface ThinkingEndEvent extends BaseEvent {
+    type: "thinking:end";
+}
+/**
+ * Action/tool execution started
+ */
+interface ActionStartEvent extends BaseEvent {
+    type: "action:start";
+    id: string;
+    name: string;
+    /** Whether this tool should be hidden from UI */
+    hidden?: boolean;
+    /** Provider-specific metadata (e.g. Gemini 3 thought_signature) */
+    extra_content?: Record<string, unknown>;
+}
+/**
+ * Action arguments (streaming)
+ */
+interface ActionArgsEvent extends BaseEvent {
+    type: "action:args";
+    id: string;
+    args: string;
+}
+/**
+ * Action execution completed
+ */
+interface ActionEndEvent extends BaseEvent {
+    type: "action:end";
+    id: string;
+    name?: string;
+    result?: unknown;
+    error?: string;
+}
+/**
+ * Error event
+ */
+interface ErrorEvent extends BaseEvent {
+    type: "error";
+    message: string;
+    code?: string;
+}
+/**
+ * Tool call information
+ */
+interface ToolCallInfo {
+    id: string;
+    name: string;
+    args: Record<string, unknown>;
+    /** Whether this tool should be hidden from UI */
+    hidden?: boolean;
+    /** Provider-specific metadata (e.g. Gemini 3 thought_signature) */
+    extra_content?: Record<string, unknown>;
+}
+/**
+ * Assistant message with tool calls
+ */
+interface AssistantToolMessage {
+    role: "assistant";
+    content: string | null;
+    tool_calls: Array<{
+        id: string;
+        type: "function";
+        function: {
+            name: string;
+            arguments: string;
+        };
+        /** Provider-specific metadata (e.g. Gemini 3 thought_signature) */
+        extra_content?: Record<string, unknown>;
+    }>;
+}
+/**
+ * Tool calls event - client should execute and send results
+ */
+interface ToolCallsEvent extends BaseEvent {
+    type: "tool_calls";
+    toolCalls: ToolCallInfo[];
+    assistantMessage: AssistantToolMessage;
+}
+/**
+ * Tool result event
+ */
+interface ToolResultEvent extends BaseEvent {
+    type: "tool:result";
+    id: string;
+    name: string;
+    result: ToolResponse;
+}
+/**
+ * Loop iteration event
+ */
+interface LoopIterationEvent extends BaseEvent {
+    type: "loop:iteration";
+    iteration: number;
+    maxIterations: number;
+}
+/**
+ * Loop complete event
+ */
+interface LoopCompleteEvent extends BaseEvent {
+    type: "loop:complete";
+    iterations: number;
+    aborted?: boolean;
+    maxIterationsReached?: boolean;
+}
+/**
+ * Citation from web search (unified format for all providers)
+ */
+interface Citation {
+    /** Unique citation index (1-based) */
+    index: number;
+    /** Source URL */
+    url: string;
+    /** Page title */
+    title: string;
+    /** Cited text snippet (optional) */
+    citedText?: string;
+    /** Source domain (extracted from URL) */
+    domain?: string;
+    /** Favicon URL (generated from domain) */
+    favicon?: string;
+}
+/**
+ * Citation event - web search returned citations
+ */
+interface CitationEvent extends BaseEvent {
+    type: "citation";
+    citations: Citation[];
+}
+/**
+ * Message format for done event (API format with snake_case)
+ */
+interface DoneEventMessage {
+    role: "assistant" | "tool";
+    content: string | null;
+    tool_calls?: Array<{
+        id: string;
+        type: "function";
+        function: {
+            name: string;
+            arguments: string;
+        };
+        /** Provider-specific metadata (e.g. Gemini 3 thought_signature) */
+        extra_content?: Record<string, unknown>;
+    }>;
+    tool_call_id?: string;
+}
+/**
+ * Token usage (snake_case for API compatibility)
+ */
+interface TokenUsageRaw {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens?: number;
+}
+/**
+ * Thread/session created — emitted early in the stream, before any message events,
+ * so the client can adopt the threadId without waiting for the done chunk.
+ */
+interface ThreadCreatedEvent extends BaseEvent {
+    type: "thread:created";
+    threadId: string;
+}
+/**
+ * Stream completed
+ */
+interface DoneEvent extends BaseEvent {
+    type: "done";
+    requiresAction?: boolean;
+    messages?: DoneEventMessage[];
+    /** Token usage (server-side only, stripped before sending to client) */
+    usage?: TokenUsageRaw;
+    /** Session ID — present when storage adapter created a session for this request */
+    threadId?: string;
+}
+/**
+ * Union of all stream events
+ */
+type StreamEvent = MessageStartEvent | MessageDeltaEvent | MessageEndEvent | ThinkingStartEvent | ThinkingDeltaEvent | ThinkingEndEvent | ActionStartEvent | ActionArgsEvent | ActionEndEvent | ToolCallsEvent | ToolResultEvent | CitationEvent | LoopIterationEvent | LoopCompleteEvent | ErrorEvent | ThreadCreatedEvent | DoneEvent;
+/**
+ * Structured-output / JSON-mode request format.
+ *
+ * Uses OpenAI's `response_format` shape as the unified surface; each adapter
+ * translates to its provider's native field (Anthropic `output_config`,
+ * Gemini `responseJsonSchema`, Ollama `format`, etc.).
+ */
+type ResponseFormat = {
+    type: "json_object";
+} | {
+    type: "json_schema";
+    json_schema: {
+        name: string;
+        schema: Record<string, unknown>;
+        strict?: boolean;
+    };
+};
+/**
+ * MCP (Model Context Protocol) server reference for a request.
+ *
+ * Vendor-neutral shape — each adapter translates to its provider's native
+ * field: OpenAI Responses `tools[type=mcp]`, Anthropic `mcp_servers` +
+ * `tools[type=mcp_toolset]` (beta `mcp-client-2025-11-20`), or local
+ * execution for adapters without native MCP.
+ */
+interface McpServerConfig {
+    /** Human-readable label sent to the provider (also used as MCP server name). */
+    label: string;
+    /** MCP server endpoint (HTTP/SSE URL). */
+    url: string;
+    /** Additional HTTP headers; the `Authorization` value is also extracted for providers that take a separate token field. */
+    headers?: Record<string, string>;
+    /** Restrict the model to a subset of the MCP server's exposed tools. */
+    allowedTools?: string[];
+    /** Approval policy for tool invocation. Defaults to "never" (no human-in-the-loop). */
+    requireApproval?: "never" | "always";
+}
+/**
+ * Reasoning effort knob — normalized across providers.
+ *
+ * Maps to OpenAI Responses `reasoning.effort`, Anthropic `thinking`
+ * (adaptive+effort on Claude 4.6/4.7, budget_tokens on older models),
+ * Gemini `thinkingBudget`, xAI `reasoning_effort`. Adapters silently
+ * no-op when the underlying model doesn't support reasoning.
+ *
+ * Use the enum for the common case, or `{ budgetTokens }` / `{ raw }`
+ * for provider-specific escape hatches when full fidelity is required.
+ */
+type ReasoningEffort = "minimal" | "low" | "medium" | "high" | {
+    budgetTokens: number;
+} | {
+    raw: Record<string, unknown>;
+};
+/**
+ * LLM configuration
+ */
+interface LLMConfig {
+    temperature?: number;
+    maxTokens?: number;
+    responseFormat?: ResponseFormat;
+    mcpServers?: McpServerConfig[];
+    reasoningEffort?: ReasoningEffort;
+}
+/**
+ * Tool call format (OpenAI style)
+ */
+interface ToolCall$1 {
+    id: string;
+    type: "function";
+    function: {
+        name: string;
+        arguments: string;
+    };
+    /** Provider-specific metadata (e.g. Gemini 3 thought_signature in extra_content.google) */
+    extra_content?: Record<string, unknown>;
+}
+/**
+ * Message role
+ */
+type MessageRole = "system" | "user" | "assistant" | "tool";
+/**
+ * Message attachment
+ */
+interface MessageAttachment {
+    type: "image" | "file" | "audio" | "video";
+    data?: string;
+    url?: string;
+    mimeType: string;
+    filename?: string;
+}
+/**
+ * Message metadata
+ */
+interface MessageMetadata {
+    thinking?: string;
+    attachments?: MessageAttachment[];
+    toolName?: string;
+    [key: string]: unknown;
+}
+/**
+ * Message type (simplified for llm-sdk)
+ */
+interface Message {
+    id: string;
+    thread_id?: string;
+    role: MessageRole;
+    content: string | null;
+    tool_calls?: ToolCall$1[];
+    tool_call_id?: string;
+    metadata?: MessageMetadata;
+    created_at?: Date;
+}
+/**
+ * Action parameter definition
+ */
+interface ActionParameter {
+    type: string;
+    description?: string;
+    required?: boolean;
+    enum?: string[];
+    items?: ActionParameter;
+    properties?: Record<string, ActionParameter>;
+}
+/**
+ * Action definition for tool calling
+ */
+interface ActionDefinition<TParams = Record<string, unknown>> {
+    name: string;
+    description: string;
+    parameters?: Record<string, ActionParameter>;
+    handler: (params: TParams) => unknown | Promise<unknown>;
+}
+/**
+ * Tool location (server or client)
+ */
+type ToolLocation = "server" | "client";
+/**
+ * Tool execution status
+ */
+type ToolExecutionStatus = "pending" | "executing" | "completed" | "error";
+/**
+ * Tool response
+ */
+interface ToolResponse<T = unknown> {
+    success: boolean;
+    data?: T;
+    error?: string;
+    /** Internal: AI response mode override */
+    _aiResponseMode?: AIResponseMode;
+    /** Internal: AI content for multimodal response (images, etc.) */
+    _aiContent?: AIContent[];
+    /** Internal: AI context string override */
+    _aiContext?: string;
+}
+/**
+ * Tool context passed to handlers
+ */
+interface ToolContext$1 {
+    userId?: string;
+    threadId?: string;
+    [key: string]: unknown;
+}
+/**
+ * AI response mode for tool results
+ */
+type AIResponseMode = "none" | "brief" | "full";
+/**
+ * AI content structure
+ */
+interface AIContent {
+    type?: "text" | "image";
+    text?: string;
+    mediaType?: string;
+    data?: string;
+    summary?: string;
+    details?: string;
+}
+/**
+ * JSON Schema for tool input
+ */
+interface ToolInputSchema {
+    type: "object";
+    properties?: Record<string, unknown>;
+    required?: string[];
+}
+/**
+ * Tool definition
+ */
+interface ToolDefinition<TParams = Record<string, unknown>> {
+    name: string;
+    description: string;
+    location: ToolLocation;
+    /** Optional logical category for tool search and selective loading. */
+    category?: string;
+    /** Optional group label for related tools. */
+    group?: string;
+    title?: string | ((args: TParams) => string);
+    inputSchema?: ToolInputSchema;
+    handler?: (params: TParams, context?: ToolContext$1) => unknown | Promise<unknown>;
+    render?: (props: unknown) => unknown;
+    available?: boolean;
+    /**
+     * Hide this tool's execution from the chat UI.
+     * When true, tool calls and results won't be displayed to the user,
+     * but the tool will still execute normally.
+     * @default false
+     */
+    hidden?: boolean;
+    needsApproval?: boolean;
+    approvalMessage?: string | ((params: TParams) => string);
+    /** AI response mode for this tool (none, brief, full) */
+    aiResponseMode?: AIResponseMode;
+    /** AI context string or function to generate context */
+    aiContext?: string | ((result: ToolResponse, args: Record<string, unknown>) => string);
+    /** Hint that this tool should be loaded lazily when dynamic selection is active. */
+    deferLoading?: boolean;
+    /** Named profiles this tool belongs to (for example "coding" or "search"). */
+    profiles?: string[];
+    /** Extra keywords used by lightweight tool search/ranking. */
+    searchKeywords?: string[];
+}
+interface ToolProfile {
+    include?: string[];
+    exclude?: string[];
+}
+interface OpenAIToolSelectionHints {
+    /**
+     * "single" forces the selected tool when exactly one tool remains after selection.
+     * Otherwise the adapter falls back to automatic tool choice.
+     */
+    toolChoice?: "auto" | "required" | "single";
+    /** Set false to disable parallel tool calls on OpenAI-compatible providers. */
+    parallelToolCalls?: boolean;
+}
+interface AnthropicToolSelectionHints {
+    /**
+     * "single" forces the selected tool when exactly one tool remains after selection.
+     * Otherwise the adapter falls back to Anthropic's automatic tool choice.
+     */
+    toolChoice?: "auto" | "any" | "single";
+    /** Disable parallel tool use when supported by the Anthropic API. */
+    disableParallelToolUse?: boolean;
+}
+interface ToolNativeProviderHints {
+    openai?: OpenAIToolSelectionHints;
+    anthropic?: AnthropicToolSelectionHints;
+}
+interface OpenAIProviderToolOptions {
+    toolChoice?: "auto" | "required" | {
+        type: "function";
+        name: string;
+    };
+    parallelToolCalls?: boolean;
+    nativeToolSearch?: {
+        enabled: boolean;
+        useResponsesApi?: boolean;
+    };
+}
+interface AnthropicProviderToolOptions {
+    toolChoice?: "auto" | "any" | {
+        type: "tool";
+        name: string;
+    };
+    disableParallelToolUse?: boolean;
+    nativeToolSearch?: {
+        enabled: boolean;
+        variant: "bm25" | "regex";
+    };
+}
+interface ProviderToolRuntimeOptions {
+    openai?: OpenAIProviderToolOptions;
+    anthropic?: AnthropicProviderToolOptions;
+}
+/**
+ * Web search configuration for native provider search
+ *
+ * Enables native web search for supported providers:
+ * - Anthropic: Uses Claude's built-in web search tool
+ * - OpenAI: Uses GPT's web search preview
+ * - Google: Uses Gemini's Google Search grounding
+ *
+ * @example
+ * ```typescript
+ * const runtime = createRuntime({
+ *   provider: createAnthropic({ apiKey: '...' }),
+ *   model: 'claude-sonnet-4-20250514',
+ *   webSearch: true, // Enable with defaults
+ * });
+ *
+ * // Or with configuration
+ * const runtime = createRuntime({
+ *   provider: createOpenAI({ apiKey: '...' }),
+ *   model: 'gpt-4o',
+ *   webSearch: {
+ *     maxUses: 5,
+ *     allowedDomains: ['docs.anthropic.com', 'openai.com'],
+ *   },
+ * });
+ * ```
+ */
+interface WebSearchConfig {
+    /** Maximum number of search uses per request (default: unlimited) */
+    maxUses?: number;
+    /** Only search these domains (provider-specific support) */
+    allowedDomains?: string[];
+    /** Exclude these domains from search (provider-specific support) */
+    blockedDomains?: string[];
+    /** User location for localized results (Anthropic only) */
+    userLocation?: {
+        type: "approximate";
+        city?: string;
+        region?: string;
+        country?: string;
+        timezone?: string;
+    };
+}
+/**
+ * Unified tool call format
+ */
+interface UnifiedToolCall {
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+}
+/**
+ * Unified tool result format
+ */
+interface UnifiedToolResult {
+    toolCallId: string;
+    content: string;
+    success: boolean;
+    error?: string;
+}
+/**
+ * Tool execution state
+ */
+interface ToolExecution {
+    id: string;
+    name: string;
+    args: Record<string, unknown>;
+    status: ToolExecutionStatus;
+    result?: ToolResponse;
+}
+/**
+ * Knowledge base provider
+ */
+type KnowledgeBaseProvider = "pinecone" | "qdrant" | "weaviate" | "custom";
+/**
+ * Knowledge base configuration
+ */
+interface KnowledgeBaseConfig {
+    id: string;
+    name?: string;
+    provider: KnowledgeBaseProvider;
+    apiKey?: string;
+    index?: string;
+}
+
+/**
+ * A language model instance that can generate text.
+ * This is what provider functions like `openai('gpt-4o')` return.
+ */
+interface LanguageModel {
+    /** Provider identifier (e.g., 'openai', 'anthropic') */
+    readonly provider: string;
+    /** Model identifier (e.g., 'gpt-4o', 'claude-3-5-sonnet') */
+    readonly modelId: string;
+    /** Model capabilities for feature detection */
+    readonly capabilities: ModelCapabilities;
+    /**
+     * Generate a complete response (non-streaming)
+     * Used internally by generateText()
+     */
+    doGenerate(params: DoGenerateParams): Promise<DoGenerateResult>;
+    /**
+     * Stream a response
+     * Used internally by streamText()
+     */
+    doStream(params: DoGenerateParams): AsyncGenerator<StreamChunk>;
+}
+/**
+ * Model capabilities for UI feature flags
+ */
+interface ModelCapabilities {
+    /** Supports image inputs */
+    supportsVision: boolean;
+    /** Supports tool/function calling */
+    supportsTools: boolean;
+    /** Supports streaming responses */
+    supportsStreaming: boolean;
+    /** Supports JSON mode / structured output */
+    supportsJsonMode: boolean;
+    /** Supports extended thinking (Claude) */
+    supportsThinking: boolean;
+    /** Supports PDF document inputs */
+    supportsPDF: boolean;
+    /** Maximum context tokens */
+    maxTokens: number;
+    /** Supported image MIME types */
+    supportedImageTypes: string[];
+}
+/**
+ * Default capabilities for unknown models
+ */
+declare const DEFAULT_CAPABILITIES: ModelCapabilities;
+/**
+ * Core message types for LLM conversations
+ */
+type CoreMessage = SystemMessage | UserMessage | AssistantMessage | ToolMessage;
+interface SystemMessage {
+    role: "system";
+    content: string;
+}
+interface UserMessage {
+    role: "user";
+    content: string | UserContentPart[];
+}
+interface AssistantMessage {
+    role: "assistant";
+    content: string | null;
+    toolCalls?: ToolCall[];
+}
+interface ToolMessage {
+    role: "tool";
+    toolCallId: string;
+    content: string;
+}
+/**
+ * Content parts for multimodal user messages
+ */
+type UserContentPart = TextPart | ImagePart | FilePart | AudioPart;
+interface TextPart {
+    type: "text";
+    text: string;
+}
+interface ImagePart {
+    type: "image";
+    /** Base64 data or URL */
+    image: string | Uint8Array;
+    /** MIME type (e.g., 'image/png') */
+    mimeType?: string;
+}
+interface FilePart {
+    type: "file";
+    /** Base64 data or URL */
+    data: string;
+    /** MIME type (e.g., 'application/pdf') */
+    mimeType: string;
+}
+interface AudioPart {
+    type: "input_audio";
+    input_audio: {
+        /** Base64-encoded audio data */
+        data: string;
+        /** Audio format (e.g., 'mp3', 'wav', 'ogg', 'webm', 'm4a', 'flac') */
+        format: string;
+    };
+}
+/**
+ * Tool definition with Zod schema support
+ */
+interface Tool<TParams = unknown, TResult = unknown> {
+    /** Tool description for the LLM */
+    description: string;
+    /** Zod schema for parameters */
+    parameters: z.ZodType<TParams>;
+    /** Execute function */
+    execute: (params: TParams, context: ToolContext) => Promise<TResult>;
+    /**
+     * Hide this tool's execution from the chat UI.
+     * When true, tool calls and results won't be displayed to the user,
+     * but the tool will still execute normally.
+     * @default false
+     */
+    hidden?: boolean;
+}
+/**
+ * Context passed to tool execute function
+ */
+interface ToolContext {
+    /** Abort signal for cancellation */
+    abortSignal?: AbortSignal;
+    /** Unique tool call ID */
+    toolCallId: string;
+    /** Optional: messages in conversation */
+    messages?: CoreMessage[];
+}
+/**
+ * Tool call from LLM response
+ */
+interface ToolCall {
+    /** Unique ID for this tool call */
+    id: string;
+    /** Tool name */
+    name: string;
+    /** Parsed arguments */
+    args: Record<string, unknown>;
+}
+/**
+ * Tool execution result
+ */
+interface ToolResult {
+    /** Tool call ID this result corresponds to */
+    toolCallId: string;
+    /** Result data (will be JSON stringified for LLM) */
+    result: unknown;
+}
+/**
+ * Parameters for model.doGenerate() and model.doStream()
+ */
+interface DoGenerateParams {
+    /** Messages to send to LLM */
+    messages: CoreMessage[];
+    /** Tools available to the LLM (already formatted for provider) */
+    tools?: unknown[];
+    /** Temperature (0-2) */
+    temperature?: number;
+    /** Maximum tokens to generate */
+    maxTokens?: number;
+    /** Structured-output / JSON-mode request format (provider-translated) */
+    responseFormat?: ResponseFormat;
+    /** MCP servers exposed to the model (provider-translated). */
+    mcpServers?: McpServerConfig[];
+    /** Reasoning/thinking effort knob (provider-translated). */
+    reasoningEffort?: ReasoningEffort;
+    /** Abort signal */
+    signal?: AbortSignal;
+}
+/**
+ * Result from model.doGenerate()
+ */
+interface DoGenerateResult {
+    /** Generated text content */
+    text: string;
+    /** Tool calls requested by the LLM */
+    toolCalls: ToolCall[];
+    /** Why generation stopped */
+    finishReason: FinishReason;
+    /** Token usage */
+    usage: TokenUsage;
+    /** Raw provider response (for debugging) */
+    rawResponse?: unknown;
+}
+/**
+ * Finish reason for generation
+ */
+type FinishReason = "stop" | "length" | "tool-calls" | "content-filter" | "error" | "unknown";
+/**
+ * Token usage statistics
+ */
+interface TokenUsage {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+}
+/**
+ * Stream chunk from model.doStream()
+ */
+type StreamChunk = TextDeltaChunk | ToolCallChunk | ToolResultChunk | FinishChunk | ErrorChunk;
+interface TextDeltaChunk {
+    type: "text-delta";
+    text: string;
+}
+interface ToolCallChunk {
+    type: "tool-call";
+    toolCall: ToolCall;
+}
+interface ToolResultChunk {
+    type: "tool-result";
+    toolCallId: string;
+    result: unknown;
+}
+interface FinishChunk {
+    type: "finish";
+    finishReason: FinishReason;
+    usage?: TokenUsage;
+}
+interface ErrorChunk {
+    type: "error";
+    error: Error;
+}
+/**
+ * Parameters for generateText()
+ */
+interface GenerateTextParams {
+    /** Language model to use */
+    model: LanguageModel;
+    /** Simple prompt (converted to user message) */
+    prompt?: string;
+    /** System prompt */
+    system?: string;
+    /** Full message history */
+    messages?: CoreMessage[];
+    /** Tools available to the LLM */
+    tools?: Record<string, Tool>;
+    /** Maximum agentic steps (tool call loops) */
+    maxSteps?: number;
+    /** Temperature (0-2) */
+    temperature?: number;
+    /** Maximum tokens to generate */
+    maxTokens?: number;
+    /** Structured-output / JSON-mode request format */
+    responseFormat?: ResponseFormat;
+    /** MCP servers exposed to the model (provider-translated). */
+    mcpServers?: McpServerConfig[];
+    /** Reasoning/thinking effort knob (provider-translated). */
+    reasoningEffort?: ReasoningEffort;
+    /** Abort signal */
+    signal?: AbortSignal;
+}
+/**
+ * Result from generateText()
+ */
+interface GenerateTextResult {
+    /** Final text output */
+    text: string;
+    /** Token usage */
+    usage: TokenUsage;
+    /** Why generation stopped */
+    finishReason: FinishReason;
+    /** All steps taken (for agentic workflows) */
+    steps: GenerateStep[];
+    /** All tool calls made across all steps */
+    toolCalls: ToolCall[];
+    /** All tool results across all steps */
+    toolResults: ToolResult[];
+    /** Final message list including tool interactions */
+    response: {
+        messages: CoreMessage[];
+    };
+}
+/**
+ * A single step in the generation process
+ */
+interface GenerateStep {
+    /** Text generated in this step */
+    text: string;
+    /** Tool calls made in this step */
+    toolCalls: ToolCall[];
+    /** Tool results from this step */
+    toolResults: ToolResult[];
+    /** Finish reason for this step */
+    finishReason: FinishReason;
+    /** Token usage for this step */
+    usage: TokenUsage;
+}
+/**
+ * Parameters for streamText() - same as generateText
+ */
+type StreamTextParams = GenerateTextParams;
+/**
+ * Result from streamText()
+ */
+interface StreamTextResult {
+    /** Async iterable of text chunks only */
+    textStream: AsyncIterable<string>;
+    /** Async iterable of all stream parts */
+    fullStream: AsyncIterable<StreamPart>;
+    /** Promise that resolves to full text when complete */
+    readonly text: Promise<string>;
+    /** Promise that resolves to usage when complete */
+    readonly usage: Promise<TokenUsage>;
+    /** Promise that resolves to finish reason when complete */
+    readonly finishReason: Promise<FinishReason>;
+    /** Convert to plain text streaming Response */
+    toTextStreamResponse(options?: ResponseOptions): Response;
+    /** Convert to data stream Response (SSE with tool calls) */
+    toDataStreamResponse(options?: ResponseOptions): Response;
+}
+/**
+ * Stream part for fullStream
+ */
+type StreamPart = {
+    type: "text-delta";
+    text: string;
+} | {
+    type: "tool-call-start";
+    toolCallId: string;
+    toolName: string;
+} | {
+    type: "tool-call-delta";
+    toolCallId: string;
+    argsText: string;
+} | {
+    type: "tool-call-complete";
+    toolCall: ToolCall;
+} | {
+    type: "tool-result";
+    toolCallId: string;
+    result: unknown;
+} | {
+    type: "step-start";
+    step: number;
+} | {
+    type: "step-finish";
+    step: number;
+    finishReason: FinishReason;
+} | {
+    type: "finish";
+    finishReason: FinishReason;
+    usage: TokenUsage;
+} | {
+    type: "error";
+    error: Error;
+};
+/**
+ * Options for Response helpers
+ */
+interface ResponseOptions {
+    /** Additional headers */
+    headers?: Record<string, string>;
+    /** Response status (default: 200) */
+    status?: number;
+}
+/**
+ * Message format for storage adapters.
+ * Intentionally simpler than LLM-specific formats — adapters convert as needed.
+ */
+interface StorageMessage {
+    role: "user" | "assistant" | "system" | "tool";
+    content: string;
+    toolCalls?: unknown[];
+    toolCallId?: string;
+    /** Content type for the message — determines how it's stored in the backend */
+    contentType?: "text" | "image" | "file";
+    /** URL for image/file attachments */
+    url?: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Generic storage adapter interface for session + message persistence.
+ *
+ * `createYourGPT()` is the default implementation for YourGPT platform.
+ * Third-party developers can implement this interface for custom backends.
+ *
+ * @example
+ * ```ts
+ * import { createRuntime } from '@yourgpt/llm-sdk'
+ * import { createYourGPT } from '@yourgpt/llm-sdk/yourgpt'
+ *
+ * const runtime = createRuntime({
+ *   provider: anthropic,
+ *   model: 'claude-haiku-4-5',
+ *   storage: createYourGPT({ apiKey, widgetUid }),
+ * })
+ * // runtime.chat() and runtime.stream() now auto-persist messages
+ * ```
+ */
+interface StorageAdapter {
+    /** Create a new session. Returns session ID to use as threadId. */
+    createSession(data?: {
+        title?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<{
+        id: string;
+    }>;
+    /** Append messages to a session (called sequentially — input before output). */
+    saveMessages(sessionId: string, messages: StorageMessage[]): Promise<void>;
+    /** List sessions (optional — used for thread picker sync in future). */
+    getSessions?(): Promise<{
+        id: string;
+        title?: string;
+        updatedAt?: Date;
+    }[]>;
+    /** Get messages for a session (optional — used for thread restore in future). */
+    getMessages?(sessionId: string): Promise<StorageMessage[]>;
+    /**
+     * Upload a file to storage. Returns a URL the LLM can reference.
+     * When present, the server exposes a /upload endpoint and the client
+     * uses it instead of embedding base64 in the message body.
+     */
+    uploadFile?(file: StorageFile): Promise<{
+        url: string;
+    }>;
+}
+/**
+ * File data for upload via StorageAdapter.uploadFile()
+ */
+interface StorageFile {
+    /** Base64-encoded file data (with or without data URI prefix) */
+    data: string;
+    /** MIME type (e.g., "image/png", "application/pdf") */
+    mimeType: string;
+    /** Original filename */
+    filename?: string;
+}
+
+export { type UnifiedToolCall as $, type ActionDefinition as A, type TextDeltaChunk as B, type CoreMessage as C, type DoneEventMessage as D, type ToolCallChunk as E, type FilePart as F, type GenerateTextParams as G, type ToolResultChunk as H, type ImagePart as I, type FinishChunk as J, type KnowledgeBaseConfig as K, type LanguageModel as L, type McpServerConfig as M, type ErrorChunk as N, type TokenUsage as O, type ProviderToolRuntimeOptions as P, type FinishReason as Q, type ResponseFormat as R, type StreamTextParams as S, type ToolContext as T, type UserMessage as U, type ResponseOptions as V, type WebSearchConfig as W, type StorageFile as X, DEFAULT_CAPABILITIES as Y, type LLMConfig as Z, type ToolLocation as _, type GenerateTextResult as a, type UnifiedToolResult as a0, type ToolExecution as a1, type OpenAIToolSelectionHints as a2, type AnthropicToolSelectionHints as a3, type ToolNativeProviderHints as a4, type OpenAIProviderToolOptions as a5, type AnthropicProviderToolOptions as a6, type Citation as a7, type MessageAttachment as a8, type StreamTextResult as b, type Tool as c, type ToolDefinition as d, type ToolProfile as e, type StorageAdapter as f, type ReasoningEffort as g, type StreamEvent as h, type ToolCallInfo as i, type TokenUsageRaw as j, type Message as k, type ToolResponse as l, type StorageMessage as m, type ModelCapabilities as n, type DoGenerateParams as o, type DoGenerateResult as p, type SystemMessage as q, type AssistantMessage as r, type ToolMessage as s, type UserContentPart as t, type TextPart as u, type ToolCall as v, type ToolResult as w, type GenerateStep as x, type StreamPart as y, type StreamChunk as z };