@providerprotocol/ai 0.0.34 → 0.0.36

package/dist/{llm-BQJZj3cD.d.ts → llm-ByUFPcFH.d.ts}

@@ -1,1633 +1,4 @@
-/**
- * @fileoverview Content block types for multimodal messages.
- *
- * Defines the various content block types that can be included in
- * user and assistant messages, supporting text, images, audio, video,
- * and arbitrary binary data.
- *
- * @module types/content
- */
-/**
- * Content block type constants.
- *
- * Use these constants instead of raw strings for type-safe content handling:
- *
- * @example
- * ```typescript
- * import { ContentBlockType } from 'upp';
- *
- * if (block.type === ContentBlockType.Text) {
- *   console.log(block.text);
- * } else if (block.type === ContentBlockType.Image) {
- *   console.log(block.mimeType);
- * }
- * ```
- */
-declare const ContentBlockType: {
-    /** Text content */
-    readonly Text: "text";
-    /** Reasoning/thinking content from extended thinking models */
-    readonly Reasoning: "reasoning";
-    /** Image content */
-    readonly Image: "image";
-    /** Document content (PDFs, text files) */
-    readonly Document: "document";
-    /** Audio content */
-    readonly Audio: "audio";
-    /** Video content */
-    readonly Video: "video";
-    /** Binary/arbitrary data content */
-    readonly Binary: "binary";
-};
-/**
- * Content block type discriminator union.
- *
- * This type is derived from {@link ContentBlockType} constants.
- */
-type ContentBlockType = (typeof ContentBlockType)[keyof typeof ContentBlockType];
-/**
- * Image source type constants.
- *
- * @example
- * ```typescript
- * import { ImageSourceType } from 'upp';
- *
- * if (source.type === ImageSourceType.Base64) {
- *   // Handle base64 encoded image
- * } else if (source.type === ImageSourceType.Url) {
- *   // Handle URL reference
- * }
- * ```
- */
-declare const ImageSourceType: {
-    /** Base64-encoded image data */
-    readonly Base64: "base64";
-    /** URL reference to image */
-    readonly Url: "url";
-    /** Raw bytes image data */
-    readonly Bytes: "bytes";
-};
-/**
- * Image source type discriminator union.
- *
- * This type is derived from {@link ImageSourceType} constants.
- */
-type ImageSourceType = (typeof ImageSourceType)[keyof typeof ImageSourceType];
-/**
- * Image source variants for ImageBlock.
- *
- * Images can be provided as base64-encoded strings, URLs, or raw bytes.
- *
- * @example
- * ```typescript
- * // Base64 encoded image
- * const base64Source: ImageSource = {
- *   type: 'base64',
- *   data: 'iVBORw0KGgo...'
- * };
- *
- * // URL reference
- * const urlSource: ImageSource = {
- *   type: 'url',
- *   url: 'https://example.com/image.png'
- * };
- *
- * // Raw bytes
- * const bytesSource: ImageSource = {
- *   type: 'bytes',
- *   data: new Uint8Array([...])
- * };
- * ```
- */
-type ImageSource = {
-    type: 'base64';
-    data: string;
-} | {
-    type: 'url';
-    url: string;
-} | {
-    type: 'bytes';
-    data: Uint8Array;
-};
-/**
- * Document source type constants.
- *
- * @example
- * ```typescript
- * import { DocumentSourceType } from 'upp';
- *
- * if (source.type === DocumentSourceType.Base64) {
- *   // Handle base64 encoded document (PDF)
- * } else if (source.type === DocumentSourceType.Url) {
- *   // Handle URL reference (PDF)
- * } else if (source.type === DocumentSourceType.Text) {
- *   // Handle plain text document
- * }
- * ```
- */
-declare const DocumentSourceType: {
-    /** Base64-encoded document data (for PDFs) */
-    readonly Base64: "base64";
-    /** URL reference to document (for PDFs) */
-    readonly Url: "url";
-    /** Plain text document content */
-    readonly Text: "text";
-};
-/**
- * Document source type discriminator union.
- *
- * This type is derived from {@link DocumentSourceType} constants.
- */
-type DocumentSourceType = (typeof DocumentSourceType)[keyof typeof DocumentSourceType];
-/**
- * Document source variants for DocumentBlock.
- *
- * Documents can be provided as base64-encoded data (PDFs), URLs (PDFs), or plain text.
- *
- * @example
- * ```typescript
- * // Base64 encoded PDF
- * const base64Source: DocumentSource = {
- *   type: 'base64',
- *   data: 'JVBERi0xLjQK...'
- * };
- *
- * // URL reference to PDF
- * const urlSource: DocumentSource = {
- *   type: 'url',
- *   url: 'https://example.com/document.pdf'
- * };
- *
- * // Plain text document
- * const textSource: DocumentSource = {
- *   type: 'text',
- *   data: 'This is the document content...'
- * };
- * ```
- */
-type DocumentSource = {
-    type: 'base64';
-    data: string;
-} | {
-    type: 'url';
-    url: string;
-} | {
-    type: 'text';
-    data: string;
-};
-/**
- * Text content block.
- *
- * The most common content block type, containing plain text content.
- *
- * @example
- * ```typescript
- * const textBlock: TextBlock = {
- *   type: 'text',
- *   text: 'Hello, world!'
- * };
- * ```
- */
-interface TextBlock {
-    /** Discriminator for text blocks */
-    type: 'text';
-    /** The text content */
-    text: string;
-}
-/**
- * Reasoning content block.
- *
- * Contains model reasoning/thinking from extended thinking or chain-of-thought.
- * This content represents the model's internal reasoning process.
- *
- * @example
- * ```typescript
- * const reasoningBlock: ReasoningBlock = {
- *   type: 'reasoning',
- *   text: 'Let me think about this step by step...'
- * };
- * ```
- */
-interface ReasoningBlock {
-    /** Discriminator for reasoning blocks */
-    type: 'reasoning';
-    /** The reasoning/thinking text */
-    text: string;
-}
-/**
- * Image content block.
- *
- * Contains an image with its source data and metadata.
- *
- * @example
- * ```typescript
- * const imageBlock: ImageBlock = {
- *   type: 'image',
- *   source: { type: 'url', url: 'https://example.com/photo.jpg' },
- *   mimeType: 'image/jpeg',
- *   width: 1920,
- *   height: 1080
- * };
- * ```
- */
-interface ImageBlock {
-    /** Discriminator for image blocks */
-    type: 'image';
-    /** The image data source */
-    source: ImageSource;
-    /** MIME type of the image (e.g., 'image/png', 'image/jpeg') */
-    mimeType: string;
-    /** Image width in pixels */
-    width?: number;
-    /** Image height in pixels */
-    height?: number;
-}
-/**
- * Document content block.
- *
- * Contains a document (PDF or plain text) with its source and metadata.
- * Supports PDF documents via base64 encoding or URL, and plain text content.
- *
- * @example
- * ```typescript
- * // PDF document from base64
- * const pdfBlock: DocumentBlock = {
- *   type: 'document',
- *   source: { type: 'base64', data: 'JVBERi0xLjQK...' },
- *   mimeType: 'application/pdf',
- *   title: 'Annual Report'
- * };
- *
- * // Plain text document
- * const textDoc: DocumentBlock = {
- *   type: 'document',
- *   source: { type: 'text', data: 'Document contents here...' },
- *   mimeType: 'text/plain'
- * };
- * ```
- */
-interface DocumentBlock {
-    /** Discriminator for document blocks */
-    type: 'document';
-    /** The document data source */
-    source: DocumentSource;
-    /** MIME type of the document ('application/pdf' or 'text/plain') */
-    mimeType: string;
-    /** Optional document title (used for citations) */
-    title?: string;
-}
-/**
- * Audio content block.
- *
- * Contains audio data with its metadata.
- *
- * @example
- * ```typescript
- * const audioBlock: AudioBlock = {
- *   type: 'audio',
- *   data: audioBytes,
- *   mimeType: 'audio/mp3',
- *   duration: 120.5
- * };
- * ```
- */
-interface AudioBlock {
-    /** Discriminator for audio blocks */
-    type: 'audio';
-    /** Raw audio data */
-    data: Uint8Array;
-    /** MIME type of the audio (e.g., 'audio/mp3', 'audio/wav') */
-    mimeType: string;
-    /** Duration in seconds */
-    duration?: number;
-}
-/**
- * Video content block.
- *
- * Contains video data with its metadata.
- *
- * @example
- * ```typescript
- * const videoBlock: VideoBlock = {
- *   type: 'video',
- *   data: videoBytes,
- *   mimeType: 'video/mp4',
- *   duration: 30,
- *   width: 1920,
- *   height: 1080
- * };
- * ```
- */
-interface VideoBlock {
-    /** Discriminator for video blocks */
-    type: 'video';
-    /** Raw video data */
-    data: Uint8Array;
-    /** MIME type of the video (e.g., 'video/mp4', 'video/webm') */
-    mimeType: string;
-    /** Duration in seconds */
-    duration?: number;
-    /** Video width in pixels */
-    width?: number;
-    /** Video height in pixels */
-    height?: number;
-}
-/**
- * Binary content block for arbitrary data.
- *
- * A generic block type for data that doesn't fit other categories.
- *
- * @example
- * ```typescript
- * const binaryBlock: BinaryBlock = {
- *   type: 'binary',
- *   data: pdfBytes,
- *   mimeType: 'application/pdf',
- *   metadata: { filename: 'document.pdf', pages: 10 }
- * };
- * ```
- */
-interface BinaryBlock {
-    /** Discriminator for binary blocks */
-    type: 'binary';
-    /** Raw binary data */
-    data: Uint8Array;
-    /** MIME type of the data */
-    mimeType: string;
-    /** Additional metadata about the binary content */
-    metadata?: Record<string, unknown>;
-}
-/**
- * Union of all content block types.
- *
- * Used when a function or property can accept any type of content block.
- */
-type ContentBlock = TextBlock | ReasoningBlock | ImageBlock | DocumentBlock | AudioBlock | VideoBlock | BinaryBlock;
-/**
- * Content types allowed in user messages.
- *
- * Users can send any type of content block including binary data.
- */
-type UserContent = TextBlock | ImageBlock | DocumentBlock | AudioBlock | VideoBlock | BinaryBlock;
-/**
- * Content types allowed in assistant messages.
- *
- * Assistants can generate text and media but not arbitrary binary data.
- */
-type AssistantContent = TextBlock | ReasoningBlock | ImageBlock | AudioBlock | VideoBlock;
-/**
- * Creates a text content block from a string.
- *
- * @param content - The text content
- * @returns A TextBlock containing the provided text
- *
- * @example
- * ```typescript
- * const block = text('Hello, world!');
- * // { type: 'text', text: 'Hello, world!' }
- * ```
- */
-declare function text(content: string): TextBlock;
-/**
- * Creates a reasoning content block from a string.
- *
- * @param content - The reasoning/thinking content
- * @returns A ReasoningBlock containing the provided text
- *
- * @example
- * ```typescript
- * const block = reasoning('Let me think step by step...');
- * // { type: 'reasoning', text: 'Let me think step by step...' }
- * ```
- */
-declare function reasoning(content: string): ReasoningBlock;
-/**
- * Type guard for TextBlock.
- *
- * @param block - The content block to check
- * @returns True if the block is a TextBlock
- *
- * @example
- * ```typescript
- * if (isTextBlock(block)) {
- *   console.log(block.text);
- * }
- * ```
- */
-declare function isTextBlock(block: ContentBlock): block is TextBlock;
-/**
- * Type guard for ReasoningBlock.
- *
- * @param block - The content block to check
- * @returns True if the block is a ReasoningBlock
- *
- * @example
- * ```typescript
- * if (isReasoningBlock(block)) {
- *   console.log(block.text);
- * }
- * ```
- */
-declare function isReasoningBlock(block: ContentBlock): block is ReasoningBlock;
-/**
- * Type guard for ImageBlock.
- *
- * @param block - The content block to check
- * @returns True if the block is an ImageBlock
- *
- * @example
- * ```typescript
- * if (isImageBlock(block)) {
- *   console.log(block.mimeType, block.width, block.height);
- * }
- * ```
- */
-declare function isImageBlock(block: ContentBlock): block is ImageBlock;
-/**
- * Type guard for DocumentBlock.
- *
- * @param block - The content block to check
- * @returns True if the block is a DocumentBlock
- *
- * @example
- * ```typescript
- * if (isDocumentBlock(block)) {
- *   console.log(block.mimeType, block.title);
- * }
- * ```
- */
-declare function isDocumentBlock(block: ContentBlock): block is DocumentBlock;
-/**
- * Type guard for AudioBlock.
- *
- * @param block - The content block to check
- * @returns True if the block is an AudioBlock
- *
- * @example
- * ```typescript
- * if (isAudioBlock(block)) {
- *   console.log(block.mimeType, block.duration);
- * }
- * ```
- */
-declare function isAudioBlock(block: ContentBlock): block is AudioBlock;
-/**
- * Type guard for VideoBlock.
- *
- * @param block - The content block to check
- * @returns True if the block is a VideoBlock
- *
- * @example
- * ```typescript
- * if (isVideoBlock(block)) {
- *   console.log(block.mimeType, block.duration);
- * }
- * ```
- */
-declare function isVideoBlock(block: ContentBlock): block is VideoBlock;
-/**
- * Type guard for BinaryBlock.
- *
- * @param block - The content block to check
- * @returns True if the block is a BinaryBlock
- *
- * @example
- * ```typescript
- * if (isBinaryBlock(block)) {
- *   console.log(block.mimeType, block.metadata);
- * }
- * ```
- */
-declare function isBinaryBlock(block: ContentBlock): block is BinaryBlock;
-
-/**
- * @fileoverview JSON Schema types for tool parameters and structured outputs.
- *
- * Provides TypeScript interfaces for defining JSON Schema objects used in
- * LLM tool definitions and structured output specifications.
- *
- * @module types/schema
- */
-/**
- * Primitive and composite JSON Schema property types.
- *
- * These types correspond to the JSON Schema specification's allowed type values.
- */
-type JSONSchemaPropertyType = 
-/** String values */
-'string'
-/** Floating point numbers */
- | 'number'
-/** Whole numbers */
- | 'integer'
-/** Boolean true/false values */
- | 'boolean'
-/** Ordered lists of values */
- | 'array'
-/** Key-value mappings */
- | 'object'
-/** Explicit null value */
- | 'null';
-/**
- * JSON Schema property definition.
- *
- * Describes a single property within a JSON Schema object, including
- * type constraints, validation rules, and nested structure definitions.
- *
- * @example
- * ```typescript
- * const nameProperty: JSONSchemaProperty = {
- *   type: 'string',
- *   description: 'User name',
- *   minLength: 1,
- *   maxLength: 100
- * };
- * ```
- *
- * @example
- * ```typescript
- * const tagsProperty: JSONSchemaProperty = {
- *   type: 'array',
- *   description: 'List of tags',
- *   items: { type: 'string' },
- *   minItems: 1,
- *   uniqueItems: true
- * };
- * ```
- */
-interface JSONSchemaProperty {
-    /** The JSON type of this property */
-    type: JSONSchemaPropertyType;
-    /** Human-readable description for the LLM */
-    description?: string;
-    /** Allowed values (enumeration) */
-    enum?: unknown[];
-    /** Constant value this property must equal */
-    const?: unknown;
-    /** Default value if not provided */
-    default?: unknown;
-    /** Minimum string length (string type only) */
-    minLength?: number;
-    /** Maximum string length (string type only) */
-    maxLength?: number;
-    /** Regular expression pattern for validation (string type only) */
-    pattern?: string;
-    /** Semantic format hint (string type only) */
-    format?: 'email' | 'uri' | 'date' | 'date-time' | 'uuid';
-    /** Minimum value inclusive (number/integer types only) */
-    minimum?: number;
-    /** Maximum value inclusive (number/integer types only) */
-    maximum?: number;
-    /** Minimum value exclusive (number/integer types only) */
-    exclusiveMinimum?: number;
-    /** Maximum value exclusive (number/integer types only) */
-    exclusiveMaximum?: number;
-    /** Value must be divisible by this (number/integer types only) */
-    multipleOf?: number;
-    /** Schema for array elements (array type only) */
-    items?: JSONSchemaProperty;
-    /** Minimum array length (array type only) */
-    minItems?: number;
-    /** Maximum array length (array type only) */
-    maxItems?: number;
-    /** Whether array elements must be unique (array type only) */
-    uniqueItems?: boolean;
-    /** Nested property definitions (object type only) */
-    properties?: Record<string, JSONSchemaProperty>;
-    /** List of required property names (object type only) */
-    required?: string[];
-    /** Whether additional properties are allowed (object type only) */
-    additionalProperties?: boolean;
-}
-/**
- * Root JSON Schema for tool parameters or structured outputs.
- *
- * This is the top-level schema definition used when defining tool
- * parameters or requesting structured output from an LLM.
- *
- * @example
- * ```typescript
- * const weatherToolSchema: JSONSchema = {
- *   type: 'object',
- *   description: 'Parameters for getting weather information',
- *   properties: {
- *     location: {
- *       type: 'string',
- *       description: 'City name or coordinates'
- *     },
- *     units: {
- *       type: 'string',
- *       enum: ['celsius', 'fahrenheit'],
- *       description: 'Temperature units'
- *     }
- *   },
- *   required: ['location']
- * };
- * ```
- */
-interface JSONSchema {
-    /** Root schemas are always objects */
-    type: 'object';
-    /** Property definitions for the object */
-    properties: Record<string, JSONSchemaProperty>;
-    /** List of required property names */
-    required?: string[];
-    /** Whether additional properties are allowed beyond those defined */
-    additionalProperties?: boolean;
-    /** Human-readable description of the schema's purpose */
-    description?: string;
-}
-
-/**
- * @fileoverview Tool types for LLM function calling.
- *
- * Defines the interfaces for registering tools with LLMs, handling
- * tool calls from the model, and managing tool execution strategies.
- *
- * @module types/tool
- */
-
-/**
- * Provider-namespaced metadata for tools.
- *
- * Each provider can attach its own metadata under its namespace,
- * enabling provider-specific features like caching, strict mode, etc.
- *
- * @example
- * ```typescript
- * const metadata: ToolMetadata = {
- *   anthropic: { cache_control: { type: 'ephemeral' } },
- *   openrouter: { cache_control: { type: 'ephemeral', ttl: '1h' } }
- * };
- * ```
- */
-interface ToolMetadata {
-    [provider: string]: Record<string, unknown> | undefined;
-}
-/**
- * Tool call requested by the model.
- *
- * Represents a single function call request from the LLM, including
- * the tool name and parsed arguments.
- *
- * @example
- * ```typescript
- * const toolCall: ToolCall = {
- *   toolCallId: 'call_abc123',
- *   toolName: 'get_weather',
- *   arguments: { location: 'San Francisco', units: 'celsius' }
- * };
- * ```
- */
-interface ToolCall {
-    /** Unique identifier for this tool call, used to match results */
-    toolCallId: string;
-    /** Name of the tool being called */
-    toolName: string;
-    /** Parsed arguments for the tool call */
-    arguments: Record<string, unknown>;
-}
-/**
- * Result of tool execution.
- *
- * Returned after executing a tool, containing the result data
- * and whether an error occurred.
- *
- * @example
- * ```typescript
- * const result: ToolResult = {
- *   toolCallId: 'call_abc123',
- *   result: { temperature: 72, conditions: 'sunny' }
- * };
- *
- * // Error result
- * const errorResult: ToolResult = {
- *   toolCallId: 'call_abc123',
- *   result: 'Location not found',
- *   isError: true
- * };
- * ```
- */
-interface ToolResult {
-    /** The tool call ID this result corresponds to */
-    toolCallId: string;
-    /** The result data (can be any serializable value) */
-    result: unknown;
-    /** Whether the tool execution resulted in an error */
-    isError?: boolean;
-}
-/**
- * Tool definition for LLM function calling.
- *
- * Defines a tool that can be called by the LLM, including its
- * name, description, parameter schema, and execution function.
- *
- * @typeParam TParams - The type of parameters the tool accepts
- * @typeParam TResult - The type of result the tool returns
- *
- * @example
- * ```typescript
- * const weatherTool: Tool<{ location: string }, WeatherData> = {
- *   name: 'get_weather',
- *   description: 'Get current weather for a location',
- *   parameters: {
- *     type: 'object',
- *     properties: {
- *       location: { type: 'string', description: 'City name' }
- *     },
- *     required: ['location']
- *   },
- *   run: async (params) => {
- *     return fetchWeather(params.location);
- *   }
- * };
- * ```
- */
-interface Tool<TParams = unknown, TResult = unknown> {
-    /** Tool name (must be unique within an llm() instance) */
-    name: string;
-    /** Human-readable description for the model to understand when to use this tool */
-    description: string;
-    /** JSON Schema defining the tool's parameters */
-    parameters: JSONSchema;
-    /**
-     * Provider-specific metadata, namespaced by provider name.
-     *
-     * Used for provider-specific features like prompt caching:
-     * @example
-     * ```typescript
-     * const tool: Tool = {
-     *   name: 'search_docs',
-     *   description: 'Search documentation',
-     *   parameters: {...},
-     *   run: async (params) => {...},
-     *   metadata: {
-     *     anthropic: { cache_control: { type: 'ephemeral' } }
-     *   }
-     * };
-     * ```
-     */
-    metadata?: ToolMetadata;
-    /**
-     * Executes the tool with the provided parameters.
-     *
-     * @param params - The parameters passed by the model
-     * @returns The tool result, synchronously or as a Promise
-     */
-    run(params: TParams): TResult | Promise<TResult>;
-    /**
-     * Optional approval handler for sensitive operations.
-     *
-     * If provided, this function is called before the tool executes.
-     * Return false to prevent execution.
-     *
-     * @param params - The parameters the tool would be called with
-     * @returns Whether to approve the execution
-     */
-    approval?(params: TParams): boolean | Promise<boolean>;
-}
-/**
- * Result from onBeforeCall hook indicating whether to proceed and optionally transformed params.
- */
-interface BeforeCallResult {
-    /** Whether to proceed with tool execution */
-    proceed: boolean;
-    /** Transformed parameters to use instead of the original (optional) */
-    params?: unknown;
-}
-/**
- * Result from onAfterCall hook optionally containing a transformed result.
- */
-interface AfterCallResult {
-    /** Transformed result to use instead of the original */
-    result: unknown;
-}
-/**
- * Strategy for controlling tool execution behavior.
- *
- * Provides hooks for monitoring, controlling, and transforming the tool execution
- * loop during LLM inference.
- *
- * @example
- * ```typescript
- * const strategy: ToolUseStrategy = {
- *   maxIterations: 5,
- *   onToolCall: (tool, params) => {
- *     console.log(`Calling ${tool.name} with`, params);
- *   },
- *   // Transform input parameters
- *   onBeforeCall: (tool, params) => {
- *     if (tool.name === 'search') {
- *       return { proceed: true, params: { ...params, limit: 10 } };
- *     }
- *     return true;
- *   },
- *   // Transform output results
- *   onAfterCall: (tool, params, result) => {
- *     if (tool.name === 'fetch_data') {
- *       return { result: sanitize(result) };
- *     }
- *   },
- *   onMaxIterations: (iterations) => {
- *     console.warn(`Reached max iterations: ${iterations}`);
- *   }
- * };
- * ```
- */
-interface ToolUseStrategy {
-    /** Maximum number of tool execution rounds (default: 10) */
-    maxIterations?: number;
-    /**
-     * Called when the model requests a tool call.
-     *
-     * @param tool - The tool being called
-     * @param params - The parameters for the call
-     */
-    onToolCall?(tool: Tool, params: unknown): void | Promise<void>;
-    /**
-     * Called before tool execution. Can skip execution or transform parameters.
-     *
-     * @param tool - The tool about to be executed
-     * @param params - The parameters for the call
-     * @returns One of:
-     *   - `false` to skip execution
-     *   - `true` to proceed with original params
-     *   - `BeforeCallResult` object to control execution and optionally transform params
-     */
-    onBeforeCall?(tool: Tool, params: unknown): boolean | BeforeCallResult | Promise<boolean | BeforeCallResult>;
-    /**
-     * Called after tool execution completes. Can transform the result.
-     *
-     * @param tool - The tool that was executed
-     * @param params - The parameters that were used
-     * @param result - The result from the tool
-     * @returns Void to use original result, or `AfterCallResult` to transform it
-     */
-    onAfterCall?(tool: Tool, params: unknown, result: unknown): void | AfterCallResult | Promise<void | AfterCallResult>;
-    /**
-     * Called when a tool execution throws an error.
-     *
-     * @param tool - The tool that failed
-     * @param params - The parameters that were used
-     * @param error - The error that was thrown
-     */
-    onError?(tool: Tool, params: unknown, error: Error): void | Promise<void>;
-    /**
-     * Called when the maximum iteration limit is reached.
-     *
-     * @param iterations - The number of iterations that were performed
-     */
-    onMaxIterations?(iterations: number): void | Promise<void>;
-}
-/**
- * Record of a completed tool execution.
- *
- * Contains all information about a tool call that was executed,
- * including timing and result data.
- *
- * @example
- * ```typescript
- * const execution: ToolExecution = {
- *   toolName: 'get_weather',
- *   toolCallId: 'call_abc123',
- *   arguments: { location: 'San Francisco' },
- *   result: { temperature: 72 },
- *   isError: false,
- *   duration: 150,
- *   approved: true
- * };
- * ```
- */
-interface ToolExecution {
-    /** Name of the tool that was called */
-    toolName: string;
-    /** Unique identifier for this tool call */
-    toolCallId: string;
-    /** Arguments that were passed to the tool */
-    arguments: Record<string, unknown>;
-    /** Result returned by the tool */
-    result: unknown;
-    /** Whether the tool execution resulted in an error */
-    isError: boolean;
-    /** Execution duration in milliseconds */
-    duration: number;
-    /** Whether approval was required and granted (undefined if no approval handler) */
-    approved?: boolean;
-}
-
-/**
- * @fileoverview Message types for conversation history.
- *
- * Defines the message classes used to represent conversation turns
- * between users and assistants, including support for multimodal
- * content and tool calls.
- *
- * @module types/messages
- */
-
-/**
- * Message serialized to JSON format.
- * Picks common fields from Message, converts timestamp to string.
- */
-type MessageJSON = Pick<Message, 'id' | 'type' | 'metadata'> & {
-    timestamp: string;
-    content: ContentBlock[];
-    toolCalls?: ToolCall[];
-    results?: ToolResult[];
-};
-/**
- * Message type discriminator union.
- *
- * This type is derived from {@link MessageRole} constants. The name `MessageType`
- * is kept for backward compatibility; `MessageRole` works as both the const
- * object and this type.
- */
-type MessageType = (typeof MessageRole)[keyof typeof MessageRole];
-/**
- * Message role/type constants.
- *
- * Use these constants instead of raw strings for type-safe message handling:
- *
- * @example
- * ```typescript
- * import { MessageRole, isUserMessage } from 'upp';
- *
- * if (message.type === MessageRole.User) {
- *   console.log('User said:', message.text);
- * } else if (message.type === MessageRole.Assistant) {
- *   console.log('Assistant replied:', message.text);
- * }
- * ```
- */
-declare const MessageRole: {
-    /** User message */
-    readonly User: "user";
-    /** Assistant/model response */
-    readonly Assistant: "assistant";
-    /** Tool execution result */
-    readonly ToolResult: "tool_result";
-};
-/**
- * Type alias for MessageType, allowing `MessageRole` to work as both const and type.
- */
-type MessageRole = MessageType;
-/**
- * Provider-namespaced metadata for messages.
- *
- * Each provider can attach its own metadata under its namespace,
- * preventing conflicts between different providers.
- *
- * @example
- * ```typescript
- * const metadata: MessageMetadata = {
- *   openai: { model: 'gpt-4', finishReason: 'stop' },
- *   anthropic: { model: 'claude-3', stopReason: 'end_turn' }
- * };
- * ```
- */
-interface MessageMetadata {
-    [provider: string]: Record<string, unknown> | undefined;
-}
-/**
- * Options for constructing messages.
- */
-interface MessageOptions {
-    /** Custom message ID (auto-generated if not provided) */
-    id?: string;
-    /** Provider-specific metadata */
-    metadata?: MessageMetadata;
-}
-/**
- * Abstract base class for all message types.
- *
- * Provides common functionality for user, assistant, and tool result
- * messages, including content accessors and metadata handling.
- *
- * @example
- * ```typescript
- * // Access text content from any message
- * const text = message.text;
- *
- * // Access images
- * const images = message.images;
- * ```
- */
-declare abstract class Message {
-    /** Unique message identifier */
-    readonly id: string;
-    /** Timestamp when the message was created */
-    readonly timestamp: Date;
-    /** Provider-specific metadata, namespaced by provider name */
-    readonly metadata?: MessageMetadata;
-    /** Message type discriminator (implemented by subclasses) */
-    abstract readonly type: MessageType;
-    /**
-     * Returns the content blocks for this message.
-     * Implemented by subclasses to provide type-specific content.
-     */
-    protected abstract getContent(): ContentBlock[];
-    /**
-     * Creates a new message instance.
-     *
-     * @param options - Optional message ID and metadata
-     */
-    constructor(options?: MessageOptions);
-    /**
-     * Concatenated text content from all text blocks.
-     * Blocks are joined with double newlines.
-     */
-    get text(): string;
-    /**
-     * All image content blocks in this message.
-     */
-    get images(): ImageBlock[];
-    /**
-     * All document content blocks in this message.
-     */
-    get documents(): DocumentBlock[];
-    /**
-     * All audio content blocks in this message.
-     */
-    get audio(): AudioBlock[];
-    /**
-     * All video content blocks in this message.
-     */
-    get video(): VideoBlock[];
-    /**
-     * All reasoning/thinking content blocks in this message.
-     * Available when using extended thinking models.
-     */
-    get reasoning(): ReasoningBlock[];
-}
-/**
- * User input message.
- *
- * Represents a message from the user, which can contain text and/or
- * multimodal content like images, audio, or video.
- *
- * @example
- * ```typescript
- * // Simple text message
- * const msg = new UserMessage('Hello, world!');
- *
- * // Multimodal message
- * const msg = new UserMessage([
- *   { type: 'text', text: 'What is in this image?' },
- *   { type: 'image', source: { type: 'url', url: '...' }, mimeType: 'image/png' }
- * ]);
- * ```
- */
-declare class UserMessage extends Message {
-    /** Message type discriminator */
-    readonly type: "user";
-    /** Content blocks in this message */
-    readonly content: UserContent[];
-    /**
-     * Creates a new user message.
-     *
-     * @param content - String (converted to TextBlock) or array of content blocks
-     * @param options - Optional message ID and metadata
-     */
-    constructor(content: string | UserContent[], options?: MessageOptions);
-    protected getContent(): ContentBlock[];
-}
-/**
- * Assistant response message.
- *
- * Represents a response from the AI assistant, which may contain
- * text, media content, and/or tool call requests.
- *
- * @example
- * ```typescript
- * // Simple text response
- * const msg = new AssistantMessage('Hello! How can I help?');
- *
- * // Response with tool calls
- * const msg = new AssistantMessage(
- *   'Let me check the weather...',
- *   [{ toolCallId: 'call_1', toolName: 'get_weather', arguments: { location: 'NYC' } }]
- * );
- * ```
- */
-declare class AssistantMessage extends Message {
-    /** Message type discriminator */
-    readonly type: "assistant";
-    /** Content blocks in this message */
-    readonly content: AssistantContent[];
-    /** Tool calls requested by the model (if any) */
-    readonly toolCalls?: ToolCall[];
-    /**
-     * Creates a new assistant message.
-     *
-     * @param content - String (converted to TextBlock) or array of content blocks
-     * @param toolCalls - Tool calls requested by the model
-     * @param options - Optional message ID and metadata
-     */
-    constructor(content: string | AssistantContent[], toolCalls?: ToolCall[], options?: MessageOptions);
-    protected getContent(): ContentBlock[];
-    /**
-     * Whether this message contains tool call requests.
-     */
-    get hasToolCalls(): boolean;
-}
-/**
- * Tool execution result message.
- *
- * Contains the results of executing one or more tool calls,
- * sent back to the model for further processing.
- *
- * @example
- * ```typescript
- * const msg = new ToolResultMessage([
- *   { toolCallId: 'call_1', result: { temperature: 72, conditions: 'sunny' } },
- *   { toolCallId: 'call_2', result: 'File not found', isError: true }
- * ]);
- * ```
- */
-declare class ToolResultMessage extends Message {
-    /** Message type discriminator */
-    readonly type: "tool_result";
-    /** Results from tool executions */
-    readonly results: ToolResult[];
-    /**
-     * Creates a new tool result message.
-     *
-     * @param results - Array of tool execution results
-     * @param options - Optional message ID and metadata
-     */
-    constructor(results: ToolResult[], options?: MessageOptions);
-    protected getContent(): ContentBlock[];
-}
-/**
- * Type guard for UserMessage.
- *
- * @param msg - The message to check
- * @returns True if the message is a UserMessage
- *
- * @example
- * ```typescript
- * if (isUserMessage(msg)) {
- *   console.log('User said:', msg.text);
- * }
- * ```
- */
-declare function isUserMessage(msg: Message): msg is UserMessage;
-/**
- * Type guard for AssistantMessage.
- *
- * @param msg - The message to check
- * @returns True if the message is an AssistantMessage
- *
- * @example
- * ```typescript
- * if (isAssistantMessage(msg)) {
- *   console.log('Assistant said:', msg.text);
- *   if (msg.hasToolCalls) {
- *     console.log('Tool calls:', msg.toolCalls);
- *   }
- * }
- * ```
- */
-declare function isAssistantMessage(msg: Message): msg is AssistantMessage;
-/**
- * Type guard for ToolResultMessage.
- *
- * @param msg - The message to check
- * @returns True if the message is a ToolResultMessage
- *
- * @example
- * ```typescript
- * if (isToolResultMessage(msg)) {
- *   for (const result of msg.results) {
- *     console.log(`Tool ${result.toolCallId}:`, result.result);
- *   }
- * }
- * ```
- */
-declare function isToolResultMessage(msg: Message): msg is ToolResultMessage;
-
-/**
- * @fileoverview Turn types for inference results.
- *
- * A Turn represents the complete result of one inference call, including
- * all messages produced during tool execution loops, token usage, and
- * optional structured output data.
- *
- * @module types/turn
- */
-
-/**
- * Token usage information for an inference request.
- *
- * Tracks input and output tokens across all inference cycles,
- * with optional per-cycle breakdown and cache metrics.
- *
- * @example
- * ```typescript
- * const usage: TokenUsage = {
- *   inputTokens: 150,
- *   outputTokens: 50,
- *   totalTokens: 200,
- *   cacheReadTokens: 100,
- *   cacheWriteTokens: 50,
- *   cycles: [
- *     { inputTokens: 100, outputTokens: 30, cacheReadTokens: 0, cacheWriteTokens: 50 },
- *     { inputTokens: 50, outputTokens: 20, cacheReadTokens: 100, cacheWriteTokens: 0 }
- *   ]
- * };
- * ```
- */
-interface TokenUsage {
-    /** Total input tokens across all cycles */
-    inputTokens: number;
-    /** Total output tokens across all cycles */
-    outputTokens: number;
-    /** Sum of input and output tokens */
-    totalTokens: number;
-    /**
-     * Tokens read from cache (cache hits).
-     * Returns 0 for providers that don't support or report cache metrics.
-     */
-    cacheReadTokens: number;
-    /**
-     * Tokens written to cache (cache misses that were cached).
-     * Only Anthropic reports this metric; returns 0 for other providers.
-     */
-    cacheWriteTokens: number;
-    /** Per-cycle token breakdown (if multiple cycles occurred) */
-    cycles?: Array<{
-        inputTokens: number;
-        outputTokens: number;
-        cacheReadTokens: number;
-        cacheWriteTokens: number;
-    }>;
-}
-/**
- * A Turn represents the complete result of one inference call.
- *
- * Includes all messages produced during tool execution loops,
- * the final assistant response, token usage, and optional
- * structured output data.
- *
- * @typeParam TData - Type of the structured output data
- *
- * @example
- * ```typescript
- * const turn = await instance.generate('Hello');
- * console.log(turn.response.text);
- * console.log(`Used ${turn.usage.totalTokens} tokens in ${turn.cycles} cycles`);
- *
- * // With structured output
- * interface WeatherData { temperature: number; conditions: string; }
- * const turn = await instance.generate<WeatherData>('Get weather');
- * console.log(turn.data?.temperature);
- * ```
- */
-interface Turn<TData = unknown> {
-    /**
-     * All messages produced during this inference, in chronological order.
-     * Includes UserMessage, AssistantMessage (may include toolCalls), and ToolResultMessage.
-     */
-    readonly messages: Message[];
-    /** The final assistant response (last AssistantMessage in the turn) */
-    readonly response: AssistantMessage;
-    /**
-     * Tool executions that occurred during this turn.
-     *
-     * Execution order reflects completion timing, not call order.
-     * Correlate with tool calls using toolCallId.
-     */
-    readonly toolExecutions: ToolExecution[];
-    /** Aggregate token usage for the entire turn */
-    readonly usage: TokenUsage;
-    /** Total number of inference cycles (1 + number of tool rounds) */
-    readonly cycles: number;
-    /**
-     * Structured output data (if a structure schema was provided).
-     * Type is inferred from the schema when using TypeScript.
-     */
-    readonly data?: TData;
-}
-/**
- * Turn serialized to JSON format.
- * Messages are converted to MessageJSON, response is omitted (computed from messages).
- *
- * @remarks
- * This type is derived from {@link Turn} and should stay in sync with it.
- */
-type TurnJSON = Omit<Turn, 'messages' | 'response'> & {
-    messages: MessageJSON[];
-};
-/**
- * Creates a Turn from accumulated inference data.
- *
- * @typeParam TData - Type of the structured output data
- * @param messages - All messages produced during the inference
- * @param toolExecutions - Record of all tool executions
- * @param usage - Aggregate token usage
- * @param cycles - Number of inference cycles
- * @param data - Optional structured output data
- * @returns A complete Turn object
- * @throws Error if no assistant message is found in the messages
- *
- * @example
- * ```typescript
- * const turn = createTurn(
- *   [userMsg, assistantMsg],
- *   [],
- *   { inputTokens: 100, outputTokens: 50, totalTokens: 150 },
- *   1
- * );
- * ```
- */
-declare function createTurn<TData = unknown>(messages: Message[], toolExecutions: ToolExecution[], usage: TokenUsage, cycles: number, data?: TData): Turn<TData>;
-/**
- * Creates an empty TokenUsage object.
- *
- * @returns A TokenUsage with all values set to zero
- *
- * @example
- * ```typescript
- * const usage = emptyUsage();
- * // { inputTokens: 0, outputTokens: 0, totalTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, cycles: [] }
- * ```
- */
-declare function emptyUsage(): TokenUsage;
-/**
- * Aggregates token usage from multiple inference cycles.
- *
- * @param usages - Array of TokenUsage objects to aggregate
- * @returns Combined TokenUsage with per-cycle breakdown
- *
- * @example
- * ```typescript
- * const cycle1 = { inputTokens: 100, outputTokens: 30, totalTokens: 130, cacheReadTokens: 50, cacheWriteTokens: 0 };
- * const cycle2 = { inputTokens: 150, outputTokens: 40, totalTokens: 190, cacheReadTokens: 100, cacheWriteTokens: 0 };
- * const total = aggregateUsage([cycle1, cycle2]);
- * // { inputTokens: 250, outputTokens: 70, totalTokens: 320, cacheReadTokens: 150, cacheWriteTokens: 0, cycles: [...] }
- * ```
- */
-declare function aggregateUsage(usages: TokenUsage[]): TokenUsage;
-
-/**
- * @fileoverview Streaming types for real-time LLM responses.
- *
- * Defines the event types and interfaces for streaming LLM inference,
- * including text deltas, tool call deltas, and control events.
- *
- * @module types/stream
- */
-
-/**
- * Stream event type constants.
- *
- * Use these constants instead of raw strings for type-safe event handling:
- *
- * @example
- * ```typescript
- * import { StreamEventType } from 'upp';
- *
- * for await (const event of stream) {
- *   if (event.type === StreamEventType.TextDelta) {
- *     process.stdout.write(event.delta.text ?? '');
- *   }
- * }
- * ```
- */
-declare const StreamEventType: {
-    /** Incremental text output */
-    readonly TextDelta: "text_delta";
-    /** Incremental reasoning/thinking output */
-    readonly ReasoningDelta: "reasoning_delta";
-    /** Incremental image data */
-    readonly ImageDelta: "image_delta";
-    /** Incremental audio data */
-    readonly AudioDelta: "audio_delta";
-    /** Incremental video data */
-    readonly VideoDelta: "video_delta";
-    /** Incremental tool call data (arguments being streamed) */
-    readonly ToolCallDelta: "tool_call_delta";
-    /** Incremental structured object data (for structured output responses) */
-    readonly ObjectDelta: "object_delta";
-    /** Tool execution has started (may be emitted after completion in some implementations) */
-    readonly ToolExecutionStart: "tool_execution_start";
-    /** Tool execution has completed */
-    readonly ToolExecutionEnd: "tool_execution_end";
-    /** Beginning of a message */
-    readonly MessageStart: "message_start";
-    /** End of a message */
-    readonly MessageStop: "message_stop";
-    /** Beginning of a content block */
-    readonly ContentBlockStart: "content_block_start";
-    /** End of a content block */
-    readonly ContentBlockStop: "content_block_stop";
-};
-/**
- * Stream event type discriminator union.
- *
- * This type is derived from {@link StreamEventType} constants. Use `StreamEventType.TextDelta`
- * for constants or `type MyType = StreamEventType` for type annotations.
- */
-type StreamEventType = (typeof StreamEventType)[keyof typeof StreamEventType];
-/**
- * Event delta data payload.
- *
- * Contains the type-specific data for a streaming event.
- * Different fields are populated depending on the event type:
- *
- * | Event Type | Fields |
- * |------------|--------|
- * | `text_delta` | `text` |
- * | `reasoning_delta` | `text` |
- * | `object_delta` | `text` |
- * | `image_delta` | `data` |
- * | `audio_delta` | `data` |
- * | `video_delta` | `data` |
- * | `tool_call_delta` | `toolCallId`, `toolName`, `argumentsJson` |
- * | `tool_execution_start` | `toolCallId`, `toolName`, `timestamp` |
- * | `tool_execution_end` | `toolCallId`, `toolName`, `result`, `isError`, `timestamp` |
- * | `message_start` | (none) |
- * | `message_stop` | (none) |
- * | `content_block_start` | (none) |
- * | `content_block_stop` | (none) |
- */
-interface EventDelta {
-    /** Incremental text content (text_delta, reasoning_delta, object_delta) */
-    text?: string;
-    /** Incremental binary data (image_delta, audio_delta, video_delta) */
-    data?: Uint8Array;
-    /** Tool call identifier (tool_call_delta, tool_execution_start/end) */
-    toolCallId?: string;
-    /** Tool name (tool_call_delta, tool_execution_start/end) */
-    toolName?: string;
-    /** Incremental JSON arguments string (tool_call_delta) */
-    argumentsJson?: string;
-    /** Tool execution result (tool_execution_end) */
-    result?: unknown;
-    /** Whether tool execution resulted in an error (tool_execution_end) */
-    isError?: boolean;
-    /** Timestamp in milliseconds (tool_execution_start/end) */
-    timestamp?: number;
-}
-/**
- * A single streaming event from the LLM.
- *
- * Events are emitted in order as the model generates output,
- * allowing for real-time display of responses.
- *
- * @example
- * ```typescript
- * import { StreamEventType } from 'upp';
- *
- * for await (const event of stream) {
- *   if (event.type === StreamEventType.TextDelta) {
- *     process.stdout.write(event.delta.text ?? '');
- *   } else if (event.type === StreamEventType.ToolCallDelta) {
- *     console.log('Tool:', event.delta.toolName);
- *   }
- * }
- * ```
- */
-interface StreamEvent {
-    /** Event type discriminator */
-    type: StreamEventType;
-    /** Index of the content block this event belongs to */
-    index: number;
-    /** Event-specific data payload */
-    delta: EventDelta;
-}
-/**
- * Stream result - an async iterable that also provides the final turn.
- *
- * Allows consuming streaming events while also awaiting the complete
- * Turn result after streaming finishes.
- *
- * @typeParam TData - Type of the structured output data
- *
- * @example
- * ```typescript
- * import { StreamEventType } from 'upp';
- *
- * const stream = instance.stream('Tell me a story');
- *
- * // Consume streaming events
- * for await (const event of stream) {
- *   if (event.type === StreamEventType.TextDelta) {
- *     process.stdout.write(event.delta.text ?? '');
- *   }
- * }
- *
- * // Get the complete turn after streaming
- * const turn = await stream.turn;
- * console.log('\n\nTokens used:', turn.usage.totalTokens);
- * ```
- */
-interface StreamResult<TData = unknown> extends AsyncIterable<StreamEvent> {
-    /**
-     * Promise that resolves to the complete Turn after streaming finishes.
-     * Rejects if the stream is aborted or terminated early.
-     */
-    readonly turn: Promise<Turn<TData>>;
-    /**
-     * Aborts the stream, stopping further events and cancelling the request.
-     * This will cause {@link StreamResult.turn} to reject.
-     */
-    abort(): void;
-}
-/**
- * Creates a StreamResult from an async generator and completion promise.
- *
- * @typeParam TData - Type of the structured output data
- * @param generator - Async generator that yields stream events
- * @param turnPromiseOrFactory - Promise or factory that resolves to the complete Turn
- * @param abortController - Controller for aborting the stream
- * @returns A StreamResult that can be iterated and awaited
- *
- * @example
- * ```typescript
- * const abortController = new AbortController();
- * const stream = createStreamResult(
- *   eventGenerator(),
- *   turnPromise,
- *   abortController
- * );
- * ```
- */
-declare function createStreamResult<TData = unknown>(generator: AsyncGenerator<StreamEvent, void, unknown>, turnPromiseOrFactory: Promise<Turn<TData>> | (() => Promise<Turn<TData>>), abortController: AbortController): StreamResult<TData>;
-/**
- * Creates a text delta stream event.
- *
- * @param text - The incremental text content
- * @param index - Content block index (default: 0)
- * @returns A text_delta StreamEvent
- */
-declare function textDelta(text: string, index?: number): StreamEvent;
-/**
- * Creates a tool call delta stream event.
- *
- * @param toolCallId - Unique identifier for the tool call
- * @param toolName - Name of the tool being called
- * @param argumentsJson - Incremental JSON arguments string
- * @param index - Content block index (default: 0)
- * @returns A tool_call_delta StreamEvent
- */
-declare function toolCallDelta(toolCallId: string, toolName: string, argumentsJson: string, index?: number): StreamEvent;
-/**
- * Creates an object delta stream event for structured output responses.
- *
- * @param text - The incremental text content
- * @param index - Content block index (default: 0)
- * @returns An object_delta StreamEvent
- */
-declare function objectDelta(text: string, index?: number): StreamEvent;
-/**
- * Creates a message start stream event.
- *
- * @returns A message_start StreamEvent
- */
-declare function messageStart(): StreamEvent;
-/**
- * Creates a message stop stream event.
- *
- * @returns A message_stop StreamEvent
- */
-declare function messageStop(): StreamEvent;
-/**
- * Creates a content block start stream event.
- *
- * @param index - The content block index starting
- * @returns A content_block_start StreamEvent
- */
-declare function contentBlockStart(index: number): StreamEvent;
-/**
- * Creates a content block stop stream event.
- *
- * @param index - The content block index stopping
- * @returns A content_block_stop StreamEvent
- */
-declare function contentBlockStop(index: number): StreamEvent;
-/**
- * Creates a tool execution start stream event.
- *
- * @param toolCallId - Unique identifier for the tool call
- * @param toolName - Name of the tool being executed
- * @param timestamp - Start timestamp in milliseconds
- * @param index - Content block index (default: 0)
- * @returns A tool_execution_start StreamEvent
- */
-declare function toolExecutionStart(toolCallId: string, toolName: string, timestamp: number, index?: number): StreamEvent;
-/**
- * Creates a tool execution end stream event.
- *
- * @param toolCallId - Unique identifier for the tool call
- * @param toolName - Name of the tool that was executed
- * @param result - The result from the tool execution
- * @param isError - Whether the execution resulted in an error
- * @param timestamp - End timestamp in milliseconds
- * @param index - Content block index (default: 0)
- * @returns A tool_execution_end StreamEvent
- */
-declare function toolExecutionEnd(toolCallId: string, toolName: string, result: unknown, isError: boolean, timestamp: number, index?: number): StreamEvent;
+import { I as ImageSource, c as ImageBlock, S as StreamEvent, d as Tool, M as Message, T as Turn, U as UserContent, A as AssistantContent, e as MessageType, a as MessageJSON, f as ToolUseStrategy, J as JSONSchema, g as AssistantMessage, h as TokenUsage, C as ContentBlock, i as StreamResult } from './stream-S7nwQRqM.js';
 
 /**
  * @fileoverview Error types for the Unified Provider Protocol.
@@ -1964,7 +335,7 @@ declare class Image {
 /**
  * @fileoverview Middleware types for the Universal Provider Protocol.
  *
- * Defines the interfaces for composable middleware that can intercept and
+ * Defines the interfaces for composable middleware that can
  * transform requests, responses, and stream events across all modalities.
  *
  * @module types/middleware
@@ -2103,6 +474,15 @@ interface Middleware {
      * @param ctx - The middleware context
      */
     onError?(error: Error, ctx: MiddlewareContext): void | Promise<void>;
