@providerprotocol/ai 0.0.37 → 0.0.39

package/dist/proxy/server/h3/index.d.ts

@@ -1,7 +1,8 @@
-import { T as Turn, i as StreamResult } from '../../../stream-sXhBtWjl.js';
-import { d as EmbeddingResult } from '../../../embedding-CwZ1ZNWv.js';
-import { N as ImageResult } from '../../../llm-DS_-l71X.js';
-import { I as ImageStreamLike } from '../../../image-stream-CeQHtjxS.js';
+import { T as Turn, g as StreamResult } from '../../../stream-DVVUIKpz.js';
+import { d as EmbeddingResult } from '../../../embedding-iNQCeXfk.js';
+import { N as ImageResult } from '../../../llm-CZqlijjK.js';
+import { I as ImageStreamLike } from '../../../image-stream-ARno6XlS.js';
+import '../../../tool-D22EhP5F.js';
 
 /**
  * @fileoverview H3/Nitro/Nuxt adapter for proxy server.
@@ -18,6 +19,7 @@ import { I as ImageStreamLike } from '../../../image-stream-CeQHtjxS.js';
 interface H3Event {
     node: {
         res: {
+            statusCode: number;
             setHeader(name: string, value: string): void;
             write(chunk: string): boolean;
             end(): void;
@@ -57,14 +59,14 @@ declare function sendImageJSON(result: ImageResult, event: H3Event): unknown;
 /**
  * Stream a StreamResult as Server-Sent Events.
  *
- * @param stream - The StreamResult from instance.stream()
- * @param event - H3 event object
- *
- * @example
+ * Note: For better H3/Nuxt integration, prefer using `createSSEStream` with `sendStream`:
  * ```typescript
- * const stream = instance.stream(messages);
- * return h3Adapter.streamSSE(stream, event);
+ * import { sendStream } from 'h3';
+ * return sendStream(event, h3Adapter.createSSEStream(stream));
  * ```
+ *
+ * @param stream - The StreamResult from instance.stream()
+ * @param event - H3 event object
  */
 declare function streamSSE(stream: StreamResult, event: H3Event): void;
 /**
@@ -95,7 +97,7 @@ declare function createSSEStream(stream: StreamResult): ReadableStream<Uint8Arra
  */
 declare function createImageSSEStream(stream: ImageStreamLike): ReadableStream<Uint8Array>;
 /**
- * Send an error response.
+ * Send an error response with proper HTTP status.
  *
  * @param message - Error message
  * @param status - HTTP status code
@@ -112,10 +114,10 @@ declare function sendError(message: string, status: number, event: H3Event): {
  * @example Basic usage
  * ```typescript
  * // Nuxt server route: server/api/ai.post.ts
+ * import { sendStream } from 'h3';
  * import { llm } from '@providerprotocol/ai';
  * import { anthropic } from '@providerprotocol/ai/anthropic';
- * import { parseBody } from '@providerprotocol/ai/proxy';
- * import { h3 as h3Adapter } from '@providerprotocol/ai/proxy/server';
+ * import { parseBody, h3 as h3Adapter } from '@providerprotocol/ai/proxy';
  *
  * export default defineEventHandler(async (event) => {
  *   const body = await readBody(event);
@@ -124,7 +126,7 @@ declare function sendError(message: string, status: number, event: H3Event): {
  *
  *   const wantsStream = getHeader(event, 'accept')?.includes('text/event-stream');
  *   if (wantsStream) {
- *     return h3Adapter.streamSSE(instance.stream(messages), event);
+ *     return sendStream(event, h3Adapter.createSSEStream(instance.stream(messages)));
  *   } else {
  *     const turn = await instance.generate(messages);
  *     return h3Adapter.sendJSON(turn, event);
@@ -135,11 +137,11 @@ declare function sendError(message: string, status: number, event: H3Event): {
  * @example API Gateway with authentication (Nuxt)
  * ```typescript
  * // server/api/ai.post.ts
+ * import { sendStream } from 'h3';
  * import { llm } from '@providerprotocol/ai';
  * import { anthropic } from '@providerprotocol/ai/anthropic';
  * import { ExponentialBackoff, RoundRobinKeys } from '@providerprotocol/ai/http';
- * import { parseBody } from '@providerprotocol/ai/proxy';
- * import { h3 as h3Adapter } from '@providerprotocol/ai/proxy/server';
+ * import { parseBody, h3 as h3Adapter } from '@providerprotocol/ai/proxy';
  *
  * // Server manages AI provider keys - users never see them
  * const claude = llm({
@@ -168,7 +170,7 @@ declare function sendError(message: string, status: number, event: H3Event): {
  *   const { messages, system, params } = parseBody(body);
  *
  *   if (params?.stream) {
- *     return h3Adapter.streamSSE(claude.stream(messages, { system }), event);
+ *     return sendStream(event, h3Adapter.createSSEStream(claude.stream(messages, { system })));
  *   }
  *   const turn = await claude.generate(messages, { system });
  *   return h3Adapter.sendJSON(turn, event);

package/dist/proxy/server/h3/index.js

@@ -8,8 +8,9 @@ import {
   sendJSON,
   streamImageSSE,
   streamSSE
-} from "../../../chunk-ZRVNAET3.js";
-import "../../../chunk-YQLR3XOA.js";
+} from "../../../chunk-KNBODIQU.js";
+import "../../../chunk-BIBMNP7Y.js";
+import "../../../chunk-7ULSRWDH.js";
 import "../../../chunk-ETBFOLQN.js";
 import "../../../chunk-N5DX5JW3.js";
 import "../../../chunk-WU4U6IHF.js";

package/dist/proxy/server/index.d.ts

@@ -6,10 +6,11 @@ import { sendJSON, sendEmbeddingJSON, sendImageJSON, streamSSE, streamImageSSE,
 export { express } from './express/index.js';
 import { parseBody, parseEmbeddingBody, parseImageBody, toJSON, toEmbeddingJSON, toImageJSON, toSSE, toImageSSE, toError, bindTools } from './webapi/index.js';
 export { ParsedEmbeddingRequest, ParsedImageRequest, ParsedRequest, webapi } from './webapi/index.js';
-import { M as Message, J as JSONSchema, H as ToolMetadata, T as Turn, i as StreamResult } from '../../stream-sXhBtWjl.js';
-import '../../embedding-CwZ1ZNWv.js';
-import '../../llm-DS_-l71X.js';
-import '../../image-stream-CeQHtjxS.js';
+import { M as Message, T as Turn, g as StreamResult } from '../../stream-DVVUIKpz.js';
+import { J as JSONSchema, j as ToolMetadata } from '../../tool-D22EhP5F.js';
+import '../../embedding-iNQCeXfk.js';
+import '../../llm-CZqlijjK.js';
+import '../../image-stream-ARno6XlS.js';
 
 /**
  * @fileoverview Shared types for proxy server adapters.

package/dist/proxy/server/index.js

@@ -1,12 +1,15 @@
 import {
   server
-} from "../../chunk-IK6NRCW5.js";
+} from "../../chunk-RDC5GYST.js";
+import {
+  express
+} from "../../chunk-O32SBS6S.js";
 import {
   h3
-} from "../../chunk-ZRVNAET3.js";
+} from "../../chunk-KNBODIQU.js";
 import {
   fastify
-} from "../../chunk-7GTWHZY2.js";
+} from "../../chunk-IDZR4ROP.js";
 import {
   bindTools,
   parseBody,
@@ -19,11 +22,9 @@ import {
   toJSON,
   toSSE,
   webapi
-} from "../../chunk-LTEMH3CI.js";
-import {
-  express
-} from "../../chunk-FYSZFIZS.js";
-import "../../chunk-YQLR3XOA.js";
+} from "../../chunk-5XPRVUOK.js";
+import "../../chunk-BIBMNP7Y.js";
+import "../../chunk-7ULSRWDH.js";
 import "../../chunk-ETBFOLQN.js";
 import "../../chunk-N5DX5JW3.js";
 import "../../chunk-WU4U6IHF.js";

package/dist/proxy/server/webapi/index.d.ts

@@ -1,7 +1,8 @@
-import { M as Message, J as JSONSchema, H as ToolMetadata, T as Turn, i as StreamResult, d as Tool } from '../../../stream-sXhBtWjl.js';
-import { o as Image, E as EmbeddingInput, N as ImageResult } from '../../../llm-DS_-l71X.js';
-import { d as EmbeddingResult } from '../../../embedding-CwZ1ZNWv.js';
-import { I as ImageStreamLike } from '../../../image-stream-CeQHtjxS.js';
+import { M as Message, T as Turn, g as StreamResult } from '../../../stream-DVVUIKpz.js';
+import { o as Image, E as EmbeddingInput, N as ImageResult } from '../../../llm-CZqlijjK.js';
+import { J as JSONSchema, j as ToolMetadata, b as Tool } from '../../../tool-D22EhP5F.js';
+import { d as EmbeddingResult } from '../../../embedding-iNQCeXfk.js';
+import { I as ImageStreamLike } from '../../../image-stream-ARno6XlS.js';
 
 /**
  * @fileoverview Media serialization utilities for proxy transport.

package/dist/proxy/server/webapi/index.js

@@ -10,8 +10,9 @@ import {
   toJSON,
   toSSE,
   webapi
-} from "../../../chunk-LTEMH3CI.js";
-import "../../../chunk-YQLR3XOA.js";
+} from "../../../chunk-5XPRVUOK.js";
+import "../../../chunk-BIBMNP7Y.js";
+import "../../../chunk-7ULSRWDH.js";
 import "../../../chunk-ETBFOLQN.js";
 import "../../../chunk-N5DX5JW3.js";
 import "../../../chunk-WU4U6IHF.js";

package/dist/responses/index.d.ts

@@ -1,5 +1,6 @@
-import { e as Provider } from '../llm-DS_-l71X.js';
-import '../stream-sXhBtWjl.js';
+import { e as Provider } from '../llm-CZqlijjK.js';
+import '../stream-DVVUIKpz.js';
+import '../tool-D22EhP5F.js';
 
 /**
  * @fileoverview OpenResponses Provider Type Definitions

package/dist/{retry-CgoBNa51.d.ts → retry-C1eJbEMV.d.ts}

@@ -1,4 +1,4 @@
-import { K as KeyStrategy, c as ProviderConfig, f as Modality, R as RetryStrategy, U as UPPError } from './llm-DS_-l71X.js';
+import { K as KeyStrategy, c as ProviderConfig, f as Modality, R as RetryStrategy, U as UPPError } from './llm-CZqlijjK.js';
 
 /**
  * API key management strategies for load balancing and dynamic key selection.

package/dist/{stream-sXhBtWjl.d.ts → stream-DVVUIKpz.d.ts}

@@ -1,3 +1,5 @@
+import { c as ToolCall, d as ToolResult, e as ToolExecution } from './tool-D22EhP5F.js';
+
 /**
  * @fileoverview Content block types for multimodal messages.
  *
@@ -500,421 +502,6 @@ declare function isVideoBlock(block: ContentBlock): block is VideoBlock;
  */
 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.
  *
