@providerprotocol/ai 0.0.31 → 0.0.33

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

@@ -1407,6 +1407,8 @@ declare const StreamEventType: {
     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 */
@@ -1431,24 +1433,40 @@ 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.
+ * 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 (for text_delta, reasoning_delta) */
+    /** Incremental text content (text_delta, reasoning_delta, object_delta) */
     text?: string;
-    /** Incremental binary data (for image_delta, audio_delta, video_delta) */
+    /** Incremental binary data (image_delta, audio_delta, video_delta) */
     data?: Uint8Array;
-    /** Tool call identifier (for tool_call_delta, tool_execution_start/end) */
+    /** Tool call identifier (tool_call_delta, tool_execution_start/end) */
     toolCallId?: string;
-    /** Tool name (for tool_call_delta, tool_execution_start/end) */
+    /** Tool name (tool_call_delta, tool_execution_start/end) */
     toolName?: string;
-    /** Incremental JSON arguments string (for tool_call_delta) */
+    /** Incremental JSON arguments string (tool_call_delta) */
     argumentsJson?: string;
-    /** Tool execution result (for tool_execution_end) */
+    /** Tool execution result (tool_execution_end) */
     result?: unknown;
-    /** Whether tool execution resulted in an error (for tool_execution_end) */
+    /** Whether tool execution resulted in an error (tool_execution_end) */
     isError?: boolean;
-    /** Timestamp in milliseconds (for tool_execution_start/end) */
+    /** Timestamp in milliseconds (tool_execution_start/end) */
     timestamp?: number;
 }
 /**
@@ -1554,6 +1572,14 @@ declare function textDelta(text: string, index?: number): StreamEvent;
  * @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.
  *
@@ -1580,6 +1606,28 @@ declare function contentBlockStart(index: number): StreamEvent;
  * @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;
 
 /**
  * @fileoverview Error types for the Unified Provider Protocol.
@@ -1913,6 +1961,198 @@ declare class Image {
     static fromBlock(block: ImageBlock): Image;
 }
 
+/**
+ * @fileoverview Middleware types for the Universal Provider Protocol.
+ *
+ * Defines the interfaces for composable middleware that can intercept and
+ * transform requests, responses, and stream events across all modalities.
+ *
+ * @module types/middleware
+ */
+
+/**
+ * Modality discriminator for middleware context.
+ */
+type MiddlewareModality = 'llm' | 'embedding' | 'image';
+/**
+ * Union type for all request types across modalities.
+ */
+type AnyRequest = LLMRequest | EmbeddingRequest | ImageRequest;
+/**
+ * Union type for all response types across modalities.
+ */
+type AnyResponse = LLMResponse | EmbeddingResponse | ImageResponse;
+/**
+ * Shared context passed to all middleware hooks.
+ *
+ * Provides access to request/response data, timing information,
+ * and a shared state map for passing data between middleware.
+ *
+ * @example
+ * ```typescript
+ * const loggingMiddleware: Middleware = {
+ *   name: 'logging',
+ *   onStart(ctx) {
+ *     ctx.state.set('requestId', crypto.randomUUID());
+ *   },
+ *   onEnd(ctx) {
+ *     const duration = ctx.endTime! - ctx.startTime;
+ *     console.log(`[${ctx.provider}] ${ctx.state.get('requestId')} completed in ${duration}ms`);
+ *   },
+ * };
+ * ```
+ */
+interface MiddlewareContext {
+    /** The modality being used */
+    readonly modality: MiddlewareModality;
+    /** Model ID */
+    readonly modelId: string;
+    /** Provider name */
+    readonly provider: string;
+    /** Whether this is a streaming request */
+    readonly streaming: boolean;
+    /** Request object (modality-specific, mutable for onRequest hook) */
+    request: AnyRequest;
+    /** Response object (populated after execution, mutable for onResponse hook) */
+    response?: AnyResponse;
+    /** Shared state across middleware - use for passing data between hooks */
+    readonly state: Map<string, unknown>;
+    /** Request start timestamp in milliseconds */
+    readonly startTime: number;
+    /** Request end timestamp in milliseconds (set after completion) */
+    endTime?: number;
+}
+/**
+ * Context for stream event hooks.
+ *
+ * Provides a shared state map for middleware to store and retrieve data.
+ * Middleware that need to accumulate text or other data should manage
+ * their own state using the provided state map.
+ *
+ * @example
+ * ```typescript
+ * const filterMiddleware: Middleware = {
+ *   name: 'reasoning-filter',
+ *   onStreamEvent(event, ctx) {
+ *     // Filter out reasoning events
+ *     if (event.type === StreamEventType.ReasoningDelta) {
+ *       return null;
+ *     }
+ *     return event;
+ *   },
+ * };
+ * ```
+ */
+interface StreamContext {
+    /** Shared state (same reference as MiddlewareContext.state) */
+    readonly state: Map<string, unknown>;
+}
+/**
+ * Middleware interface with optional hooks.
+ *
+ * Implement only the hooks you need. Middleware are executed in array order
+ * for request/start hooks, and reverse order for response/end hooks.
+ *
+ * @example
+ * ```typescript
+ * import { type Middleware, StreamEventType } from '@providerprotocol/ai';
+ *
+ * const customMiddleware: Middleware = {
+ *   name: 'request-id',
+ *
+ *   onRequest(ctx) {
+ *     ctx.state.set('requestId', crypto.randomUUID());
+ *   },
+ *
+ *   onStreamEvent(event, ctx) {
+ *     // Filter out reasoning events
+ *     if (event.type === StreamEventType.ReasoningDelta) {
+ *       return null;
+ *     }
+ *     return event;
+ *   },
+ *
+ *   onEnd(ctx) {
+ *     const duration = ctx.endTime! - ctx.startTime;
+ *     console.log(`Request ${ctx.state.get('requestId')} took ${duration}ms`);
+ *   },
+ * };
+ * ```
+ */
+interface Middleware {
+    /** Middleware name for debugging and logging */
+    readonly name: string;
+    /**
+     * Called when generate/stream starts, before any provider execution.
+     *
+     * @param ctx - The middleware context
+     */
+    onStart?(ctx: MiddlewareContext): void | Promise<void>;
+    /**
+     * Called when generate/stream completes successfully.
+     * Called in reverse middleware order.
+     *
+     * @param ctx - The middleware context with response populated
+     */
+    onEnd?(ctx: MiddlewareContext): void | Promise<void>;
+    /**
+     * Called on any error during execution.
+     * Called for all middleware that have this hook, regardless of order.
+     *
+     * @param error - The error that occurred
+     * @param ctx - The middleware context
+     */
+    onError?(error: Error, ctx: MiddlewareContext): void | Promise<void>;
+    /**
+     * Called before provider execution. Can modify the request.
+     *
+     * @param ctx - The middleware context with mutable request
+     */
+    onRequest?(ctx: MiddlewareContext): void | Promise<void>;
+    /**
+     * Called after provider execution. Can modify the response.
+     * Called in reverse middleware order.
+     *
+     * @param ctx - The middleware context with mutable response
+     */
+    onResponse?(ctx: MiddlewareContext): void | Promise<void>;
+    /**
+     * Called for each stream event. Can transform, filter, or expand events.
+     *
+     * Return values:
+     * - `StreamEvent` - Pass through (potentially modified)
+     * - `StreamEvent[]` - Expand into multiple events
+     * - `null` - Filter out this event
+     *
+     * @param event - The stream event to process
+     * @param ctx - The stream context
+     * @returns Transformed event(s) or null to filter
+     */
+    onStreamEvent?(event: StreamEvent, ctx: StreamContext): StreamEvent | StreamEvent[] | null;
+    /**
+     * Called when stream completes, after all events have been processed.
+     *
+     * @param ctx - The stream context
+     */
+    onStreamEnd?(ctx: StreamContext): void | Promise<void>;
+    /**
+     * Called when a tool is about to be executed.
+     *
+     * @param tool - The tool being called
+     * @param params - The parameters for the tool call
+     * @param ctx - The middleware context
+     */
+    onToolCall?(tool: Tool, params: unknown, ctx: MiddlewareContext): void | Promise<void>;
+    /**
+     * Called after tool execution completes.
+     *
+     * @param tool - The tool that was executed
+     * @param result - The result from the tool
+     * @param ctx - The middleware context
+     */
+    onToolResult?(tool: Tool, result: unknown, ctx: MiddlewareContext): void | Promise<void>;
+}
+
 /**
  * @fileoverview Image generation types for the Universal Provider Protocol.
  *
@@ -1959,6 +2199,13 @@ interface ImageOptions<TParams = unknown> {
     config?: ProviderConfig;
     /** Provider-specific parameters (passed through unchanged) */
     params?: TParams;