+    /**
+     * Called when a request is cancelled (for example, when a stream is aborted
+     * or a client disconnects).
+     * Called for all middleware that have this hook, regardless of order.
+     *
+     * @param error - The cancellation error
+     * @param ctx - The middleware context
+     */
+    onAbort?(error: Error, ctx: MiddlewareContext): void | Promise<void>;
     /**
      * Called before provider execution. Can modify the request.
      *
@@ -3382,4 +1762,4 @@ interface BoundLLMModel<TParams = unknown> {
     stream(request: LLMRequest<TParams>): LLMStreamResult;
 }
 
-export { UserMessage as $, type AudioBlock as A, type BinaryBlock as B, type ContentBlock as C, type DocumentSource as D, type EmbeddingHandler as E, isAudioBlock as F, isVideoBlock as G, isBinaryBlock as H, type ImageOptions as I, type JSONSchema as J, type Tool as K, type LLMOptions as L, type ModelReference as M, type ToolCall as N, type ToolResult as O, type Provider as P, type ToolMetadata as Q, type ReasoningBlock as R, type StreamEvent as S, type TextBlock as T, UPPError as U, type VideoBlock as V, type ToolUseStrategy as W, type BeforeCallResult as X, type AfterCallResult as Y, type ToolExecution as Z, Message as _, type LLMInstance as a, type MiddlewareContext as a$, AssistantMessage as a0, ToolResultMessage as a1, MessageRole as a2, isUserMessage as a3, isAssistantMessage as a4, isToolResultMessage as a5, type MessageType as a6, type MessageMetadata as a7, type MessageOptions as a8, type Turn as a9, type BoundEmbeddingModel as aA, type EmbeddingRequest as aB, type EmbeddingResponse as aC, type EmbeddingVector as aD, type EmbeddingUsage as aE, type EmbeddingInput as aF, type LLMCapabilities as aG, type LLMRequest as aH, type LLMResponse as aI, type LLMStreamResult as aJ, type BoundLLMModel as aK, type InferenceInput as aL, type ImageInput as aM, type ImageEditInput as aN, type ImageGenerateOptions as aO, type GeneratedImage as aP, type ImageUsage as aQ, type ImageResult as aR, type ImageStreamEvent as aS, type ImageStreamResult as aT, type ImageCapabilities as aU, type ImageRequest as aV, type ImageEditRequest as aW, type ImageResponse as aX, type ImageProviderStreamResult as aY, type BoundImageModel as aZ, type ImageModelInput as a_, type TokenUsage as aa, createTurn as ab, emptyUsage as ac, aggregateUsage as ad, Thread as ae, type ThreadJSON as af, type MessageJSON as ag, type StreamResult as ah, StreamEventType as ai, createStreamResult as aj, textDelta as ak, toolCallDelta as al, objectDelta as am, messageStart as an, messageStop as ao, contentBlockStart as ap, contentBlockStop as aq, toolExecutionStart as ar, toolExecutionEnd as as, type ProviderIdentity as at, type ProviderConfig as au, type KeyStrategy as av, type RetryStrategy as aw, type LLMProvider as ax, type EmbeddingProvider as ay, type ImageProvider as az, type ImageInstance as b, type StreamContext as b0, type MiddlewareModality as b1, type AnyRequest as b2, type AnyResponse as b3, type TurnJSON as b4, type LLMHandler as c, type ImageHandler as d, type DocumentBlock as e, type Middleware as f, type EventDelta as g, Image as h, ErrorCode as i, ModalityType as j, type Modality as k, type JSONSchemaProperty as l, type JSONSchemaPropertyType as m, type ImageBlock as n, type ImageSource as o, type UserContent as p, type AssistantContent as q, ContentBlockType as r, ImageSourceType as s, DocumentSourceType as t, text as u, reasoning as v, isTextBlock as w, isReasoningBlock as x, isImageBlock as y, isDocumentBlock as z };
+export { type MiddlewareModality as $, type BoundLLMModel as A, type BoundEmbeddingModel as B, type InferenceInput as C, type ImageInput as D, type EmbeddingInput as E, type ImageEditInput as F, type ImageGenerateOptions as G, type GeneratedImage as H, type ImageStreamResult as I, type ImageUsage as J, type KeyStrategy as K, type LLMOptions as L, type Middleware as M, type ImageResult as N, type ImageStreamEvent as O, type ProviderIdentity as P, type ImageCapabilities as Q, type RetryStrategy as R, type ImageRequest as S, Thread as T, UPPError as U, type ImageEditRequest as V, type ImageResponse as W, type BoundImageModel as X, type ImageModelInput as Y, type MiddlewareContext as Z, type StreamContext as _, type ImageProviderStreamResult as a, type AnyRequest as a0, type AnyResponse as a1, type ProviderConfig as b, type EmbeddingUsage as c, type Provider as d, type Modality as e, ErrorCode as f, type ModelReference as g, type LLMInstance as h, type ImageOptions as i, type ImageInstance as j, type LLMHandler as k, type EmbeddingHandler as l, type ImageHandler as m, Image as n, ModalityType as o, type ThreadJSON as p, type LLMProvider as q, type EmbeddingProvider as r, type ImageProvider as s, type EmbeddingRequest as t, type EmbeddingResponse as u, type EmbeddingVector as v, type LLMCapabilities as w, type LLMRequest as x, type LLMResponse as y, type LLMStreamResult as z };