@@ -1644,4 +1231,4 @@ declare function toolExecutionStart(toolCallId: string, toolName: string, timest
  */
 declare function toolExecutionEnd(toolCallId: string, toolName: string, result: unknown, isError: boolean, timestamp: number, index?: number): StreamEvent;
 
-export { createTurn as $, type AssistantContent as A, type BinaryBlock as B, type ContentBlock as C, type DocumentSource as D, type EventDelta as E, type ToolCall as F, type ToolResult as G, type ToolMetadata as H, type ImageSource as I, type JSONSchema as J, type BeforeCallResult as K, type AfterCallResult as L, Message as M, type ToolExecution as N, UserMessage as O, ToolResultMessage as P, MessageRole as Q, type ReasoningBlock as R, type StreamEvent as S, type Turn as T, type UserContent as U, type VideoBlock as V, isUserMessage as W, isAssistantMessage as X, isToolResultMessage as Y, type MessageMetadata as Z, type MessageOptions as _, type MessageJSON as a, emptyUsage as a0, aggregateUsage as a1, StreamEventType as a2, createStreamResult as a3, textDelta as a4, toolCallDelta as a5, objectDelta as a6, messageStart as a7, messageStop as a8, contentBlockStart as a9, contentBlockStop as aa, toolExecutionStart as ab, toolExecutionEnd as ac, type TurnJSON as b, type ImageBlock as c, type Tool as d, type MessageType as e, type ToolUseStrategy as f, AssistantMessage as g, type TokenUsage as h, type StreamResult as i, type DocumentBlock as j, type AudioBlock as k, type JSONSchemaProperty as l, type JSONSchemaPropertyType as m, type TextBlock as n, ContentBlockType as o, ImageSourceType as p, DocumentSourceType as q, reasoning as r, isTextBlock as s, text as t, isReasoningBlock as u, isImageBlock as v, isDocumentBlock as w, isAudioBlock as x, isVideoBlock as y, isBinaryBlock as z };
+export { contentBlockStop as $, type AssistantContent as A, type BinaryBlock as B, type ContentBlock as C, type DocumentSource as D, type EventDelta as E, isAssistantMessage as F, isToolResultMessage as G, type MessageMetadata as H, type ImageSource as I, type MessageOptions as J, createTurn as K, emptyUsage as L, Message as M, aggregateUsage as N, StreamEventType as O, createStreamResult as P, textDelta as Q, type ReasoningBlock as R, type StreamEvent as S, type Turn as T, type UserContent as U, type VideoBlock as V, toolCallDelta as W, objectDelta as X, messageStart as Y, messageStop as Z, contentBlockStart as _, type MessageJSON as a, toolExecutionStart as a0, toolExecutionEnd as a1, type TurnJSON as b, type ImageBlock as c, type MessageType as d, AssistantMessage as e, type TokenUsage as f, type StreamResult as g, type DocumentBlock as h, type AudioBlock as i, type TextBlock as j, ContentBlockType as k, ImageSourceType as l, DocumentSourceType as m, isTextBlock as n, isReasoningBlock as o, isImageBlock as p, isDocumentBlock as q, reasoning as r, isAudioBlock as s, text as t, isVideoBlock as u, isBinaryBlock as v, UserMessage as w, ToolResultMessage as x, MessageRole as y, isUserMessage as z };