ai-stream-utils 1.5.0 → 2.0.0

package/dist/index.mjs

@@ -1,172 +1,88 @@
-import { t as createAsyncIterableStream } from "./create-async-iterable-stream-x_DKVIDi.mjs";
-import { getToolOrDynamicToolName, isDataUIPart, isFileUIPart, isReasoningUIPart, isTextUIPart, isToolOrDynamicToolUIPart, readUIMessageStream } from "ai";
+import { a as convertArrayToStream, c as convertAsyncIterableToStream, i as convertAsyncIterableToArray, n as convertStreamToArray, o as convertArrayToAsyncIterable, r as convertSSEToUIMessageStream, s as createAsyncIterableStream, t as convertUIMessageToSSEStream } from "./convert-ui-message-stream-to-sse-stream-CcQRXKju.mjs";
+import "./utils/index.mjs";
+import { createIdGenerator, getToolOrDynamicToolName, isDataUIPart, isFileUIPart, isReasoningUIPart, isTextUIPart, isToolOrDynamicToolUIPart, readUIMessageStream } from "ai";
 
-//#region node_modules/.pnpm/@ai-sdk+provider@3.0.4/node_modules/@ai-sdk/provider/dist/index.mjs
-var marker$1 = "vercel.ai.error";
-var symbol$1 = Symbol.for(marker$1);
-var _a, _b;
-var AISDKError = class _AISDKError extends (_b = Error, _a = symbol$1, _b) {
-	/**
-	* Creates an AI SDK Error.
-	*
-	* @param {Object} params - The parameters for creating the error.
-	* @param {string} params.name - The name of the error.
-	* @param {string} params.message - The error message.
-	* @param {unknown} [params.cause] - The underlying cause of the error.
-	*/
-	constructor({ name: name14, message, cause }) {
-		super(message);
-		this[_a] = true;
-		this.name = name14;
-		this.cause = cause;
-	}
-	/**
-	* Checks if the given error is an AI SDK Error.
-	* @param {unknown} error - The error to check.
-	* @returns {boolean} True if the error is an AI SDK Error, false otherwise.
-	*/
-	static isInstance(error) {
-		return _AISDKError.hasMarker(error, marker$1);
-	}
-	static hasMarker(error, marker15) {
-		const markerSymbol = Symbol.for(marker15);
-		return error != null && typeof error === "object" && markerSymbol in error && typeof error[markerSymbol] === "boolean" && error[markerSymbol] === true;
-	}
-};
-var name$1 = "AI_APICallError";
-var marker2 = `vercel.ai.error.${name$1}`;
-var symbol2 = Symbol.for(marker2);
-var name2 = "AI_EmptyResponseBodyError";
-var marker3 = `vercel.ai.error.${name2}`;
-var symbol3 = Symbol.for(marker3);
-var name3 = "AI_InvalidArgumentError";
-var marker4 = `vercel.ai.error.${name3}`;
-var symbol4 = Symbol.for(marker4);
-var _a4, _b4;
-var InvalidArgumentError = class extends (_b4 = AISDKError, _a4 = symbol4, _b4) {
-	constructor({ message, cause, argument }) {
-		super({
-			name: name3,
-			message,
-			cause
-		});
-		this[_a4] = true;
-		this.argument = argument;
-	}
-	static isInstance(error) {
-		return AISDKError.hasMarker(error, marker4);
-	}
-};
-var name4 = "AI_InvalidPromptError";
-var marker5 = `vercel.ai.error.${name4}`;
-var symbol5 = Symbol.for(marker5);
-var name5 = "AI_InvalidResponseDataError";
-var marker6 = `vercel.ai.error.${name5}`;
-var symbol6 = Symbol.for(marker6);
-var name6 = "AI_JSONParseError";
-var marker7 = `vercel.ai.error.${name6}`;
-var symbol7 = Symbol.for(marker7);
-var name7 = "AI_LoadAPIKeyError";
-var marker8 = `vercel.ai.error.${name7}`;
-var symbol8 = Symbol.for(marker8);
-var name8 = "AI_LoadSettingError";
-var marker9 = `vercel.ai.error.${name8}`;
-var symbol9 = Symbol.for(marker9);
-var name9 = "AI_NoContentGeneratedError";
-var marker10 = `vercel.ai.error.${name9}`;
-var symbol10 = Symbol.for(marker10);
-var name10 = "AI_NoSuchModelError";
-var marker11 = `vercel.ai.error.${name10}`;
-var symbol11 = Symbol.for(marker11);
-var name11 = "AI_TooManyEmbeddingValuesForCallError";
-var marker12 = `vercel.ai.error.${name11}`;
-var symbol12 = Symbol.for(marker12);
-var name12 = "AI_TypeValidationError";
-var marker13 = `vercel.ai.error.${name12}`;
-var symbol13 = Symbol.for(marker13);
-var name13 = "AI_UnsupportedFunctionalityError";
-var marker14 = `vercel.ai.error.${name13}`;
-var symbol14 = Symbol.for(marker14);
-
-//#endregion
-//#region node_modules/.pnpm/@ai-sdk+provider-utils@4.0.8_zod@4.3.5/node_modules/@ai-sdk/provider-utils/dist/index.mjs
-function convertAsyncIteratorToReadableStream(iterator) {
-	let cancelled = false;
-	return new ReadableStream({
-		async pull(controller) {
-			if (cancelled) return;
-			try {
-				const { value, done } = await iterator.next();
-				if (done) controller.close();
-				else controller.enqueue(value);
-			} catch (error) {
-				controller.error(error);
-			}
-		},
-		async cancel(reason) {
-			cancelled = true;
-			if (iterator.return) try {
-				await iterator.return(reason);
-			} catch (e) {}
-		}
-	});
+//#region src/consume/consume-ui-message-stream.ts
+/**
+* Consumes a UIMessageStream by fully reading it and returning the final UI message.
+*
+* This function uses `readUIMessageStream` to process all chunks from the stream
+* and returns the last assembled message, which contains the complete content
+* with all parts fully resolved.
+*
+* @example
+* ```typescript
+* const message = await consumeUIMessageStream(stream);
+* console.log(message.parts); // All parts fully assembled
+* ```
+*
+* @example
+* ```typescript
+* const stream = result.toUIMessageStream();
+* const filteredStream = filterUIMessageStream(stream, includeParts(['text']));
+* const message = await consumeUIMessageStream(filteredStream);
+* ```
+*/
+async function consumeUIMessageStream(stream) {
+	let lastMessage;
+	for await (const message of readUIMessageStream({ stream })) lastMessage = message;
+	if (!lastMessage) throw new Error("Unexpected: stream ended without producing any messages");
+	return lastMessage;
 }
-var { btoa, atob } = globalThis;
-var name = "AI_DownloadError";
-var marker = `vercel.ai.error.${name}`;
-var symbol = Symbol.for(marker);
-var createIdGenerator = ({ prefix, size = 16, alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", separator = "-" } = {}) => {
-	const generator = () => {
-		const alphabetLength = alphabet.length;
-		const chars = new Array(size);
-		for (let i = 0; i < size; i++) chars[i] = alphabet[Math.random() * alphabetLength | 0];
-		return chars.join("");
-	};
-	if (prefix == null) return generator;
-	if (alphabet.includes(separator)) throw new InvalidArgumentError({
-		argument: "separator",
-		message: `The separator "${separator}" must not be part of the alphabet "${alphabet}".`
-	});
-	return () => `${prefix}${separator}${generator()}`;
-};
-var generateId = createIdGenerator();
-var schemaSymbol = Symbol.for("vercel.ai.schema");
 
 //#endregion
-//#region src/utils/internal/stream-utils.ts
+//#region src/internal/get-part-type-from-chunk.ts
 /**
-* Maps a chunk to its corresponding UI message part type.
-* For tool-related chunks, returns 'tool-{toolName}' or 'dynamic-tool'.
+* Derives the part type directly from a chunk's type.
+* This avoids relying on `message.parts[-1]` which can be incorrect
+* when chunks from different part types are interleaved.
+*
+* @param chunk - The chunk to derive part type from
+* @param toolCallIdMap - Map to track toolCallId → partType for tool chunks
+* @returns The part type string, or undefined for meta chunks
 */
-function getPartTypeFromChunk(chunk, toolCallStates) {
-	switch (chunk.type) {
-		case `tool-input-start`:
-		case `tool-input-available`:
-		case `tool-input-error`: {
-			const toolChunk = chunk;
-			return toolChunk.dynamic ? `dynamic-tool` : `tool-${toolChunk.toolName}`;
-		}
-		case `tool-input-delta`:
-		case `tool-output-available`:
-		case `tool-output-error`: {
-			const toolChunk = chunk;
-			if (toolChunk.dynamic) return `dynamic-tool`;
-			const toolState = toolCallStates?.get(toolChunk.toolCallId);
-			if (toolState) return toolState.dynamic ? `dynamic-tool` : `tool-${toolState.toolName}`;
-			return `dynamic-tool`;
-		}
+function getPartTypeFromChunk(chunk, toolCallIdMap) {
+	const chunkType = chunk.type;
+	switch (chunkType) {
 		case `text-start`:
 		case `text-delta`:
 		case `text-end`: return `text`;
 		case `reasoning-start`:
 		case `reasoning-delta`:
 		case `reasoning-end`: return `reasoning`;
-		case `file`: return `file`;
+		case `tool-input-start`: {
+			const c = chunk;
+			const partType = c.dynamic ? `dynamic-tool` : `tool-${c.toolName}`;
+			toolCallIdMap.set(c.toolCallId, partType);
+			return partType;
+		}
+		case `tool-input-delta`:
+		case `tool-input-available`:
+		case `tool-input-error`:
+		case `tool-output-available`:
+		case `tool-output-error`:
+		case `tool-output-denied`:
+		case `tool-approval-request`: {
+			const c = chunk;
+			return toolCallIdMap.get(c.toolCallId);
+		}
 		case `source-url`: return `source-url`;
 		case `source-document`: return `source-document`;
-		default: return chunk.type;
+		case `file`: return `file`;
+		case `start`:
+		case `finish`:
+		case `start-step`:
+		case `finish-step`:
+		case `error`:
+		case `abort`:
+		case `message-metadata`: return;
+		default: if (chunkType.startsWith(`data-`)) return chunkType;
 	}
+	throw new Error(`Unable to derive part type from chunk type: ${chunkType}`);
 }
+
+//#endregion
+//#region src/internal/utils.ts
 /**
 * Checks if a chunk is a control/meta chunk that should always pass through.
 */
@@ -201,7 +117,7 @@ function asArray(value) {
 }
 
 //#endregion
-//#region src/utils/internal/create-ui-message-stream-reader.ts
+//#region src/internal/create-ui-message-stream-reader.ts
 /**
 * Creates an async generator that wraps a UIMessageStream with readUIMessageStream.
 *
@@ -226,7 +142,7 @@ async function* createUIMessageStreamReader(inputStream) {
 	const iterator = readUIMessageStream({ stream: new ReadableStream({ start(c) {
 		controller = c;
 	} }) })[Symbol.asyncIterator]();
-	const toolCallStates = /* @__PURE__ */ new Map();
+	const toolCallIdMap = /* @__PURE__ */ new Map();
 	try {
 		while (true) {
 			const { done, value: chunk } = await inputReader.read();
@@ -234,13 +150,6 @@ async function* createUIMessageStreamReader(inputStream) {
 				controller.close();
 				break;
 			}
-			if (chunk.type === `tool-input-start`) {
-				const toolChunk = chunk;
-				toolCallStates.set(toolChunk.toolCallId, {
-					toolName: toolChunk.toolName,
-					dynamic: toolChunk.dynamic
-				});
-			}
 			if (isMetaChunk(chunk) || isStepStartChunk(chunk) || isStepEndChunk(chunk)) {
 				controller.enqueue(chunk);
 				yield {
@@ -262,7 +171,7 @@ async function* createUIMessageStreamReader(inputStream) {
 			const result = await iterator.next();
 			const message = result.done ? void 0 : result.value;
 			const messagePart = message?.parts[message.parts.length - 1];
-			const expectedPartType = getPartTypeFromChunk(chunk, toolCallStates);
+			const expectedPartType = getPartTypeFromChunk(chunk, toolCallIdMap);
 			yield {
 				chunk,
 				message,
@@ -279,7 +188,7 @@ async function* createUIMessageStreamReader(inputStream) {
 }
 
 //#endregion
-//#region src/map-ui-message-stream.ts
+//#region src/map/map-ui-message-stream.ts
 /**
 * Maps/filters a UIMessageStream at the chunk level using readUIMessageStream.
 *
@@ -393,39 +302,11 @@ function mapUIMessageStream(stream, mapFn) {
 			if (chunks.length > 0) yield* emitChunks(chunks);
 		}
 	}
-	return createAsyncIterableStream(convertAsyncIteratorToReadableStream(processChunks()));
+	return createAsyncIterableStream(convertAsyncIterableToStream(processChunks()));
 }
 
 //#endregion
-//#region src/filter-ui-message-stream.ts
-/**
-* Creates a filter predicate that includes only the specified part types.
-*
-* @example
-* ```typescript
-* filterUIMessageStream(stream, includeParts(['text', 'tool-weather']));
-* ```
-*/
-function includeParts(includePartTypes) {
-	return ({ part }) => {
-		const partType = part.type;
-		return includePartTypes.includes(partType);
-	};
-}
-/**
-* Creates a filter predicate that excludes the specified part types.
-*
-* @example
-* ```typescript
-* filterUIMessageStream(stream, excludeParts(['reasoning', 'tool-calculator']));
-* ```
-*/
-function excludeParts(excludePartTypes) {
-	return ({ part }) => {
-		const partType = part.type;
-		return !excludePartTypes.includes(partType);
-	};
-}
+//#region src/filter/filter-ui-message-stream.ts
 /**
 * Filters a UIMessageStream to include or exclude specific chunks.
 *
@@ -468,7 +349,11 @@ function filterUIMessageStream(stream, predicate) {
 }
 
 //#endregion
-//#region src/utils/internal/serialize-part-to-chunks.ts
+//#region src/internal/serialize-part-to-chunks.ts
+const generateId = createIdGenerator({
+	prefix: `aitxt`,
+	size: 24
+});
 /**
 * Type guard to check if a message part is a source-url part.
 */
@@ -488,27 +373,16 @@ function isStepStartUIPart(part) {
 	return part.type === "step-start";
 }
 /**
-* Extracts the part ID from a list of chunks belonging to the same part.
-*/
-function getPartId(chunks) {
-	for (const chunk of chunks) {
-		if ("id" in chunk && chunk.id) return chunk.id;
-		if ("toolCallId" in chunk && chunk.toolCallId) return chunk.toolCallId;
-	}
-	return "unknown";
-}
-/**
 * Serializes a UIMessagePart back to chunks (without step boundaries).
 *
 * This function converts a complete part (e.g., TextUIPart, ToolUIPart)
 * back into the chunk format used by UIMessageStream.
 *
 * @param part - The part to serialize
-* @param originalChunks - Original chunks for extracting IDs (for text/reasoning parts)
 * @returns Array of chunks representing the part
 */
-function serializePartToChunks(part, originalChunks) {
-	if (isStepStartUIPart(part)) return originalChunks;
+function serializePartToChunks(part) {
+	if (isStepStartUIPart(part)) return [{ type: "start-step" }];
 	if (isFileUIPart(part)) return [{
 		type: "file",
 		mediaType: part.mediaType,
@@ -534,41 +408,46 @@ function serializePartToChunks(part, originalChunks) {
 		type: part.type,
 		data: part.data
 	}];
-	const id = getPartId(originalChunks);
-	if (isTextUIPart(part)) return [
-		{
-			type: "text-start",
-			id,
-			providerMetadata: part.providerMetadata
-		},
-		{
-			type: "text-delta",
-			id,
-			delta: part.text
-		},
-		{
-			type: "text-end",
-			id,
-			providerMetadata: part.providerMetadata
-		}
-	];
-	if (isReasoningUIPart(part)) return [
-		{
-			type: "reasoning-start",
-			id,
-			providerMetadata: part.providerMetadata
-		},
-		{
-			type: "reasoning-delta",
-			id,
-			delta: part.text
-		},
-		{
-			type: "reasoning-end",
-			id,
-			providerMetadata: part.providerMetadata
-		}
-	];
+	if (isTextUIPart(part)) {
+		const id = generateId();
+		return [
+			{
+				type: "text-start",
+				id,
+				providerMetadata: part.providerMetadata
+			},
+			{
+				type: "text-delta",
+				id,
+				delta: part.text
+			},
+			{
+				type: "text-end",
+				id,
+				providerMetadata: part.providerMetadata
+			}
+		];
+	}
+	if (isReasoningUIPart(part)) {
+		const id = generateId();
+		return [
+			{
+				type: "reasoning-start",
+				id,
+				providerMetadata: part.providerMetadata
+			},
+			{
+				type: "reasoning-delta",
+				id,
+				delta: part.text
+			},
+			{
+				type: "reasoning-end",
+				id,
+				providerMetadata: part.providerMetadata
+			}
+		];
+	}
 	if (isToolOrDynamicToolUIPart(part)) {
 		const dynamic = part.type === "dynamic-tool";
 		const chunks = [{
@@ -604,11 +483,11 @@ function serializePartToChunks(part, originalChunks) {
 		});
 		return chunks;
 	}
-	return originalChunks;
+	throw new Error(`Cannot serialize unknown part type: ${part.type}`);
 }
 
 //#endregion
-//#region src/flat-map-ui-message-stream.ts
+//#region src/flat-map/flat-map-ui-message-stream.ts
 /**
 * Creates a predicate that matches parts by their type.
 */
@@ -663,7 +542,7 @@ function flatMapUIMessageStream(...args) {
 			index: allParts.length - 1,
 			parts: allParts
 		}));
-		for (const part of parts) yield* emitChunks(serializePartToChunks(part, bufferedChunks));
+		for (const part of parts) yield* emitChunks(serializePartToChunks(part));
 		bufferedChunks = [];
 		lastBufferedPart = void 0;
 	}
@@ -681,7 +560,7 @@ function flatMapUIMessageStream(...args) {
 				continue;
 			}
 			if (isStepEndChunk(chunk)) {
-				if (currentMode === "buffering" && lastBufferedPart) yield* flushBufferedPart(lastBufferedPart);
+				if (currentMode === `buffering` && lastBufferedPart) yield* flushBufferedPart(lastBufferedPart);
 				if (stepStartEmitted) {
 					yield chunk;
 					stepStartEmitted = false;
@@ -697,35 +576,338 @@ function flatMapUIMessageStream(...args) {
 					index: allParts.length - 1,
 					parts: allParts
 				}));
-				for (const part$1 of parts) yield* emitChunks([part$1]);
+				for (const part of parts) yield* emitChunks([part]);
 				continue;
 			}
-			if (!message) throw new Error("Unexpected: received content chunk but message is undefined");
+			if (!message) throw new Error(`Unexpected: received content chunk but message is undefined`);
 			const currentPart = part;
 			if (!currentPart) throw new Error(`Unexpected: received content chunk but part is undefined`);
 			if (message.parts.length > lastPartCount) {
-				if (currentMode === "buffering" && lastBufferedPart) yield* flushBufferedPart(lastBufferedPart);
-				if (currentMode === "streaming" && lastPartCount > 0) {
+				if (currentMode === `buffering` && lastBufferedPart) yield* flushBufferedPart(lastBufferedPart);
+				if (currentMode === `streaming` && lastPartCount > 0) {
 					const previousPart = message.parts[lastPartCount - 1];
 					if (previousPart) allParts.push(previousPart);
 				}
 				if (!predicate || predicate(currentPart)) {
-					currentMode = "buffering";
+					currentMode = `buffering`;
 					bufferedChunks = [chunk];
 					lastBufferedPart = currentPart;
 				} else {
-					currentMode = "streaming";
+					currentMode = `streaming`;
 					yield* emitChunks([chunk]);
 				}
 				lastPartCount = message.parts.length;
-			} else if (currentMode === "buffering") {
+			} else if (currentMode === `buffering`) {
 				bufferedChunks.push(chunk);
 				lastBufferedPart = currentPart;
-			} else if (currentMode === "streaming") yield* emitChunks([chunk]);
+			} else if (currentMode === `streaming`) yield* emitChunks([chunk]);
+		}
+	}
+	return createAsyncIterableStream(convertAsyncIterableToStream(processChunks()));
+}
+
+//#endregion
+//#region src/pipe/chunk-pipeline.ts
+/**
+* Pipeline for chunk-based operations.
+* Operations receive individual chunks with their associated part type.
+*/
+var ChunkPipeline = class ChunkPipeline {
+	consumed = false;
+	sourceIterable;
+	prevBuilder;
+	constructor(sourceIterable, prevBuilder = (s) => s) {
+		this.sourceIterable = sourceIterable;
+		this.prevBuilder = prevBuilder;
+	}
+	assertNotConsumed() {
+		if (this.consumed) throw new Error(`Pipeline has already been consumed.`);
+	}
+	filter(predicate) {
+		/**
+		* The predicate is cast to a simple function type for runtime execution.
+		*/
+		const predicateFn = predicate;
+		const nextBuilder = (iterable) => {
+			const prevIterable = this.prevBuilder(iterable);
+			async function* generator() {
+				for await (const item of prevIterable) {
+					/**
+					* Meta chunks always pass through without filtering.
+					*/
+					if (item.partType === void 0) {
+						yield item;
+						continue;
+					}
+					if (predicateFn({
+						chunk: item.chunk,
+						part: { type: item.partType }
+					})) yield item;
+				}
+			}
+			return generator();
+		};
+		return new ChunkPipeline(this.sourceIterable, nextBuilder);
+	}
+	/**
+	* Transforms chunks by applying a mapping function.
+	* The callback only receives content chunks because meta chunks pass through unchanged.
+	* Returning null filters out the chunk, while returning an array yields multiple chunks.
+	*/
+	map(fn) {
+		const nextBuilder = (iterable) => {
+			const prevIterable = this.prevBuilder(iterable);
+			async function* generator() {
+				for await (const item of prevIterable) {
+					/**
+					* Meta chunks always pass through unchanged without transformation.
+					*/
+					if (item.partType === void 0) {
+						yield item;
+						continue;
+					}
+					/**
+					* The asArray utility normalizes the result: null becomes an empty array,
+					* a single chunk becomes an array with one element, and arrays pass through as-is.
+					* An empty array means the chunk is filtered out and not yielded.
+					*/
+					const chunks = asArray(fn({
+						chunk: item.chunk,
+						part: { type: item.partType }
+					}));
+					for (const chunk of chunks) yield {
+						chunk,
+						partType: item.partType
+					};
+				}
+			}
+			return generator();
+		};
+		return new ChunkPipeline(this.sourceIterable, nextBuilder);
+	}
+	on(predicate, callback) {
+		/**
+		* The predicate is cast to a simple function type for runtime execution.
+		*/
+		const predicateFn = predicate;
+		const nextBuilder = (iterable) => {
+			const prevIterable = this.prevBuilder(iterable);
+			async function* generator() {
+				for await (const item of prevIterable) {
+					/**
+					* Build the input object for the predicate and callback.
+					* Content chunks get a part object with the type, while meta chunks get undefined.
+					*/
+					const input = {
+						chunk: item.chunk,
+						part: item.partType !== void 0 ? { type: item.partType } : void 0
+					};
+					if (predicateFn(input)) await callback(input);
+					yield item;
+				}
+			}
+			return generator();
+		};
+		return new ChunkPipeline(this.sourceIterable, nextBuilder);
+	}
+	/**
+	* Executes the pipeline and returns the resulting stream.
+	* All chunks pass through including step boundaries and meta chunks.
+	*/
+	toStream() {
+		this.assertNotConsumed();
+		this.consumed = true;
+		const processedIterable = this.prevBuilder(this.sourceIterable);
+		/**
+		* Unwrap internal chunks by extracting just the chunk property.
+		* This removes the internal partType metadata used for pipeline operations.
+		*/
+		async function* generator() {
+			for await (const item of processedIterable) yield item.chunk;
 		}
+		return createAsyncIterableStream(convertAsyncIterableToStream(generator()));
+	}
+	[Symbol.asyncIterator]() {
+		return this.toStream()[Symbol.asyncIterator]();
 	}
-	return createAsyncIterableStream(convertAsyncIteratorToReadableStream(processChunks()));
+};
+
+//#endregion
+//#region src/pipe/pipe.ts
+/**
+* Creates an iterable with part type information from a raw chunk stream.
+*
+* Part type is derived directly from the chunk's type rather than from message.parts[-1],
+* which ensures correct association when chunks from different part types are interleaved.
+*
+* Step boundaries (start-step/finish-step) pass through as-is with undefined partType.
+* The AI SDK's readUIMessageStream handles all step boundary scenarios gracefully.
+*/
+async function* createIterable(input) {
+	/**
+	* Tracks toolCallId → partType mapping for tool chunks
+	*/
+	const toolCallIdMap = /* @__PURE__ */ new Map();
+	/**
+	* Use Symbol.asyncIterator if available (AsyncIterable), otherwise convert ReadableStream
+	*/
+	const iterable = Symbol.asyncIterator in input ? input : createAsyncIterableStream(input);
+	for await (const chunk of iterable) yield {
+		chunk,
+		partType: getPartTypeFromChunk(chunk, toolCallIdMap)
+	};
+}
+/**
+* Creates a type-safe pipeline for UIMessageStream operations.
+*
+* @example
+* ```typescript
+* pipe<MyUIMessage>(stream)
+*   .filter(isPartType('text'))
+*   .map(({ chunk }) => chunk)
+*   .toStream();
+* ```
+*/
+function pipe(input) {
+	return new ChunkPipeline(createIterable(input));
+}
+
+//#endregion
+//#region src/pipe/type-guards.ts
+/**
+* Creates a filter guard that includes specific content chunk types.
+* Use with `.filter()` to narrow to specific chunks.
+*
+* @example
+* ```typescript
+* pipe<MyUIMessage>(stream)
+*   .filter(includeChunks('text-delta'))
+*   .map(({ chunk }) => chunk); // chunk is narrowed to text-delta chunk
+*
+* pipe<MyUIMessage>(stream)
+*   .filter(includeChunks(['text-delta', 'text-end']))
+*   .map(({ chunk }) => chunk); // chunk is narrowed to text-delta | text-end
+* ```
+*/
+function includeChunks(types) {
+	const typeArray = Array.isArray(types) ? types : [types];
+	const guard = (input) => typeArray.includes(input.chunk.type);
+	return guard;
+}
+/**
+* Creates a filter guard that includes specific part types.
+* Use with `.filter()` to narrow to chunks belonging to specific parts.
+*
+* @example
+* ```typescript
+* pipe<MyUIMessage>(stream)
+*   .filter(includeParts('text'))
+*   .map(({ chunk, part }) => chunk); // chunk is narrowed to text chunks
+*
+* pipe<MyUIMessage>(stream)
+*   .filter(includeParts(['text', 'reasoning']))
+*   .map(({ chunk }) => chunk); // chunk is text or reasoning chunks
+* ```
+*/
+function includeParts(types) {
+	const typeArray = Array.isArray(types) ? types : [types];
+	const guard = (input) => typeArray.includes(input.part?.type);
+	return guard;
+}
+/**
+* Creates a filter guard that excludes specific content chunk types.
+* Use with `.filter()` to keep all chunks except the specified types.
+*
+* @example
+* ```typescript
+* pipe<MyUIMessage>(stream)
+*   .filter(excludeChunks('text-delta'))
+*   .map(({ chunk }) => chunk); // chunk is all content chunks except text-delta
+*
+* pipe<MyUIMessage>(stream)
+*   .filter(excludeChunks(['text-start', 'text-end']))
+*   .map(({ chunk }) => chunk); // excludes text-start and text-end
+* ```
+*/
+function excludeChunks(types) {
+	const typeArray = Array.isArray(types) ? types : [types];
+	const guard = (input) => !typeArray.includes(input.chunk.type);
+	return guard;
+}
+/**
+* Creates a filter guard that excludes specific part types.
+* Use with `.filter()` to keep all chunks except those belonging to specified parts.
+*
+* @example
+* ```typescript
+* pipe<MyUIMessage>(stream)
+*   .filter(excludeParts('text'))
+*   .map(({ chunk }) => chunk); // excludes all text chunks
+*
+* pipe<MyUIMessage>(stream)
+*   .filter(excludeParts(['text', 'reasoning']))
+*   .map(({ chunk }) => chunk); // excludes text and reasoning chunks
+* ```
+*/
+function excludeParts(types) {
+	const typeArray = Array.isArray(types) ? types : [types];
+	const guard = (input) => !typeArray.includes(input.part?.type);
+	return guard;
+}
+/**
+* Creates an observe guard that matches specific chunk types, including meta chunks.
+* Use with `.on()` to observe specific chunks without filtering.
+*
+* @example
+* ```typescript
+* // Observe content chunks
+* pipe<MyUIMessage>(stream)
+*   .on(chunkType('text-delta'), ({ chunk, part }) => {
+*     // chunk is text-delta, part is { type: 'text' }
+*   });
+*
+* // Observe meta chunks
+* pipe<MyUIMessage>(stream)
+*   .on(chunkType('start'), ({ chunk, part }) => {
+*     // chunk is start chunk, part is undefined
+*   });
+*
+* // Observe multiple chunk types
+* pipe<MyUIMessage>(stream)
+*   .on(chunkType(['text-delta', 'start']), ({ chunk, part }) => {
+*     // chunk is text-delta | start, part is { type: 'text' } | undefined
+*   });
+* ```
+*/
+function chunkType(types) {
+	const typeArray = Array.isArray(types) ? types : [types];
+	const guard = (input) => typeArray.includes(input.chunk.type);
+	return guard;
+}
+/**
+* Creates an observe guard that matches specific part types.
+* Use with `.on()` to observe chunks belonging to specific parts without filtering.
+*
+* @example
+* ```typescript
+* // Observe text parts
+* pipe<MyUIMessage>(stream)
+*   .on(partType('text'), ({ chunk, part }) => {
+*     // chunk is text chunk, part is { type: 'text' }
+*   });
+*
+* // Observe multiple part types
+* pipe<MyUIMessage>(stream)
+*   .on(partType(['text', 'reasoning']), ({ chunk, part }) => {
+*     // chunk is text | reasoning chunk, part is { type: 'text' | 'reasoning' }
+*   });
+* ```
+*/
+function partType(types) {
+	const typeArray = Array.isArray(types) ? types : [types];
+	const guard = (input) => typeArray.includes(input.part?.type);
+	return guard;
 }
 
 //#endregion
-export { excludeParts, filterUIMessageStream, flatMapUIMessageStream, includeParts, mapUIMessageStream, partTypeIs };
+export { chunkType, consumeUIMessageStream, convertArrayToAsyncIterable, convertArrayToStream, convertAsyncIterableToArray, convertAsyncIterableToStream, convertSSEToUIMessageStream, convertStreamToArray, convertUIMessageToSSEStream, createAsyncIterableStream, excludeChunks, excludeParts, filterUIMessageStream, flatMapUIMessageStream, includeChunks, includeParts, mapUIMessageStream, partType, partTypeIs, pipe };