ai-stream-utils 2.0.1 → 2.2.0

package/README.md

@@ -15,9 +15,9 @@ This library provides composable filter and transformation utilities for UI mess
 
 The AI SDK UI message stream created by [`toUIMessageStream()`](https://ai-sdk.dev/docs/reference/ai-sdk-core/stream-text#to-ui-message-stream) streams all parts (text, tools, reasoning, etc.) to the client by default. However, you may want to:
 
-- **Filter**: Tool calls like database queries often contain large amounts of data or sensitive information that should not be streamed to the client
+- **Filter**: Tool calls like database searches often contain large amounts of data or sensitive information that should not be streamed to the client
 - **Transform**: Modify text or tool outputs while they are streamed to the client
-- **Observe**: Log stream lifecycle events, tool calls, or other chunks without consuming or modifying the stream
+- **Observe**: Log stream lifecycle events, update states, or run side-effects without modifying the stream
 
 This library provides type-safe, composable utilities for all these use cases.
 
@@ -52,21 +52,56 @@ const stream = pipe(result.toUIMessageStream())
   .toStream();
 ```
 
-**Type guards** provide a simpler API for common filtering patterns:
+#### Type Guards
 
-- `includeChunks("text-delta")` or `includeChunks(["text-delta", "text-end"])`: Include specific chunk types
-- `excludeChunks("text-delta")` or `excludeChunks(["text-delta", "text-end"])`: Exclude specific chunk types
-- `includeParts("text")` or `includeParts(["text", "reasoning"])`: Include specific part types
-- `excludeParts("reasoning")` or `excludeParts(["reasoning", "tool-database"])`: Exclude specific part types
+Generic type guards provide a simpler API for common filtering patterns:
 
-**Example:** Exclude tool calls from the client.
+- `includeChunks("text-delta")` or `includeChunks(["text-delta", "text-end"])`: Include **only** specific chunk types
+- `excludeChunks("text-delta")` or `excludeChunks(["text-delta", "text-end"])`: Exclude **only** specific chunk types
+- `includeParts("text")` or `includeParts(["text", "reasoning"])`: Include **only** specific part types
+- `excludeParts("reasoning")` or `excludeParts(["reasoning", "tool-database"])`: Exclude **only** specific part types
+
+Filtering tools is the most common use case and the tool-filter type guards provide a convenient API for filtering tool chunks by tool name:
+
+- `excludeTools()` or `excludeTools("weather")` or `excludeTools(["weather", "database"])`: Exclude all tools or specific tools by name
+- `includeTools()` or `includeTools("weather")` or `includeTools(["weather", "database"])`: Include all tools or specific tools by name
+
+> [!NOTE]
+> The tool-filter type guards only affect tool chunks. Non-tool chunks will pass through.
+
+#### Examples
+
+Exclude tool calls from the client.
 
 ```typescript
+// Exclude by part type (requires "tool-" prefix)
 const stream = pipe(result.toUIMessageStream())
   .filter(excludeParts(["tool-weather", "tool-database"]))
   .toStream();
+
+// Exclude by tool name (without "tool-" prefix)
+const stream = pipe(result.toUIMessageStream())
+  .filter(excludeTools(["weather", "database"]))
+  .toStream();
+
+// Exclude all tools
+const stream = pipe(result.toUIMessageStream()).filter(excludeTools()).toStream();
+
+// Include only specific tools (without "tool-" prefix)
+const stream = pipe(result.toUIMessageStream())
+  .filter(includeTools(["weather"]))
+  .toStream();
 ```
 
+> [!NOTE]
+> `excludeTools()` and `includeTools()` filters tool chunks on the server before streaming to the client. This affects all tool types including:
+>
+> - Server-side tools with `execute` functions
+> - Client-side tools without `execute` functions
+> - Tools that require human approval via `needsApproval`
+>
+> Excluded tools will not appear in the client's message parts, so users won't see tool call UI or be able to approve/reject filtered tools.
+
 ### `.map()`
 
 Transform chunks by returning a chunk, an array of chunks, or `null` to exclude.
@@ -94,7 +129,9 @@ const stream = pipe(result.toUIMessageStream())
   .toStream();
 ```
 
-**Example:** Convert text to uppercase.
+#### Examples
+
+Convert text to uppercase.
 
 ```typescript
 const stream = pipe(result.toUIMessageStream())
@@ -127,30 +164,59 @@ const stream = pipe(result.toUIMessageStream())
   .toStream();
 ```
 
+#### Type Guards
+
 **Type guard** provides a type-safe way to observe specific chunk types:
 
 - `chunkType("text-delta")` or `chunkType(["start", "finish"])`: Observe specific chunk types
 - `partType("text")` or `partType(["text", "reasoning"])`: Observe chunks belonging to specific part types
+- `toolCall()` or `toolCall({ tool: "weather" })` or `toolCall({ state: "output-available" })`: Observe tool state transitions
+
+The `toolCall()` guard matches tool chunks representing state transitions (not streaming events):
+
+- `input-available`: Tool input fully parsed
+- `approval-requested`: Tool awaiting user approval
+- `output-available`: Tool execution completed
+- `output-error`: Tool execution failed
+- `output-denied`: User denied approval
 
 > [!NOTE]
 > The `partType` type guard still operates on chunks. That means `partType("text")` will match any text chunks such as `text-start`, `text-delta`, and `text-end`.
 
-**Example:** Log stream lifecycle events.
+#### Examples
+
+Log stream lifecycle events.
 
 ```typescript
 const stream = pipe(result.toUIMessageStream())
-  .on(chunkType("start"), () => {
-    console.log("Stream started");
+  .on(chunkType("start"), ({ chunk }) => {
+    console.log("Stream started:", chunk.messageId);
   })
   .on(chunkType("finish"), ({ chunk }) => {
     console.log("Stream finished:", chunk.finishReason);
   })
   .on(chunkType("tool-input-available"), ({ chunk }) => {
-    console.log("Tool called:", chunk.toolName, chunk.input);
+    console.log("Tool input:", chunk.toolName, chunk.input);
+  })
+  .on(chunkType("tool-output-available"), ({ chunk }) => {
+    console.log("Tool output:", chunk.toolName, chunk.output);
   })
   .toStream();
 ```
 
+Observe tool state transitions.
+
+```typescript
+const stream = pipe(result.toUIMessageStream())
+  .on(toolCall({ tool: "weather", state: "approval-requested" }), ({ chunk }) => {
+    console.log("Weather tool needs approval");
+  })
+  .toStream();
+```
+
+> [!NOTE]
+> The `tool` option filters by part type (`tool-{name}`). Dynamic tools have part type `dynamic-tool`, so `toolCall({ tool: "myTool" })` will not match dynamic tools. Use `toolCall()` without the `tool` option to observe all tools including dynamic ones.
+
 ### `.toStream()`
 
 Convert the pipeline back to a `AsyncIterableStream<InferUIMessageChunk<UI_MESSAGE>>` that can be returned to the client or consumed.
@@ -183,8 +249,8 @@ Multiple operators can be chained together. After filtering with type guards, ch
 const stream = pipe<MyUIMessage>(result.toUIMessageStream())
   .filter(includeParts("text"))
   .map(({ chunk, part }) => {
-    // chunk is narrowed to text chunks only
-    // part.type is narrowed to "text"
+    // chunk is narrowed to text chunks: "text-start" | "text-delta" | "text-end"
+    // part is narrowed to "text"
     return chunk;
   })
   .toStream();

package/dist/index.d.mts

@@ -1,6 +1,6 @@
-import { a as convertSSEToUIMessageStream, c as convertArrayToStream, i as convertStreamToArray, l as convertArrayToAsyncIterable, n as createAsyncIterableStream, o as convertAsyncIterableToStream, r as convertUIMessageToSSEStream, s as convertAsyncIterableToArray, t as AsyncIterableStream } from "./types-B4nePmEd.mjs";
+import { a as convertSSEToUIMessageStream, c as convertArrayToStream, i as convertStreamToArray, l as convertArrayToAsyncIterable, n as createAsyncIterableStream, o as convertAsyncIterableToStream, r as convertUIMessageToSSEStream, s as convertAsyncIterableToArray, t as AsyncIterableStream } from "./types-CNApJ39t.mjs";
 import "./utils/index.mjs";
-import { AsyncIterableStream as AsyncIterableStream$1, InferUIMessageChunk, UIMessage } from "ai";
+import { AsyncIterableStream as AsyncIterableStream$1, InferUIMessageChunk, UIDataTypes, UIMessage, UITools } from "ai";
 
 //#region src/consume/consume-ui-message-stream.d.ts
 /**
@@ -181,6 +181,7 @@ declare function filterUIMessageStream<UI_MESSAGE extends UIMessage>(stream: Rea
 type InferUIMessagePart<UI_MESSAGE extends UIMessage> = UI_MESSAGE["parts"][number];
 type InferUIMessagePartType<UI_MESSAGE extends UIMessage> = InferUIMessagePart<UI_MESSAGE>["type"];
 type InferUIMessageChunkType<UI_MESSAGE extends UIMessage> = InferUIMessageChunk<UI_MESSAGE>["type"];
+type InferUIMessageTools<UI_MESSAGE extends UIMessage> = UI_MESSAGE extends UIMessage<unknown, UIDataTypes, infer TOOLS> ? TOOLS : UITools;
 /**
  * Extracts chunk type strings that match the prefix exactly or as `${PREFIX}-*`.
  * Dynamically derives chunk types from the actual UIMessageChunk union.
@@ -318,6 +319,47 @@ type InferPartForChunk<UI_MESSAGE extends UIMessage, CHUNK_TYPE extends string>
  * ```
  */
 type ExcludePartForChunks<UI_MESSAGE extends UIMessage, EXCLUDED_CHUNK_TYPE extends string> = { [PT in InferUIMessagePartType<UI_MESSAGE>]: [Exclude<PartTypeToChunkTypes<UI_MESSAGE, PT>, EXCLUDED_CHUNK_TYPE>] extends [never] ? never : PT }[InferUIMessagePartType<UI_MESSAGE>];
+/**
+ * Extract tool names from UIMessage tools.
+ *
+ * @example
+ * ```typescript
+ * type Tools = InferToolName<MyUIMessage>;
+ * // => 'weather' | 'calculator'
+ * ```
+ */
+type InferToolName<UI_MESSAGE extends UIMessage> = keyof InferUIMessageTools<UI_MESSAGE> & string;
+/**
+ * All tool-related part types (tool-* and dynamic-tool).
+ */
+type ToolPartTypes<UI_MESSAGE extends UIMessage> = Extract<InferUIMessagePartType<UI_MESSAGE>, `tool-${string}` | `dynamic-tool`>;
+/**
+ * Part types remaining after excluding all tools.
+ */
+type ExcludeToolPartTypes<UI_MESSAGE extends UIMessage> = Exclude<InferUIMessagePartType<UI_MESSAGE>, ToolPartTypes<UI_MESSAGE>>;
+/**
+ * Chunk types for tools (tool-input-*, tool-output-*, etc.).
+ */
+type ToolChunkTypes<UI_MESSAGE extends UIMessage> = Extract<InferUIMessageChunkType<UI_MESSAGE>, `tool-${string}`>;
+/**
+ * Content chunk types remaining after excluding all tool chunks.
+ */
+type ExcludeToolChunkTypes<UI_MESSAGE extends UIMessage> = Exclude<ContentChunkType<UI_MESSAGE>, ToolChunkTypes<UI_MESSAGE>>;
+/**
+ * Tool states that have corresponding stream chunks.
+ * These are the "final" states from UIToolInvocation, not streaming events.
+ */
+type ToolCallState = "input-available" | "approval-requested" | "output-available" | "output-error" | "output-denied";
+/**
+ * Map tool states to their corresponding chunk types.
+ */
+type ToolStateToChunkType = {
+  "input-available": "tool-input-available";
+  "approval-requested": "tool-approval-request";
+  "output-available": "tool-output-available";
+  "output-error": "tool-output-error";
+  "output-denied": "tool-output-denied";
+};
 //#endregion
 //#region src/flat-map/flat-map-ui-message-stream.d.ts
 /**
@@ -549,8 +591,8 @@ declare class ChunkPipeline<UI_MESSAGE extends UIMessage, CHUNK extends InferUIM
    * Content chunks include a part object with the type, while meta chunks have undefined part.
    * All chunks pass through regardless of whether the callback is invoked.
    */
-  on<NARROWED_CHUNK extends CHUNK, NARROWED_PART extends {
-    type: PART[`type`];
+  on<NARROWED_CHUNK extends InferUIMessageChunk<UI_MESSAGE>, NARROWED_PART extends {
+    type: string;
   } | undefined>(guard: ObserveGuard<UI_MESSAGE, NARROWED_CHUNK, NARROWED_PART>, callback: ChunkObserveFn<NARROWED_CHUNK, NARROWED_PART>): ChunkPipeline<UI_MESSAGE, CHUNK, PART>;
   /**
    * Observes chunks matching a predicate without filtering them.
@@ -707,5 +749,114 @@ declare function chunkType<UI_MESSAGE extends UIMessage, CHUNK_TYPE extends Infe
 declare function partType<UI_MESSAGE extends UIMessage, PART_TYPE extends InferUIMessagePartType<UI_MESSAGE>>(types: PART_TYPE | Array<PART_TYPE>): ObserveGuard<UI_MESSAGE, ExtractChunkForPart<UI_MESSAGE, ExtractPart<UI_MESSAGE, PART_TYPE>>, {
   type: PART_TYPE;
 }>;
+/**
+ * Creates a filter guard that includes only specific tools while keeping non-tool chunks.
+ * Use with `.filter()` to include only specific tools.
+ *
+ * @example
+ * ```typescript
+ * // No-op: all chunks pass through
+ * pipe<MyUIMessage>(stream)
+ *   .filter(includeTools())
+ *   .map(({ chunk }) => chunk); // all chunks pass
+ *
+ * // Include specific tool (non-tool chunks still pass)
+ * pipe<MyUIMessage>(stream)
+ *   .filter(includeTools('weather'))
+ *   .map(({ chunk }) => chunk); // text + tool-weather chunks
+ *
+ * // Include multiple tools
+ * pipe<MyUIMessage>(stream)
+ *   .filter(includeTools(['weather', 'calculator']))
+ *   .map(({ chunk }) => chunk); // text + specified tool chunks
+ * ```
+ */
+declare function includeTools<UI_MESSAGE extends UIMessage>(): FilterGuard<UI_MESSAGE, InferUIMessageChunk<UI_MESSAGE>, {
+  type: InferUIMessagePartType<UI_MESSAGE>;
+}>;
+declare function includeTools<UI_MESSAGE extends UIMessage, TOOL_NAME extends InferToolName<UI_MESSAGE>>(toolNames: TOOL_NAME | Array<TOOL_NAME>): FilterGuard<UI_MESSAGE, InferUIMessageChunk<UI_MESSAGE>, {
+  type: ExcludeToolPartTypes<UI_MESSAGE> | `tool-${TOOL_NAME}`;
+}>;
+/**
+ * Creates a filter guard that excludes all or only specific tools while keeping non-tool chunks.
+ * Use with `.filter()` to exclude specific tools or all tools.
+ *
+ * @example
+ * ```typescript
+ * // Exclude all tools
+ * pipe<MyUIMessage>(stream)
+ *   .filter(excludeTools())
+ *   .map(({ chunk }) => chunk); // no tool chunks
+ *
+ * // Exclude specific tool
+ * pipe<MyUIMessage>(stream)
+ *   .filter(excludeTools('weather'))
+ *   .map(({ chunk }) => chunk); // excludes tool-weather chunks
+ *
+ * // Exclude multiple tools
+ * pipe<MyUIMessage>(stream)
+ *   .filter(excludeTools(['weather', 'calculator']))
+ *   .map(({ chunk }) => chunk); // excludes weather and calculator
+ * ```
+ */
+declare function excludeTools<UI_MESSAGE extends UIMessage>(): FilterGuard<UI_MESSAGE, ExtractChunk<UI_MESSAGE, ExcludeToolChunkTypes<UI_MESSAGE>>, {
+  type: ExcludeToolPartTypes<UI_MESSAGE>;
+}>;
+declare function excludeTools<UI_MESSAGE extends UIMessage, TOOL_NAME extends InferToolName<UI_MESSAGE>>(toolNames: TOOL_NAME | Array<TOOL_NAME>): FilterGuard<UI_MESSAGE, InferUIMessageChunk<UI_MESSAGE>, {
+  type: Exclude<InferUIMessagePartType<UI_MESSAGE>, `tool-${TOOL_NAME}`>;
+}>;
+/**
+ * Creates an observe guard that matches tool call chunks by tool name and/or state.
+ * Use with `.on()` to observe tool call state transitions without filtering.
+ *
+ * @example
+ * ```typescript
+ * // Match all tool state transitions (any tool, any state)
+ * pipe<MyUIMessage>(stream)
+ *   .on(toolCall(), ({ chunk, part }) => {
+ *     // Observes: tool-input-available, tool-approval-request,
+ *     // tool-output-available, tool-output-error, tool-output-denied
+ *   });
+ *
+ * // Match specific tool (any state)
+ * pipe<MyUIMessage>(stream)
+ *   .on(toolCall({ tool: "weather" }), ({ chunk, part }) => {
+ *     // part.type is 'tool-weather'
+ *   });
+ *
+ * // Match specific state (all tools)
+ * pipe<MyUIMessage>(stream)
+ *   .on(toolCall({ state: "output-available" }), ({ chunk, part }) => {
+ *     // chunk.type is 'tool-output-available'
+ *   });
+ *
+ * // Match specific tool AND state
+ * pipe<MyUIMessage>(stream)
+ *   .on(toolCall({ tool: "weather", state: "output-available" }), ({ chunk, part }) => {
+ *     // chunk.type is 'tool-output-available', part.type is 'tool-weather'
+ *   });
+ * ```
+ */
+declare function toolCall<UI_MESSAGE extends UIMessage>(): ObserveGuard<UI_MESSAGE, ExtractChunk<UI_MESSAGE, ToolStateToChunkType[ToolCallState]>, {
+  type: `tool-${InferToolName<UI_MESSAGE>}` | "dynamic-tool";
+}>;
+declare function toolCall<UI_MESSAGE extends UIMessage, TOOL_NAME extends InferToolName<UI_MESSAGE>, STATE extends ToolCallState>(options: {
+  tool: TOOL_NAME;
+  state: STATE;
+}): ObserveGuard<UI_MESSAGE, ExtractChunk<UI_MESSAGE, ToolStateToChunkType[STATE]>, {
+  type: `tool-${TOOL_NAME}`;
+}>;
+declare function toolCall<UI_MESSAGE extends UIMessage, TOOL_NAME extends InferToolName<UI_MESSAGE>>(options: {
+  tool: TOOL_NAME;
+  state?: undefined;
+}): ObserveGuard<UI_MESSAGE, ExtractChunk<UI_MESSAGE, ToolStateToChunkType[ToolCallState]>, {
+  type: `tool-${TOOL_NAME}`;
+}>;
+declare function toolCall<UI_MESSAGE extends UIMessage, STATE extends ToolCallState>(options: {
+  tool?: undefined;
+  state: STATE;
+}): ObserveGuard<UI_MESSAGE, ExtractChunk<UI_MESSAGE, ToolStateToChunkType[STATE]>, {
+  type: `tool-${InferToolName<UI_MESSAGE>}` | "dynamic-tool";
+}>;
 //#endregion
-export { AsyncIterableStream, type FlatMapContext, type FlatMapInput, type FlatMapUIMessageStreamFn, type FlatMapUIMessageStreamPredicate, type MapInput, type MapUIMessageStreamFn, chunkType, consumeUIMessageStream, convertArrayToAsyncIterable, convertArrayToStream, convertAsyncIterableToArray, convertAsyncIterableToStream, convertSSEToUIMessageStream, convertStreamToArray, convertUIMessageToSSEStream, createAsyncIterableStream, excludeChunks, excludeParts, filterUIMessageStream, flatMapUIMessageStream, includeChunks, includeParts, mapUIMessageStream, partType, partTypeIs, pipe };
+export { AsyncIterableStream, type FlatMapContext, type FlatMapInput, type FlatMapUIMessageStreamFn, type FlatMapUIMessageStreamPredicate, type MapInput, type MapUIMessageStreamFn, chunkType, consumeUIMessageStream, convertArrayToAsyncIterable, convertArrayToStream, convertAsyncIterableToArray, convertAsyncIterableToStream, convertSSEToUIMessageStream, convertStreamToArray, convertUIMessageToSSEStream, createAsyncIterableStream, excludeChunks, excludeParts, excludeTools, filterUIMessageStream, flatMapUIMessageStream, includeChunks, includeParts, includeTools, mapUIMessageStream, partType, partTypeIs, pipe, toolCall };

package/dist/index.mjs

@@ -908,6 +908,64 @@ function partType(types) {
 	const guard = (input) => typeArray.includes(input.part?.type);
 	return guard;
 }
+function includeTools(toolNames) {
+	const toolNameArray = toolNames === void 0 ? void 0 : Array.isArray(toolNames) ? toolNames : [toolNames];
+	const guard = (input) => {
+		/** No args = no-op, all chunks pass */
+		if (toolNameArray === void 0) return true;
+		const partType = input.part?.type;
+		if (!partType) return true;
+		/** Non-tool chunks pass */
+		if (!partType.startsWith(`tool-`) && partType !== `dynamic-tool`) return true;
+		/** Only matching tool chunks pass */
+		for (const name of toolNameArray) if (partType === `tool-${name}`) return true;
+		return false;
+	};
+	return guard;
+}
+function excludeTools(toolNames) {
+	const toolNameArray = toolNames === void 0 ? void 0 : Array.isArray(toolNames) ? toolNames : [toolNames];
+	const guard = (input) => {
+		const partType = input.part?.type;
+		/** Meta chunks pass (no part type) */
+		if (!partType) return true;
+		/** No args = exclude all tool chunks */
+		if (toolNameArray === void 0) return !partType.startsWith(`tool-`) && partType !== `dynamic-tool`;
+		/** Exclude only matching tool chunks */
+		for (const name of toolNameArray) if (partType === `tool-${name}`) return false;
+		return true;
+	};
+	return guard;
+}
+/**
+* Reverse mapping from chunk type to state.
+*/
+const chunkTypeToState = Object.fromEntries(Object.entries({
+	"input-available": "tool-input-available",
+	"approval-requested": "tool-approval-request",
+	"output-available": "tool-output-available",
+	"output-error": "tool-output-error",
+	"output-denied": "tool-output-denied"
+}).map(([state, chunkType]) => [chunkType, state]));
+function toolCall(options) {
+	const toolName = options?.tool;
+	const state = options?.state;
+	const guard = (input) => {
+		const chunkType = input.chunk.type;
+		const partType = input.part?.type;
+		/** Must be a tool chunk type that maps to a state */
+		const matchingState = chunkTypeToState[chunkType];
+		if (!matchingState) return false;
+		/** Check state match */
+		if (state && matchingState !== state) return false;
+		/** Check tool name match */
+		if (toolName && partType) {
+			if (partType !== `tool-${toolName}`) return false;
+		}
+		return true;
+	};
+	return guard;
+}
 
 //#endregion
-export { chunkType, consumeUIMessageStream, convertArrayToAsyncIterable, convertArrayToStream, convertAsyncIterableToArray, convertAsyncIterableToStream, convertSSEToUIMessageStream, convertStreamToArray, convertUIMessageToSSEStream, createAsyncIterableStream, excludeChunks, excludeParts, filterUIMessageStream, flatMapUIMessageStream, includeChunks, includeParts, mapUIMessageStream, partType, partTypeIs, pipe };
+export { chunkType, consumeUIMessageStream, convertArrayToAsyncIterable, convertArrayToStream, convertAsyncIterableToArray, convertAsyncIterableToStream, convertSSEToUIMessageStream, convertStreamToArray, convertUIMessageToSSEStream, createAsyncIterableStream, excludeChunks, excludeParts, excludeTools, filterUIMessageStream, flatMapUIMessageStream, includeChunks, includeParts, includeTools, mapUIMessageStream, partType, partTypeIs, pipe, toolCall };

package/dist/{types-B4nePmEd.d.mts → types-CNApJ39t.d.mts}

@@ -1,4 +1,4 @@
-import { AsyncIterableStream, AsyncIterableStream as AsyncIterableStream$1, UIMessageChunk } from "ai";
+import { AsyncIterableStream, AsyncIterableStream as AsyncIterableStream$1, InferUIMessageChunk, UIMessage, UIMessageChunk } from "ai";
 
 //#region src/utils/convert-array-to-async-iterable.d.ts
 /**
@@ -29,7 +29,7 @@ declare function convertAsyncIterableToStream<T>(iterable: AsyncIterable<T>): Re
 /**
  * Converts an SSE stream to a UI message stream.
  */
-declare function convertSSEToUIMessageStream(stream: ReadableStream<string>): ReadableStream<UIMessageChunk>;
+declare function convertSSEToUIMessageStream<UI_MESSAGE extends UIMessage = UIMessage>(stream: ReadableStream<string>): ReadableStream<InferUIMessageChunk<UI_MESSAGE>>;
 //#endregion
 //#region src/utils/convert-stream-to-array.d.ts
 /**

package/dist/utils/index.d.mts

@@ -1,2 +1,2 @@
-import { a as convertSSEToUIMessageStream, c as convertArrayToStream, i as convertStreamToArray, l as convertArrayToAsyncIterable, n as createAsyncIterableStream, o as convertAsyncIterableToStream, r as convertUIMessageToSSEStream, s as convertAsyncIterableToArray, t as AsyncIterableStream } from "../types-B4nePmEd.mjs";
+import { a as convertSSEToUIMessageStream, c as convertArrayToStream, i as convertStreamToArray, l as convertArrayToAsyncIterable, n as createAsyncIterableStream, o as convertAsyncIterableToStream, r as convertUIMessageToSSEStream, s as convertAsyncIterableToArray, t as AsyncIterableStream } from "../types-CNApJ39t.mjs";
 export { type AsyncIterableStream, convertArrayToAsyncIterable, convertArrayToStream, convertAsyncIterableToArray, convertAsyncIterableToStream, convertSSEToUIMessageStream, convertStreamToArray, convertUIMessageToSSEStream, createAsyncIterableStream };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-stream-utils",
-  "version": "2.0.1",
+  "version": "2.2.0",
   "description": "AI SDK: Filter and transform UI messages while streaming to the client",
   "keywords": [
     "ai",
@@ -41,6 +41,7 @@
     "@ai-sdk/openai": "^3.0.29",
     "@ai-sdk/provider": "^3.0.8",
     "@ai-sdk/provider-utils": "^4.0.15",
+    "@ai-sdk/react": "^3.0.110",
     "@arethetypeswrong/cli": "^0.18.2",
     "@total-typescript/tsconfig": "^1.0.4",
     "@types/node": "^25.2.3",