@providerprotocol/ai 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,792 @@
+import { M as ModelReference, P as ProviderConfig, L as LLMProvider, a as LLMHandler$1, E as EmbeddingHandler, I as ImageHandler, b as Provider } from './provider-CUJWjgNl.js';
+export { B as BoundEmbeddingModel, g as BoundImageModel, e as EmbeddingProvider, c as ErrorCode, f as ImageProvider, K as KeyStrategy, d as Modality, R as RetryStrategy, U as UPPError } from './provider-CUJWjgNl.js';
+export { D as DynamicKey, E as ExponentialBackoff, L as LinearBackoff, N as NoRetry, a as RetryAfterStrategy, R as RoundRobinKeys, T as TokenBucket, W as WeightedKeys } from './retry-I2661_rv.js';
+
+/**
+ * Content block types for messages
+ */
+/**
+ * Image source types
+ */
+type ImageSource = {
+    type: 'base64';
+    data: string;
+} | {
+    type: 'url';
+    url: string;
+} | {
+    type: 'bytes';
+    data: Uint8Array;
+};
+/**
+ * Text content block
+ */
+interface TextBlock {
+    type: 'text';
+    text: string;
+}
+/**
+ * Image content block
+ */
+interface ImageBlock {
+    type: 'image';
+    source: ImageSource;
+    mimeType: string;
+    width?: number;
+    height?: number;
+}
+/**
+ * Audio content block
+ */
+interface AudioBlock {
+    type: 'audio';
+    data: Uint8Array;
+    mimeType: string;
+    duration?: number;
+}
+/**
+ * Video content block
+ */
+interface VideoBlock {
+    type: 'video';
+    data: Uint8Array;
+    mimeType: string;
+    duration?: number;
+    width?: number;
+    height?: number;
+}
+/**
+ * Binary content block for arbitrary data
+ */
+interface BinaryBlock {
+    type: 'binary';
+    data: Uint8Array;
+    mimeType: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * All content block types
+ */
+type ContentBlock = TextBlock | ImageBlock | AudioBlock | VideoBlock | BinaryBlock;
+/**
+ * Content types allowed in user messages
+ */
+type UserContent = TextBlock | ImageBlock | AudioBlock | VideoBlock | BinaryBlock;
+/**
+ * Content types allowed in assistant messages
+ */
+type AssistantContent = TextBlock | ImageBlock | AudioBlock | VideoBlock;
+/**
+ * Helper to create a text block
+ */
+declare function text(content: string): TextBlock;
+/**
+ * Type guard for TextBlock
+ */
+declare function isTextBlock(block: ContentBlock): block is TextBlock;
+/**
+ * Type guard for ImageBlock
+ */
+declare function isImageBlock(block: ContentBlock): block is ImageBlock;
+/**
+ * Type guard for AudioBlock
+ */
+declare function isAudioBlock(block: ContentBlock): block is AudioBlock;
+/**
+ * Type guard for VideoBlock
+ */
+declare function isVideoBlock(block: ContentBlock): block is VideoBlock;
+/**
+ * Type guard for BinaryBlock
+ */
+declare function isBinaryBlock(block: ContentBlock): block is BinaryBlock;
+
+/**
+ * JSON Schema types for tool parameters and structured outputs
+ */
+type JSONSchemaPropertyType = 'string' | 'number' | 'integer' | 'boolean' | 'array' | 'object' | 'null';
+/**
+ * JSON Schema property definition
+ */
+interface JSONSchemaProperty {
+    type: JSONSchemaPropertyType;
+    description?: string;
+    enum?: unknown[];
+    const?: unknown;
+    default?: unknown;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    format?: 'email' | 'uri' | 'date' | 'date-time' | 'uuid';
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: number;
+    exclusiveMaximum?: number;
+    multipleOf?: number;
+    items?: JSONSchemaProperty;
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
+    properties?: Record<string, JSONSchemaProperty>;
+    required?: string[];
+    additionalProperties?: boolean;
+}
+/**
+ * JSON Schema for tool parameters or structured outputs
+ */
+interface JSONSchema {
+    type: 'object';
+    properties: Record<string, JSONSchemaProperty>;
+    required?: string[];
+    additionalProperties?: boolean;
+    description?: string;
+}
+
+/**
+ * Tool call requested by the model
+ */
+interface ToolCall {
+    toolCallId: string;
+    toolName: string;
+    arguments: Record<string, unknown>;
+}
+/**
+ * Result of tool execution
+ */
+interface ToolResult {
+    toolCallId: string;
+    result: unknown;
+    isError?: boolean;
+}
+/**
+ * Tool definition
+ */
+interface Tool<TParams = unknown, TResult = unknown> {
+    /** Tool name (must be unique within a llm() instance) */
+    name: string;
+    /** Human-readable description for the model */
+    description: string;
+    /** JSON Schema defining parameters */
+    parameters: JSONSchema;
+    /** Tool execution function */
+    run(params: TParams): TResult | Promise<TResult>;
+    /** Optional approval handler for sensitive operations */
+    approval?(params: TParams): boolean | Promise<boolean>;
+}
+/**
+ * Strategy for tool execution
+ */
+interface ToolUseStrategy {
+    /** Maximum tool execution rounds (default: 10) */
+    maxIterations?: number;
+    /** Called when the model requests a tool call */
+    onToolCall?(tool: Tool, params: unknown): void | Promise<void>;
+    /** Called before tool execution, return false to skip */
+    onBeforeCall?(tool: Tool, params: unknown): boolean | Promise<boolean>;
+    /** Called after tool execution */
+    onAfterCall?(tool: Tool, params: unknown, result: unknown): void | Promise<void>;
+    /** Called on tool execution error */
+    onError?(tool: Tool, params: unknown, error: Error): void | Promise<void>;
+    /** Called when max iterations reached */
+    onMaxIterations?(iterations: number): void | Promise<void>;
+}
+/**
+ * Record of a tool execution
+ */
+interface ToolExecution {
+    /** The tool that was called */
+    toolName: string;
+    /** Tool call ID */
+    toolCallId: string;
+    /** Arguments 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 */
+    approved?: boolean;
+}
+
+/**
+ * Message type discriminator
+ */
+type MessageType = 'user' | 'assistant' | 'tool_result';
+/**
+ * Provider-namespaced metadata
+ * Each provider uses its own namespace
+ */
+interface MessageMetadata {
+    [provider: string]: Record<string, unknown> | undefined;
+}
+/**
+ * Options for message construction
+ */
+interface MessageOptions {
+    id?: string;
+    metadata?: MessageMetadata;
+}
+/**
+ * Base message class
+ * All messages inherit from this
+ */
+declare abstract class Message {
+    /** Unique message identifier */
+    readonly id: string;
+    /** Timestamp */
+    readonly timestamp: Date;
+    /** Provider-specific metadata, namespaced by provider */
+    readonly metadata?: MessageMetadata;
+    /** Message type discriminator */
+    abstract readonly type: MessageType;
+    /** Raw content - implemented by subclasses */
+    protected abstract getContent(): ContentBlock[];
+    constructor(options?: MessageOptions);
+    /**
+     * Convenience accessor for text content
+     * Concatenates all text blocks with '\n\n'
+     */
+    get text(): string;
+}
+/**
+ * User input message
+ */
+declare class UserMessage extends Message {
+    readonly type: "user";
+    readonly content: UserContent[];
+    /**
+     * @param content - String (converted to TextBlock) or array of content blocks
+     */
+    constructor(content: string | UserContent[], options?: MessageOptions);
+    protected getContent(): ContentBlock[];
+}
+/**
+ * Assistant response message
+ * May contain text, media, and/or tool calls
+ */
+declare class AssistantMessage extends Message {
+    readonly type: "assistant";
+    readonly content: AssistantContent[];
+    /** Tool calls requested by the model (if any) */
+    readonly toolCalls?: ToolCall[];
+    /**
+     * @param content - String (converted to TextBlock) or array of content blocks
+     * @param toolCalls - Tool calls requested by the model
+     * @param options - Message ID and metadata
+     */
+    constructor(content: string | AssistantContent[], toolCalls?: ToolCall[], options?: MessageOptions);
+    protected getContent(): ContentBlock[];
+    /** Check if this message requests tool execution */
+    get hasToolCalls(): boolean;
+}
+/**
+ * Result of tool execution (sent back to model)
+ */
+declare class ToolResultMessage extends Message {
+    readonly type: "tool_result";
+    readonly results: ToolResult[];
+    /**
+     * @param results - Array of tool execution results
+     * @param options - Message ID and metadata
+     */
+    constructor(results: ToolResult[], options?: MessageOptions);
+    protected getContent(): ContentBlock[];
+}
+/**
+ * Type guard for UserMessage
+ */
+declare function isUserMessage(msg: Message): msg is UserMessage;
+/**
+ * Type guard for AssistantMessage
+ */
+declare function isAssistantMessage(msg: Message): msg is AssistantMessage;
+/**
+ * Type guard for ToolResultMessage
+ */
+declare function isToolResultMessage(msg: Message): msg is ToolResultMessage;
+
+/**
+ * Token usage information
+ */
+interface TokenUsage {
+    /** Input tokens across all cycles */
+    inputTokens: number;
+    /** Output tokens across all cycles */
+    outputTokens: number;
+    /** Total tokens */
+    totalTokens: number;
+    /** Per-cycle breakdown (if available) */
+    cycles?: Array<{
+        inputTokens: number;
+        outputTokens: number;
+    }>;
+}
+/**
+ * A Turn represents the complete result of one inference call,
+ * including all messages produced during tool execution loops.
+ */
+interface Turn<TData = unknown> {
+    /**
+     * All messages produced during this inference, in chronological order.
+     * Types: UserMessage, AssistantMessage (may include toolCalls), ToolResultMessage
+     */
+    readonly messages: Message[];
+    /** The final assistant response (convenience accessor) */
+    readonly response: AssistantMessage;
+    /** Tool executions that occurred during this turn */
+    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 structure was provided).
+     * Type is inferred from the schema when using TypeScript.
+     */
+    readonly data?: TData;
+}
+/**
+ * Create a Turn from accumulated data
+ */
+declare function createTurn<TData = unknown>(messages: Message[], toolExecutions: ToolExecution[], usage: TokenUsage, cycles: number, data?: TData): Turn<TData>;
+/**
+ * Create empty token usage
+ */
+declare function emptyUsage(): TokenUsage;
+/**
+ * Aggregate token usage from multiple cycles
+ */
+declare function aggregateUsage(usages: TokenUsage[]): TokenUsage;
+
+/**
+ * Stream event types
+ */
+type StreamEventType = 'text_delta' | 'reasoning_delta' | 'image_delta' | 'audio_delta' | 'video_delta' | 'tool_call_delta' | 'message_start' | 'message_stop' | 'content_block_start' | 'content_block_stop';
+/**
+ * Event delta data (type-specific)
+ */
+interface EventDelta {
+    text?: string;
+    data?: Uint8Array;
+    toolCallId?: string;
+    toolName?: string;
+    argumentsJson?: string;
+}
+/**
+ * A streaming event
+ */
+interface StreamEvent {
+    /** Event type */
+    type: StreamEventType;
+    /** Index of the content block this event belongs to */
+    index: number;
+    /** Event data (type-specific) */
+    delta: EventDelta;
+}
+/**
+ * Stream result - async iterable that also provides final turn
+ */
+interface StreamResult<TData = unknown> extends AsyncIterable<StreamEvent> {
+    /**
+     * Get the complete Turn after streaming finishes.
+     * Resolves when the stream completes.
+     */
+    readonly turn: Promise<Turn<TData>>;
+    /** Abort the stream */
+    abort(): void;
+}
+/**
+ * Create a stream result from an async generator and completion promise
+ */
+declare function createStreamResult<TData = unknown>(generator: AsyncGenerator<StreamEvent, void, unknown>, turnPromise: Promise<Turn<TData>>, abortController: AbortController): StreamResult<TData>;
+/**
+ * Create a text delta event
+ */
+declare function textDelta(text: string, index?: number): StreamEvent;
+/**
+ * Create a tool call delta event
+ */
+declare function toolCallDelta(toolCallId: string, toolName: string, argumentsJson: string, index?: number): StreamEvent;
+/**
+ * Create a message start event
+ */
+declare function messageStart(): StreamEvent;
+/**
+ * Create a message stop event
+ */
+declare function messageStop(): StreamEvent;
+/**
+ * Create a content block start event
+ */
+declare function contentBlockStart(index: number): StreamEvent;
+/**
+ * Create a content block stop event
+ */
+declare function contentBlockStop(index: number): StreamEvent;
+
+/**
+ * Serialized message format
+ */
+interface MessageJSON {
+    id: string;
+    type: MessageType;
+    content: ContentBlock[];
+    toolCalls?: ToolCall[];
+    results?: ToolResult[];
+    metadata?: MessageMetadata;
+    timestamp: string;
+}
+/**
+ * Serialized thread format
+ */
+interface ThreadJSON {
+    id: string;
+    messages: MessageJSON[];
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * Thread - A utility class for managing conversation history
+ * Users control their own history; Thread is optional
+ */
+declare class Thread {
+    /** Unique thread identifier */
+    readonly id: string;
+    /** Internal message storage */
+    private _messages;
+    /** Creation timestamp */
+    private _createdAt;
+    /** Last update timestamp */
+    private _updatedAt;
+    /**
+     * Create a new thread, optionally with initial messages
+     */
+    constructor(messages?: Message[]);
+    /** All messages in the thread (readonly) */
+    get messages(): readonly Message[];
+    /** Number of messages */
+    get length(): number;
+    /**
+     * Append messages from a turn
+     */
+    append(turn: Turn): this;
+    /**
+     * Add raw messages
+     */
+    push(...messages: Message[]): this;
+    /**
+     * Add a user message
+     */
+    user(content: string | UserContent[]): this;
+    /**
+     * Add an assistant message
+     */
+    assistant(content: string | AssistantContent[]): this;
+    /**
+     * Get messages by type
+     */
+    filter(type: MessageType): Message[];
+    /**
+     * Get the last N messages
+     */
+    tail(count: number): Message[];
+    /**
+     * Create a new thread with a subset of messages
+     */
+    slice(start?: number, end?: number): Thread;
+    /**
+     * Clear all messages
+     */
+    clear(): this;
+    /**
+     * Convert to plain message array
+     */
+    toMessages(): Message[];
+    /**
+     * Serialize to JSON
+     */
+    toJSON(): ThreadJSON;
+    /**
+     * Deserialize from JSON
+     */
+    static fromJSON(json: ThreadJSON): Thread;
+    /**
+     * Iterate over messages
+     */
+    [Symbol.iterator](): Iterator<Message>;
+    /**
+     * Convert a message to JSON
+     */
+    private messageToJSON;
+    /**
+     * Reconstruct a message from JSON
+     */
+    private static messageFromJSON;
+}
+
+/**
+ * LLMCapabilities declares what the provider's API supports, not individual model capabilities.
+ * If a user attempts to use a feature with a model that doesn't support it,
+ * the provider's API will return an error—this is expected behavior.
+ *
+ * Capabilities are static - they are constant for the lifetime of the provider instance
+ * and do not vary per-request or per-model.
+ */
+interface LLMCapabilities {
+    /** Provider API supports streaming responses */
+    streaming: boolean;
+    /** Provider API supports tool/function calling */
+    tools: boolean;
+    /** Provider API supports native structured output (JSON schema) */
+    structuredOutput: boolean;
+    /** Provider API supports image input */
+    imageInput: boolean;
+    /** Provider API supports video input */
+    videoInput: boolean;
+    /** Provider API supports audio input */
+    audioInput: boolean;
+}
+/**
+ * Input types for inference
+ */
+type InferenceInput = string | Message | ContentBlock;
+/**
+ * Options for llm() function
+ */
+interface LLMOptions<TParams = unknown> {
+    /** A model reference from a provider factory */
+    model: ModelReference<any>;
+    /** Provider infrastructure configuration (optional - uses env vars if omitted) */
+    config?: ProviderConfig;
+    /** Model-specific parameters (temperature, max_tokens, etc.) */
+    params?: TParams;
+    /** System prompt for all inferences */
+    system?: string;
+    /** Tools available to the model */
+    tools?: Tool[];
+    /** Tool execution strategy */
+    toolStrategy?: ToolUseStrategy;
+    /** Structured output schema (JSON Schema) */
+    structure?: JSONSchema;
+}
+/**
+ * LLM instance returned by llm()
+ */
+interface LLMInstance<TParams = unknown> {
+    /**
+     * Execute inference and return complete Turn
+     *
+     * @overload No history - single input
+     * generate(input: InferenceInput): Promise<Turn>
+     *
+     * @overload No history - multiple inputs
+     * generate(...inputs: InferenceInput[]): Promise<Turn>
+     *
+     * @overload With history
+     * generate(history: Message[] | Thread, ...inputs: InferenceInput[]): Promise<Turn>
+     */
+    generate(historyOrInput: Message[] | Thread | InferenceInput, ...input: InferenceInput[]): Promise<Turn>;
+    /**
+     * Execute streaming inference
+     *
+     * @overload No history - single input
+     * stream(input: InferenceInput): StreamResult
+     *
+     * @overload No history - multiple inputs
+     * stream(...inputs: InferenceInput[]): StreamResult
+     *
+     * @overload With history
+     * stream(history: Message[] | Thread, ...inputs: InferenceInput[]): StreamResult
+     */
+    stream(historyOrInput: Message[] | Thread | InferenceInput, ...input: InferenceInput[]): StreamResult;
+    /** The bound model */
+    readonly model: BoundLLMModel<TParams>;
+    /** Current system prompt */
+    readonly system: string | undefined;
+    /** Current parameters */
+    readonly params: TParams | undefined;
+    /** Provider API capabilities */
+    readonly capabilities: LLMCapabilities;
+}
+/**
+ * Request passed from llm() core to providers
+ * Note: config is required here because llm() core resolves defaults
+ * before passing to providers
+ */
+interface LLMRequest<TParams = unknown> {
+    /** All messages for this request (history + new input) */
+    messages: Message[];
+    /** System prompt */
+    system?: string;
+    /** Model-specific parameters (passed through unchanged) */
+    params?: TParams;
+    /** Tools available for this request */
+    tools?: Tool[];
+    /** Structured output schema (if requested) */
+    structure?: JSONSchema;
+    /** Provider infrastructure config (resolved by llm() core) */
+    config: ProviderConfig;
+    /** Abort signal for cancellation */
+    signal?: AbortSignal;
+}
+/**
+ * Raw provider response (single cycle, no tool loop)
+ */
+interface LLMResponse {
+    message: AssistantMessage;
+    usage: TokenUsage;
+    stopReason: string;
+    /**
+     * Structured output data extracted by the provider.
+     * Present when a structure schema was requested and the provider
+     * successfully extracted the data (via tool call or native JSON mode).
+     * Providers handle their own extraction logic - core just uses this value.
+     */
+    data?: unknown;
+}
+/**
+ * Raw provider stream result
+ */
+interface LLMStreamResult extends AsyncIterable<StreamEvent> {
+    readonly response: Promise<LLMResponse>;
+}
+/**
+ * Bound LLM model - full definition
+ */
+interface BoundLLMModel<TParams = unknown> {
+    /** The model identifier */
+    readonly modelId: string;
+    /** Reference to the parent provider */
+    readonly provider: LLMProvider<TParams>;
+    /** Provider API capabilities */
+    readonly capabilities: LLMCapabilities;
+    /** Execute a single non-streaming inference request */
+    complete(request: LLMRequest<TParams>): Promise<LLMResponse>;
+    /** Execute a single streaming inference request */
+    stream(request: LLMRequest<TParams>): LLMStreamResult;
+}
+/**
+ * LLM Handler for providers
+ */
+interface LLMHandler<TParams = unknown> {
+    /** Bind model ID to create executable model */
+    bind(modelId: string): BoundLLMModel<TParams>;
+    /**
+     * Internal: Set the parent provider reference.
+     * Called by createProvider() after the provider is constructed.
+     * This allows bind() to return models with the correct provider reference.
+     * @internal
+     */
+    _setProvider?(provider: LLMProvider<TParams>): void;
+}
+
+/**
+ * Create an LLM instance
+ */
+declare function llm<TParams = unknown>(options: LLMOptions<TParams>): LLMInstance<TParams>;
+
+/**
+ * Options for creating a provider
+ */
+interface CreateProviderOptions {
+    name: string;
+    version: string;
+    modalities: {
+        llm?: LLMHandler$1;
+        embedding?: EmbeddingHandler;
+        image?: ImageHandler;
+    };
+}
+/**
+ * Create a provider factory function
+ *
+ * @typeParam TOptions - Provider-specific options type (defaults to unknown)
+ * @param options - Provider configuration
+ * @returns Provider function with modalities attached
+ *
+ * @example
+ * ```ts
+ * // Basic provider without options
+ * const anthropic = createProvider({
+ *   name: 'anthropic',
+ *   version: '1.0.0',
+ *   modalities: { llm: createLLMHandler() },
+ * });
+ *
+ * // Provider with custom options (typically needs custom factory)
+ * interface MyProviderOptions { api?: 'v1' | 'v2' }
+ * const myProvider = createProvider<MyProviderOptions>({
+ *   name: 'my-provider',
+ *   version: '1.0.0',
+ *   modalities: { llm: createLLMHandler() },
+ * });
+ * ```
+ */
+declare function createProvider<TOptions = unknown>(options: CreateProviderOptions): Provider<TOptions>;
+
+/**
+ * Image class for handling images in UPP
+ */
+declare class Image {
+    readonly source: ImageSource;
+    readonly mimeType: string;
+    readonly width?: number;
+    readonly height?: number;
+    private constructor();
+    /**
+     * Check if this image has data loaded (false for URL sources)
+     */
+    get hasData(): boolean;
+    /**
+     * Convert to base64 string (throws if source is URL)
+     */
+    toBase64(): string;
+    /**
+     * Convert to data URL (throws if source is URL)
+     */
+    toDataUrl(): string;
+    /**
+     * Get raw bytes (throws if source is URL)
+     */
+    toBytes(): Uint8Array;
+    /**
+     * Get the URL (only for URL sources)
+     */
+    toUrl(): string;
+    /**
+     * Convert to ImageBlock for use in messages
+     */
+    toBlock(): ImageBlock;
+    /**
+     * Create from file path (reads file into memory)
+     */
+    static fromPath(path: string): Promise<Image>;
+    /**
+     * Create from URL reference (does not fetch - providers handle URL conversion)
+     */
+    static fromUrl(url: string, mimeType?: string): Image;
+    /**
+     * Create from raw bytes
+     */
+    static fromBytes(data: Uint8Array, mimeType: string): Image;
+    /**
+     * Create from base64 string
+     */
+    static fromBase64(base64: string, mimeType: string): Image;
+    /**
+     * Create from an existing ImageBlock
+     */
+    static fromBlock(block: ImageBlock): Image;
+}
+
+/**
+ * UPP namespace object
+ * Provides ai.llm(), ai.embedding(), ai.image() style access
+ */
+declare const ai: {
+    llm: typeof llm;
+};
+
+export { type AssistantContent, AssistantMessage, type AudioBlock, type BinaryBlock, type BoundLLMModel, type ContentBlock, EmbeddingHandler, type EventDelta, Image, type ImageBlock, ImageHandler, type ImageSource, type InferenceInput, type JSONSchema, type JSONSchemaProperty, type JSONSchemaPropertyType, type LLMCapabilities, type LLMHandler, type LLMInstance, type LLMOptions, LLMProvider, type LLMRequest, type LLMResponse, type LLMStreamResult, Message, type MessageJSON, type MessageMetadata, type MessageOptions, type MessageType, ModelReference, Provider, ProviderConfig, type StreamEvent, type StreamEventType, type StreamResult, type TextBlock, Thread, type ThreadJSON, type TokenUsage, type Tool, type ToolCall, type ToolExecution, type ToolResult, ToolResultMessage, type ToolUseStrategy, type Turn, type UserContent, UserMessage, type VideoBlock, aggregateUsage, ai, contentBlockStart, contentBlockStop, createProvider, createStreamResult, createTurn, emptyUsage, isAssistantMessage, isAudioBlock, isBinaryBlock, isImageBlock, isTextBlock, isToolResultMessage, isUserMessage, isVideoBlock, llm, messageStart, messageStop, text, textDelta, toolCallDelta };