+    /**
+     * Middleware for intercepting and transforming requests and responses.
+     *
+     * Middleware are executed in array order for request/start hooks,
+     * and reverse order for response/end hooks.
+     */
+    middleware?: Middleware[];
 }
 /**
  * Options for image generation.
@@ -2506,6 +2753,8 @@ interface EmbeddingRequest<TParams = unknown> {
     config: ProviderConfig;
     /** Abort signal for cancellation */
     signal?: AbortSignal;
+    /** Input type hint for provider-specific optimization */
+    inputType?: 'document' | 'query';
 }
 /**
  * Response from provider's embed method.
@@ -2959,6 +3208,24 @@ interface LLMOptions<TParams = unknown> {
     toolStrategy?: ToolUseStrategy;
     /** Structured output schema (JSON Schema) */
     structure?: JSONSchema;
+    /**
+     * Middleware for intercepting and transforming requests, responses, and streams.
+     *
+     * Middleware are executed in array order for request/start hooks,
+     * and reverse order for response/end hooks.
+     *
+     * @example
+     * ```typescript
+     * const model = llm({
+     *   model: anthropic('claude-sonnet-4-20250514'),
+     *   middleware: [
+     *     loggingMiddleware(),
+     *     parsedObjectMiddleware(),
+     *   ],
+     * });
+     * ```
+     */
+    middleware?: Middleware[];
 }
 /**
  * LLM instance returned by the llm() function.
@@ -3115,4 +3382,4 @@ interface BoundLLMModel<TParams = unknown> {
     stream(request: LLMRequest<TParams>): LLMStreamResult;
 }
 
-export { MessageRole as $, type AudioBlock as A, type BinaryBlock as B, type ContentBlock as C, type DocumentSource as D, type EmbeddingHandler as E, isBinaryBlock as F, type Tool as G, type ToolCall as H, type ImageOptions as I, type JSONSchema as J, type ToolResult as K, type LLMOptions as L, type ModelReference as M, type ToolMetadata as N, type ToolUseStrategy as O, type Provider as P, type BeforeCallResult as Q, type ReasoningBlock as R, type AfterCallResult as S, type TextBlock as T, UPPError as U, type VideoBlock as V, type ToolExecution as W, Message as X, UserMessage as Y, AssistantMessage as Z, ToolResultMessage as _, type LLMInstance as a, isUserMessage as a0, isAssistantMessage as a1, isToolResultMessage as a2, type MessageType as a3, type MessageMetadata as a4, type MessageOptions as a5, type Turn as a6, type TokenUsage as a7, createTurn as a8, emptyUsage as a9, type EmbeddingUsage as aA, type EmbeddingInput as aB, type LLMCapabilities as aC, type LLMRequest as aD, type LLMResponse as aE, type LLMStreamResult as aF, type BoundLLMModel as aG, type InferenceInput as aH, type ImageInput as aI, type ImageEditInput as aJ, type ImageGenerateOptions as aK, type GeneratedImage as aL, type ImageUsage as aM, type ImageResult as aN, type ImageStreamEvent as aO, type ImageStreamResult as aP, type ImageCapabilities as aQ, type ImageRequest as aR, type ImageEditRequest as aS, type ImageResponse as aT, type ImageProviderStreamResult as aU, type BoundImageModel as aV, type ImageModelInput as aW, type TurnJSON as aX, aggregateUsage as aa, Thread as ab, type ThreadJSON as ac, type MessageJSON as ad, type StreamEvent as ae, type EventDelta as af, type StreamResult as ag, StreamEventType as ah, createStreamResult as ai, textDelta as aj, toolCallDelta as ak, messageStart as al, messageStop as am, contentBlockStart as an, contentBlockStop as ao, type ProviderIdentity as ap, type ProviderConfig as aq, type KeyStrategy as ar, type RetryStrategy as as, type LLMProvider as at, type EmbeddingProvider as au, type ImageProvider as av, type BoundEmbeddingModel as aw, type EmbeddingRequest as ax, type EmbeddingResponse as ay, type EmbeddingVector as az, type ImageInstance as b, type LLMHandler as c, type ImageHandler as d, type DocumentBlock as e, Image as f, ErrorCode as g, ModalityType as h, type Modality as i, type JSONSchemaProperty as j, type JSONSchemaPropertyType as k, type ImageBlock as l, type ImageSource as m, type UserContent as n, type AssistantContent as o, ContentBlockType as p, ImageSourceType as q, DocumentSourceType as r, reasoning as s, text as t, isTextBlock as u, isReasoningBlock as v, isImageBlock as w, isDocumentBlock as x, isAudioBlock as y, isVideoBlock as z };
+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 };

package/dist/ollama/index.d.ts

@@ -1,4 +1,4 @@
-import { P as Provider } from '../llm-DgDEy9il.js';
+import { P as Provider } from '../llm-BQJZj3cD.js';
 
 /**
  * @fileoverview Type definitions for the Ollama provider.

package/dist/ollama/index.js

@@ -2,8 +2,9 @@ import {
   parseJsonResponse
 } from "../chunk-3C7O2RNO.js";
 import {
-  StreamEventType
-} from "../chunk-73IIE3QT.js";
+  StreamEventType,
+  objectDelta
+} from "../chunk-6S222DHN.js";
 import {
   AssistantMessage,
   createProvider,
@@ -562,7 +563,11 @@ function createLLMHandler() {
                 }
                 const events = transformStreamChunk(chunk, state);
                 for (const event of events) {
-                  yield event;
+                  if (request.structure && event.type === StreamEventType.TextDelta) {
+                    yield objectDelta(event.delta.text ?? "", event.index);
+                  } else {
+                    yield event;
+                  }
                 }
               }
               responseResolve(buildResponseFromState(state));