@langchain/core 1.1.39 → 1.2.0-dev-1775763803878

package/dist/language_models/event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event.d.ts","names":[],"sources":["../../src/language_models/event.ts"],"mappings":";;;;;;;UAuDiB,iBAAA;EACf,IAAA;EA6FA;EA3FA,EAAA;EA2F4B;;AAqB9B;;EA3GE,KAAA,GAAQ,aAAA;AAAA;;;;;;;AAmIV;;KAxHY,YAAA;;;;UAKK,kBAAA;EACf,IAAA;EAqHoB;EAnHpB,MAAA,EAAQ,YAAA;EA0IoB;EAxI5B,KAAA,GAAQ,aAAA;EAwIoB;EAtI5B,gBAAA,GAAmB,MAAA;AAAA;;;;;AAmJrB;;;;;;;;;AAaA;;;;;UA3IiB,sBAAA;EACf,IAAA;EA+IE;EA7IF,KAAA;EA+IE;EA7IF,OAAA,EAAS,YAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAgCM,sBAAA;EACf,IAAA;;EAEA,KAAA;;EAEA,OAAA,EAAS,mBAAA;AAAA;;;;;;;;;;;;;;;;;;;UAqBM,uBAAA;EACf,IAAA;;EAEA,KAAA;;EAEA,OAAA,EAAS,YAAA;AAAA;;;;;;;;;;;;;;;;;UAmBM,gBAAA;EACf,IAAA;;EAEA,KAAA,EAAO,aAAA;AAAA;;;;;;;;;;;;;;;;;;;;;UAuBQ,aAAA;EACf,IAAA;;EAEA,QAAA;;EAEA,IAAA;;EAEA,OAAA;AAAA;;;;UAMe,gBAAA;EACf,IAAA;;EAEA,OAAA;;EAEA,IAAA;AAAA;;;;;;KAQU,oBAAA,GACR,iBAAA,GACA,kBAAA,GACA,sBAAA,GACA,sBAAA,GACA,uBAAA,GACA,gBAAA,GACA,aAAA,GACA,gBAAA"}

package/dist/language_models/event.js

@@ -0,0 +1,7 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+//#region src/language_models/event.ts
+var event_exports = /* @__PURE__ */ __exportAll({});
+//#endregion
+export { event_exports };
+
+//# sourceMappingURL=event.js.map

package/dist/language_models/event.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event.js","names":[],"sources":["../../src/language_models/event.ts"],"sourcesContent":["/**\n * Chat model streaming event protocol.\n *\n * Defines a content-block-centric event model for streaming chat model responses.\n * Events carry LangChain {@link ContentBlock} types directly as accumulated\n * snapshots.\n *\n * ## Design Principles\n *\n * 1. **Content blocks are the universal carrier.** Events carry {@link ContentBlock}\n *    instances directly — the block's `type` field is the discriminant. New content\n *    block types automatically work without protocol changes.\n *\n * 2. **Lifecycle completeness.** Every streamable entity has explicit start and finish\n *    events. Consumers never need to infer boundaries from absence of events.\n *\n * 3. **Accumulated snapshots.** Each {@link ContentBlockDeltaEvent} carries the\n *    accumulated state of the content block so far. Aggregation logic lives in the\n *    provider adapter, not the consumer. Consumers who need incremental deltas\n *    track previous state and diff.\n *\n * 4. **Interleaving allowed.** Content blocks may interleave (e.g., parallel tool calls).\n *    The only invariant: a block's start precedes its deltas, and its deltas precede\n *    its finish. No ordering constraint between different blocks.\n *\n * 5. **Provider passthrough.** Native provider events that don't map to standard types\n *    are forwarded as {@link ProviderEvent} rather than silently dropped.\n *\n * ## Lifecycle Contract\n *\n * ```\n * MessageStart\n *   -> ContentBlockStart(index=0, ...)\n *   -> ContentBlockStart(index=1, ...)        // can start before 0 finishes\n *   -> ContentBlockDelta(index=0, ...)\n *   -> ContentBlockDelta(index=1, ...)        // interleaved\n *   -> ContentBlockFinish(index=0, ...)       // blocks finish independently\n *   -> ContentBlockDelta(index=1, ...)\n *   -> ContentBlockFinish(index=1, ...)\n *   -> UsageUpdate(...)                       // may appear at any point\n * -> MessageFinish(reason, usage?)\n * ```\n *\n * @module\n */\n\nimport type {\n  ContentBlock,\n  PartialContentBlock,\n} from \"../messages/content/index.js\";\nimport type { UsageMetadata } from \"../messages/metadata.js\";\n\n/**\n * Emitted once at the start of a model response.\n */\nexport interface MessageStartEvent {\n  type: \"message-start\";\n  /** Optional message ID assigned by the provider. */\n  id?: string;\n  /**\n   * Initial usage snapshot, if the provider reports input token counts\n   * before content begins streaming (e.g., Anthropic's `message_start`).\n   */\n  usage?: UsageMetadata;\n}\n\n/**\n * Finish reason for a model response.\n *\n * - `\"stop\"`: Natural end of generation.\n * - `\"length\"`: Hit max token limit.\n * - `\"tool_use\"`: Model is requesting tool execution.\n * - `\"content_filter\"`: Content was filtered by safety systems.\n */\nexport type FinishReason = \"stop\" | \"length\" | \"tool_use\" | \"content_filter\";\n\n/**\n * Emitted once when the model response is complete.\n */\nexport interface MessageFinishEvent {\n  type: \"message-finish\";\n  /** Why the model stopped generating. */\n  reason: FinishReason;\n  /** Final usage snapshot. */\n  usage?: UsageMetadata;\n  /** Provider-specific response metadata (model name, response ID, headers, etc.). */\n  responseMetadata?: Record<string, unknown>;\n}\n\n/**\n * Emitted when a new content block begins streaming.\n *\n * @example\n * ```ts\n * // Text block starting\n * { type: \"content-block-start\", index: 0,\n *   content: { type: \"text\", text: \"\" } }\n *\n * // Tool call starting\n * { type: \"content-block-start\", index: 1,\n *   content: { type: \"tool_call\", id: \"call_1\", name: \"search\", args: \"\" } }\n *\n * // Reasoning starting\n * { type: \"content-block-start\", index: 2,\n *   content: { type: \"reasoning\", reasoning: \"\" } }\n * ```\n */\nexport interface ContentBlockStartEvent {\n  type: \"content-block-start\";\n  /** Positional index of this block within the message. */\n  index: number;\n  /** Initial state of the content block. */\n  content: ContentBlock;\n}\n\n/**\n * Emitted for each incremental update within a content block.\n *\n * Carries the **accumulated state** of the content block so far.\n * The content is deeply partial — not all fields may be populated during\n * streaming (e.g., a tool call may have `name` but `args` is still being\n * streamed as a partial JSON string).\n *\n * Consumers who need incremental deltas (e.g., new tokens only) should\n * track the previous state and diff against the new accumulated state.\n *\n * Aggregation into `AIMessage` is trivial:\n * `message.content[event.index] = event.content`\n *\n * @example\n * ```ts\n * // First text delta — accumulated so far\n * { type: \"content-block-delta\", index: 0,\n *   content: { type: \"text\", text: \"Hello\" } }\n *\n * // Second text delta — accumulated so far\n * { type: \"content-block-delta\", index: 0,\n *   content: { type: \"text\", text: \"Hello world\" } }\n *\n * // Tool call args — accumulated so far\n * { type: \"content-block-delta\", index: 1,\n *   content: { type: \"tool_call\", id: \"call_1\", name: \"search\", args: '{\"q\":\"wea' } }\n * ```\n */\nexport interface ContentBlockDeltaEvent {\n  type: \"content-block-delta\";\n  /** Positional index of the block being updated. */\n  index: number;\n  /** Accumulated state of the content block after this update. Deeply partial. */\n  content: PartialContentBlock;\n}\n\n/**\n * Emitted when a content block is complete.\n *\n * The `content` carries the **finalized** block. For tool calls, this means\n * args have been parsed from a JSON string into an object.\n *\n * @example\n * ```ts\n * // Finalized text block\n * { type: \"content-block-finish\", index: 0,\n *   content: { type: \"text\", text: \"The weather is sunny.\" } }\n *\n * // Finalized tool call (args parsed)\n * { type: \"content-block-finish\", index: 1,\n *   content: { type: \"tool_call\", id: \"call_1\", name: \"search\",\n *              args: { q: \"weather\" } } }\n * ```\n */\nexport interface ContentBlockFinishEvent {\n  type: \"content-block-finish\";\n  /** Positional index of the completed block. */\n  index: number;\n  /** Finalized content block. */\n  content: ContentBlock;\n}\n\n/**\n * Emitted whenever the provider reports updated usage information.\n *\n * May appear at any point during streaming. Each event carries a\n * **running snapshot** of usage (not an additive delta), so consumers\n * can simply take the latest value.\n *\n * @example\n * ```ts\n * // After message_start (Anthropic: input tokens known)\n * { type: \"usage\", usage: { input_tokens: 1234, output_tokens: 0, total_tokens: 1234 } }\n *\n * // After streaming completes\n * { type: \"usage\", usage: { input_tokens: 1234, output_tokens: 567, total_tokens: 1801 } }\n * ```\n */\nexport interface UsageUpdateEvent {\n  type: \"usage\";\n  /** Current usage snapshot. */\n  usage: UsageMetadata;\n}\n\n/**\n * Passthrough for native provider events that don't map to standard types.\n *\n * Provider adapters map recognized events to standard {@link ChatModelStreamEvent}\n * types and forward everything else as `ProviderEvent`. This ensures no information\n * is silently dropped.\n *\n * @example\n * ```ts\n * // OpenAI server-side web search in progress\n * { type: \"provider\", provider: \"openai\",\n *   name: \"response.web_search_call.searching\",\n *   payload: { item_id: \"ws_123\", output_index: 0 } }\n *\n * // Anthropic context management signal\n * { type: \"provider\", provider: \"anthropic\",\n *   name: \"context_management\",\n *   payload: { ... } }\n * ```\n */\nexport interface ProviderEvent {\n  type: \"provider\";\n  /** Provider identifier (e.g., `\"openai\"`, `\"anthropic\"`, `\"google\"`). */\n  provider: string;\n  /** Raw event type name from the provider SDK. */\n  name: string;\n  /** Raw event payload from the provider SDK. */\n  payload: unknown;\n}\n\n/**\n * Emitted on unrecoverable stream errors.\n */\nexport interface StreamErrorEvent {\n  type: \"error\";\n  /** Human-readable error message. */\n  message: string;\n  /** Optional error code for programmatic handling. */\n  code?: string;\n}\n\n/**\n * Union of all chat model stream event types.\n *\n * This is the type yielded by `ChatModelStream[Symbol.asyncIterator]()`.\n */\nexport type ChatModelStreamEvent =\n  | MessageStartEvent\n  | MessageFinishEvent\n  | ContentBlockStartEvent\n  | ContentBlockDeltaEvent\n  | ContentBlockFinishEvent\n  | UsageUpdateEvent\n  | ProviderEvent\n  | StreamErrorEvent;\n"],"mappings":""}

package/dist/language_models/stream.cjs

@@ -0,0 +1,376 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_ai = require("../messages/ai.cjs");
+//#region src/language_models/stream.ts
+/**
+* Typed stream classes for chat model streaming.
+*
+* Provides {@link ChatModelStream} and typed sub-stream accessors that
+* implement both `AsyncIterable` (for incremental consumption) and
+* `PromiseLike` (for simple `await`).
+*
+* @module
+*/
+var stream_exports = /* @__PURE__ */ require_runtime.__exportAll({
+	ChatModelStream: () => ChatModelStream,
+	ReasoningContentStream: () => ReasoningContentStream,
+	TextContentStream: () => TextContentStream,
+	ToolCallsStream: () => ToolCallsStream,
+	UsageMetadataStream: () => UsageMetadataStream
+});
+/**
+* A buffer that caches emitted events for replay.
+*
+* Multiple consumers can independently iterate the same buffer —
+* each gets its own cursor. Events are never consumed or removed.
+*
+* @internal
+*/
+var ReplayBuffer = class {
+	events = [];
+	finished = false;
+	waiters = [];
+	error = null;
+	push(event) {
+		this.events.push(event);
+		const toWake = this.waiters.splice(0);
+		for (const waiter of toWake) waiter();
+	}
+	finish() {
+		this.finished = true;
+		const toWake = this.waiters.splice(0);
+		for (const waiter of toWake) waiter();
+	}
+	setError(err) {
+		this.error = err;
+		this.finished = true;
+		const toWake = this.waiters.splice(0);
+		for (const waiter of toWake) waiter();
+	}
+	/**
+	* Create an async iterator that replays cached events from the
+	* beginning, then follows live events as they arrive.
+	*/
+	async *iterate() {
+		if (this.finished) {
+			if (this.error) throw this.error;
+			yield* this.events;
+			return;
+		}
+		let cursor = 0;
+		while (true) {
+			while (cursor < this.events.length) {
+				yield this.events[cursor];
+				cursor++;
+			}
+			if (this.finished) {
+				if (this.error) throw this.error;
+				return;
+			}
+			await new Promise((resolve) => {
+				if (cursor < this.events.length || this.finished) {
+					resolve();
+					return;
+				}
+				this.waiters.push(resolve);
+			});
+		}
+	}
+};
+/** Extract a string field from a loosely-typed content block. */
+function getStringField(obj, field) {
+	const val = obj[field];
+	return typeof val === "string" ? val : "";
+}
+/** Check if a delta event carries a text content block. */
+function isTextDelta(event) {
+	return event.type === "content-block-delta" && event.content.type === "text";
+}
+/** Check if a delta event carries a reasoning content block. */
+function isReasoningDelta(event) {
+	return event.type === "content-block-delta" && event.content.type === "reasoning";
+}
+/** Check if a finish event carries a tool_call content block. */
+function isToolCallFinish(event) {
+	return event.type === "content-block-finish" && event.content.type === "tool_call";
+}
+/**
+* Typed stream for text content.
+*
+* - **Iterate**: yields incremental text deltas (new tokens only).
+* - **Await**: resolves to the complete concatenated text.
+* - **`.full`**: yields the running accumulated text after each delta.
+*/
+var TextContentStream = class {
+	/** @internal */
+	_buffer;
+	/** @internal */
+	constructor(buffer) {
+		this._buffer = buffer;
+	}
+	/**
+	* Yields the accumulated text so far after each delta.
+	*/
+	get full() {
+		const buffer = this._buffer;
+		return { async *[Symbol.asyncIterator]() {
+			for await (const event of buffer.iterate()) if (isTextDelta(event)) yield getStringField(event.content, "text");
+		} };
+	}
+	/**
+	* Yields incremental text deltas (new tokens only).
+	* Computed by diffing successive accumulated states.
+	*/
+	[Symbol.asyncIterator]() {
+		const buffer = this._buffer;
+		async function* gen() {
+			const prevLen = /* @__PURE__ */ new Map();
+			for await (const event of buffer.iterate()) if (isTextDelta(event)) {
+				const full = getStringField(event.content, "text");
+				const prev = prevLen.get(event.index) ?? 0;
+				if (full.length > prev) {
+					yield full.slice(prev);
+					prevLen.set(event.index, full.length);
+				}
+			}
+		}
+		return gen();
+	}
+	then(onfulfilled, onrejected) {
+		return (async () => {
+			let text = "";
+			for await (const delta of this) text += delta;
+			return text;
+		})().then(onfulfilled, onrejected);
+	}
+};
+/**
+* Typed stream for tool calls.
+*
+* - **Iterate**: yields individual `ToolCall` objects as each completes.
+* - **Await**: resolves to the full array.
+* - **`.full`**: yields the accumulated array after each new tool call.
+*/
+var ToolCallsStream = class {
+	/** @internal */
+	_buffer;
+	/** @internal */
+	constructor(buffer) {
+		this._buffer = buffer;
+	}
+	get full() {
+		const buffer = this._buffer;
+		return { async *[Symbol.asyncIterator]() {
+			const calls = [];
+			for await (const event of buffer.iterate()) if (isToolCallFinish(event)) {
+				calls.push(event.content);
+				yield [...calls];
+			}
+		} };
+	}
+	[Symbol.asyncIterator]() {
+		const buffer = this._buffer;
+		async function* gen() {
+			for await (const event of buffer.iterate()) if (isToolCallFinish(event)) yield event.content;
+		}
+		return gen();
+	}
+	then(onfulfilled, onrejected) {
+		return (async () => {
+			const calls = [];
+			for await (const call of this) calls.push(call);
+			return calls;
+		})().then(onfulfilled, onrejected);
+	}
+};
+/**
+* Typed stream for reasoning content (chain-of-thought).
+* Same interface as {@link TextContentStream} but for reasoning blocks.
+*/
+var ReasoningContentStream = class {
+	/** @internal */
+	_buffer;
+	/** @internal */
+	constructor(buffer) {
+		this._buffer = buffer;
+	}
+	get full() {
+		const buffer = this._buffer;
+		return { async *[Symbol.asyncIterator]() {
+			for await (const event of buffer.iterate()) if (isReasoningDelta(event)) yield getStringField(event.content, "reasoning");
+		} };
+	}
+	[Symbol.asyncIterator]() {
+		const buffer = this._buffer;
+		async function* gen() {
+			const prevLen = /* @__PURE__ */ new Map();
+			for await (const event of buffer.iterate()) if (isReasoningDelta(event)) {
+				const full = getStringField(event.content, "reasoning");
+				const prev = prevLen.get(event.index) ?? 0;
+				if (full.length > prev) {
+					yield full.slice(prev);
+					prevLen.set(event.index, full.length);
+				}
+			}
+		}
+		return gen();
+	}
+	then(onfulfilled, onrejected) {
+		return (async () => {
+			let text = "";
+			for await (const delta of this) text += delta;
+			return text;
+		})().then(onfulfilled, onrejected);
+	}
+};
+/**
+* Typed stream for usage metadata.
+*
+* - **Iterate**: yields usage snapshots as they arrive.
+* - **Await**: resolves to the final usage snapshot.
+*/
+var UsageMetadataStream = class {
+	/** @internal */
+	_buffer;
+	/** @internal */
+	constructor(buffer) {
+		this._buffer = buffer;
+	}
+	[Symbol.asyncIterator]() {
+		const buffer = this._buffer;
+		async function* gen() {
+			for await (const event of buffer.iterate()) if (event.type === "usage") yield event.usage;
+			else if (event.type === "message-start" && event.usage) yield event.usage;
+			else if (event.type === "message-finish" && event.usage) yield event.usage;
+		}
+		return gen();
+	}
+	then(onfulfilled, onrejected) {
+		return (async () => {
+			let latest;
+			for await (const usage of this) latest = usage;
+			return latest ?? {
+				input_tokens: 0,
+				output_tokens: 0,
+				total_tokens: 0
+			};
+		})().then(onfulfilled, onrejected);
+	}
+};
+/**
+* The main stream object returned by chat model streaming.
+*
+* Implements `AsyncIterable<ChatModelStreamEvent>` for raw event access
+* and `PromiseLike<AIMessage>` for simple `await` usage.
+*
+* All sub-streams are replay-safe: multiple consumers reading from the
+* same stream work correctly because each gets its own cursor over the
+* shared buffer.
+*/
+var ChatModelStream = class {
+	/** @internal */
+	_buffer;
+	/** @internal */
+	constructor(source) {
+		this._buffer = new ReplayBuffer();
+		this._consume(source);
+	}
+	/** @internal */
+	async _consume(source) {
+		try {
+			for await (const event of source) this._buffer.push(event);
+			this._buffer.finish();
+		} catch (err) {
+			this._buffer.setError(err instanceof Error ? err : new Error(String(err)));
+		}
+	}
+	/** Iterate over raw {@link ChatModelStreamEvent}s. */
+	[Symbol.asyncIterator]() {
+		return this._buffer.iterate();
+	}
+	/** Text content deltas / full text. */
+	get text() {
+		return new TextContentStream(this._buffer);
+	}
+	/** Completed tool calls. */
+	get toolCalls() {
+		return new ToolCallsStream(this._buffer);
+	}
+	/** Reasoning content (chain-of-thought). */
+	get reasoning() {
+		return new ReasoningContentStream(this._buffer);
+	}
+	/** Usage metadata snapshots. */
+	get usage() {
+		return new UsageMetadataStream(this._buffer);
+	}
+	/** The fully assembled `AIMessage`, available once the stream finishes. */
+	get output() {
+		return { then: (onf, onr) => this._assembleMessage().then(onf, onr) };
+	}
+	/** Allows `await stream` to resolve to the fully assembled `AIMessage`. */
+	then(onfulfilled, onrejected) {
+		return this._assembleMessage().then(onfulfilled, onrejected);
+	}
+	/**
+	* Assemble all stream events into a finalized `AIMessage`.
+	* @internal
+	*/
+	async _assembleMessage() {
+		const contentBlocks = [];
+		let id;
+		let usage;
+		let responseMetadata = {};
+		let finishReason;
+		for await (const event of this._buffer.iterate()) switch (event.type) {
+			case "message-start":
+				id = event.id ?? id;
+				if (event.usage) usage = event.usage;
+				break;
+			case "content-block-start":
+			case "content-block-delta":
+				contentBlocks[event.index] = event.content;
+				break;
+			case "content-block-finish":
+				contentBlocks[event.index] = event.content;
+				break;
+			case "usage":
+				usage = event.usage;
+				break;
+			case "message-finish":
+				finishReason = event.reason;
+				if (event.usage) usage = event.usage;
+				if (event.responseMetadata) responseMetadata = {
+					...responseMetadata,
+					...event.responseMetadata
+				};
+				break;
+			default: break;
+		}
+		const filteredBlocks = contentBlocks.filter((b) => b != null);
+		return new require_ai.AIMessage({
+			id,
+			content: filteredBlocks,
+			usage_metadata: usage,
+			response_metadata: {
+				...responseMetadata,
+				...finishReason ? { finish_reason: finishReason } : {},
+				output_version: "v1"
+			}
+		});
+	}
+};
+//#endregion
+exports.ChatModelStream = ChatModelStream;
+exports.ReasoningContentStream = ReasoningContentStream;
+exports.TextContentStream = TextContentStream;
+exports.ToolCallsStream = ToolCallsStream;
+exports.UsageMetadataStream = UsageMetadataStream;
+Object.defineProperty(exports, "stream_exports", {
+	enumerable: true,
+	get: function() {
+		return stream_exports;
+	}
+});
+
+//# sourceMappingURL=stream.cjs.map

package/dist/language_models/stream.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.cjs","names":["AIMessage"],"sources":["../../src/language_models/stream.ts"],"sourcesContent":["/**\n * Typed stream classes for chat model streaming.\n *\n * Provides {@link ChatModelStream} and typed sub-stream accessors that\n * implement both `AsyncIterable` (for incremental consumption) and\n * `PromiseLike` (for simple `await`).\n *\n * @module\n */\n\nimport { AIMessage } from \"../messages/ai.js\";\nimport type { ContentBlock } from \"../messages/content/index.js\";\nimport type { UsageMetadata } from \"../messages/metadata.js\";\nimport type {\n  ChatModelStreamEvent,\n  ContentBlockDeltaEvent,\n  ContentBlockFinishEvent,\n} from \"./event.js\";\n\n// ─── Replay Buffer ──────────────────────────────────────────────\n\n/**\n * A buffer that caches emitted events for replay.\n *\n * Multiple consumers can independently iterate the same buffer —\n * each gets its own cursor. Events are never consumed or removed.\n *\n * @internal\n */\nclass ReplayBuffer {\n  private events: ChatModelStreamEvent[] = [];\n  private finished = false;\n  private waiters: Array<() => void> = [];\n  private error: Error | null = null;\n\n  push(event: ChatModelStreamEvent): void {\n    this.events.push(event);\n    // Wake ALL waiting consumers — each reads from their own cursor\n    const toWake = this.waiters.splice(0);\n    for (const waiter of toWake) {\n      waiter();\n    }\n  }\n\n  finish(): void {\n    this.finished = true;\n    const toWake = this.waiters.splice(0);\n    for (const waiter of toWake) {\n      waiter();\n    }\n  }\n\n  setError(err: Error): void {\n    this.error = err;\n    this.finished = true;\n    const toWake = this.waiters.splice(0);\n    for (const waiter of toWake) {\n      waiter();\n    }\n  }\n\n  /**\n   * Create an async iterator that replays cached events from the\n   * beginning, then follows live events as they arrive.\n   */\n  async *iterate(): AsyncGenerator<ChatModelStreamEvent> {\n    // Fast path: stream already done, replay everything\n    if (this.finished) {\n      if (this.error) throw this.error;\n      yield* this.events;\n      return;\n    }\n\n    // Live path: follow events as they arrive\n    let cursor = 0;\n    while (true) {\n      while (cursor < this.events.length) {\n        yield this.events[cursor]!;\n        cursor++;\n      }\n      if (this.finished) {\n        if (this.error) throw this.error;\n        return;\n      }\n      // Wait for new data\n      await new Promise<void>((resolve) => {\n        if (cursor < this.events.length || this.finished) {\n          resolve();\n          return;\n        }\n        this.waiters.push(resolve);\n      });\n    }\n  }\n}\n\n// ─── Helpers ────────────────────────────────────────────────────\n\n/** Extract a string field from a loosely-typed content block. */\nfunction getStringField(\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  obj: Record<string, any>,\n  field: string\n): string {\n  const val = obj[field];\n  return typeof val === \"string\" ? val : \"\";\n}\n\n/** Check if a delta event carries a text content block. */\nfunction isTextDelta(\n  event: ChatModelStreamEvent\n): event is ContentBlockDeltaEvent & {\n  content: { type: \"text\"; text?: string };\n} {\n  return event.type === \"content-block-delta\" && event.content.type === \"text\";\n}\n\n/** Check if a delta event carries a reasoning content block. */\nfunction isReasoningDelta(\n  event: ChatModelStreamEvent\n): event is ContentBlockDeltaEvent & {\n  content: { type: \"reasoning\"; reasoning?: string };\n} {\n  return (\n    event.type === \"content-block-delta\" && event.content.type === \"reasoning\"\n  );\n}\n\n/** Check if a finish event carries a tool_call content block. */\nfunction isToolCallFinish(\n  event: ChatModelStreamEvent\n): event is ContentBlockFinishEvent & {\n  content: ContentBlock.Tools.ToolCall;\n} {\n  return (\n    event.type === \"content-block-finish\" && event.content.type === \"tool_call\"\n  );\n}\n\n// ─── Sub-Stream: Text ───────────────────────────────────────────\n\n/**\n * Typed stream for text content.\n *\n * - **Iterate**: yields incremental text deltas (new tokens only).\n * - **Await**: resolves to the complete concatenated text.\n * - **`.full`**: yields the running accumulated text after each delta.\n */\nexport class TextContentStream\n  implements AsyncIterable<string>, PromiseLike<string>\n{\n  /** @internal */\n  private _buffer: ReplayBuffer;\n\n  /** @internal */\n  constructor(buffer: ReplayBuffer) {\n    this._buffer = buffer;\n  }\n\n  /**\n   * Yields the accumulated text so far after each delta.\n   */\n  get full(): AsyncIterable<string> {\n    const buffer = this._buffer;\n    return {\n      async *[Symbol.asyncIterator]() {\n        for await (const event of buffer.iterate()) {\n          if (isTextDelta(event)) {\n            yield getStringField(\n              event.content as Record<string, unknown>,\n              \"text\"\n            );\n          }\n        }\n      },\n    };\n  }\n\n  /**\n   * Yields incremental text deltas (new tokens only).\n   * Computed by diffing successive accumulated states.\n   */\n  [Symbol.asyncIterator](): AsyncIterator<string> {\n    const buffer = this._buffer;\n    async function* gen() {\n      const prevLen = new Map<number, number>();\n      for await (const event of buffer.iterate()) {\n        if (isTextDelta(event)) {\n          const full = getStringField(\n            event.content as Record<string, unknown>,\n            \"text\"\n          );\n          const prev = prevLen.get(event.index) ?? 0;\n          if (full.length > prev) {\n            yield full.slice(prev);\n            prevLen.set(event.index, full.length);\n          }\n        }\n      }\n    }\n    return gen();\n  }\n\n  then<TResult1 = string, TResult2 = never>(\n    onfulfilled?: ((value: string) => TResult1 | PromiseLike<TResult1>) | null,\n    onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null\n  ): PromiseLike<TResult1 | TResult2> {\n    const promise = (async () => {\n      let text = \"\";\n      for await (const delta of this) {\n        text += delta;\n      }\n      return text;\n    })();\n    return promise.then(onfulfilled, onrejected);\n  }\n}\n\n// ─── Sub-Stream: Tool Calls ─────────────────────────────────────\n\n/**\n * Typed stream for tool calls.\n *\n * - **Iterate**: yields individual `ToolCall` objects as each completes.\n * - **Await**: resolves to the full array.\n * - **`.full`**: yields the accumulated array after each new tool call.\n */\nexport class ToolCallsStream\n  implements\n    AsyncIterable<ContentBlock.Tools.ToolCall>,\n    PromiseLike<Array<ContentBlock.Tools.ToolCall>>\n{\n  /** @internal */\n  private _buffer: ReplayBuffer;\n\n  /** @internal */\n  constructor(buffer: ReplayBuffer) {\n    this._buffer = buffer;\n  }\n\n  get full(): AsyncIterable<Array<ContentBlock.Tools.ToolCall>> {\n    const buffer = this._buffer;\n    return {\n      async *[Symbol.asyncIterator]() {\n        const calls: Array<ContentBlock.Tools.ToolCall> = [];\n        for await (const event of buffer.iterate()) {\n          if (isToolCallFinish(event)) {\n            calls.push(event.content);\n            yield [...calls];\n          }\n        }\n      },\n    };\n  }\n\n  [Symbol.asyncIterator](): AsyncIterator<ContentBlock.Tools.ToolCall> {\n    const buffer = this._buffer;\n    async function* gen() {\n      for await (const event of buffer.iterate()) {\n        if (isToolCallFinish(event)) {\n          yield event.content;\n        }\n      }\n    }\n    return gen();\n  }\n\n  then<TResult1 = Array<ContentBlock.Tools.ToolCall>, TResult2 = never>(\n    onfulfilled?:\n      | ((\n          value: Array<ContentBlock.Tools.ToolCall>\n        ) => TResult1 | PromiseLike<TResult1>)\n      | null,\n    onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null\n  ): PromiseLike<TResult1 | TResult2> {\n    const promise = (async () => {\n      const calls: Array<ContentBlock.Tools.ToolCall> = [];\n      for await (const call of this) {\n        calls.push(call);\n      }\n      return calls;\n    })();\n    return promise.then(onfulfilled, onrejected);\n  }\n}\n\n// ─── Sub-Stream: Reasoning ──────────────────────────────────────\n\n/**\n * Typed stream for reasoning content (chain-of-thought).\n * Same interface as {@link TextContentStream} but for reasoning blocks.\n */\nexport class ReasoningContentStream\n  implements AsyncIterable<string>, PromiseLike<string>\n{\n  /** @internal */\n  private _buffer: ReplayBuffer;\n\n  /** @internal */\n  constructor(buffer: ReplayBuffer) {\n    this._buffer = buffer;\n  }\n\n  get full(): AsyncIterable<string> {\n    const buffer = this._buffer;\n    return {\n      async *[Symbol.asyncIterator]() {\n        for await (const event of buffer.iterate()) {\n          if (isReasoningDelta(event)) {\n            yield getStringField(\n              event.content as Record<string, unknown>,\n              \"reasoning\"\n            );\n          }\n        }\n      },\n    };\n  }\n\n  [Symbol.asyncIterator](): AsyncIterator<string> {\n    const buffer = this._buffer;\n    async function* gen() {\n      const prevLen = new Map<number, number>();\n      for await (const event of buffer.iterate()) {\n        if (isReasoningDelta(event)) {\n          const full = getStringField(\n            event.content as Record<string, unknown>,\n            \"reasoning\"\n          );\n          const prev = prevLen.get(event.index) ?? 0;\n          if (full.length > prev) {\n            yield full.slice(prev);\n            prevLen.set(event.index, full.length);\n          }\n        }\n      }\n    }\n    return gen();\n  }\n\n  then<TResult1 = string, TResult2 = never>(\n    onfulfilled?: ((value: string) => TResult1 | PromiseLike<TResult1>) | null,\n    onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null\n  ): PromiseLike<TResult1 | TResult2> {\n    const promise = (async () => {\n      let text = \"\";\n      for await (const delta of this) {\n        text += delta;\n      }\n      return text;\n    })();\n    return promise.then(onfulfilled, onrejected);\n  }\n}\n\n// ─── Sub-Stream: Usage ──────────────────────────────────────────\n\n/**\n * Typed stream for usage metadata.\n *\n * - **Iterate**: yields usage snapshots as they arrive.\n * - **Await**: resolves to the final usage snapshot.\n */\nexport class UsageMetadataStream\n  implements AsyncIterable<UsageMetadata>, PromiseLike<UsageMetadata>\n{\n  /** @internal */\n  private _buffer: ReplayBuffer;\n\n  /** @internal */\n  constructor(buffer: ReplayBuffer) {\n    this._buffer = buffer;\n  }\n\n  [Symbol.asyncIterator](): AsyncIterator<UsageMetadata> {\n    const buffer = this._buffer;\n    async function* gen() {\n      for await (const event of buffer.iterate()) {\n        if (event.type === \"usage\") {\n          yield event.usage;\n        } else if (event.type === \"message-start\" && event.usage) {\n          yield event.usage;\n        } else if (event.type === \"message-finish\" && event.usage) {\n          yield event.usage;\n        }\n      }\n    }\n    return gen();\n  }\n\n  then<TResult1 = UsageMetadata, TResult2 = never>(\n    onfulfilled?:\n      | ((value: UsageMetadata) => TResult1 | PromiseLike<TResult1>)\n      | null,\n    onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null\n  ): PromiseLike<TResult1 | TResult2> {\n    const promise = (async () => {\n      let latest: UsageMetadata | undefined;\n      for await (const usage of this) {\n        latest = usage;\n      }\n      return latest ?? { input_tokens: 0, output_tokens: 0, total_tokens: 0 };\n    })();\n    return promise.then(onfulfilled, onrejected);\n  }\n}\n\n// ─── ChatModelStream ────────────────────────────────────────────\n\n/**\n * The main stream object returned by chat model streaming.\n *\n * Implements `AsyncIterable<ChatModelStreamEvent>` for raw event access\n * and `PromiseLike<AIMessage>` for simple `await` usage.\n *\n * All sub-streams are replay-safe: multiple consumers reading from the\n * same stream work correctly because each gets its own cursor over the\n * shared buffer.\n */\nexport class ChatModelStream\n  implements AsyncIterable<ChatModelStreamEvent>, PromiseLike<AIMessage>\n{\n  /** @internal */\n  private _buffer: ReplayBuffer;\n\n  /** @internal */\n  constructor(source: AsyncIterable<ChatModelStreamEvent>) {\n    this._buffer = new ReplayBuffer();\n    this._consume(source);\n  }\n\n  /** @internal */\n  private async _consume(\n    source: AsyncIterable<ChatModelStreamEvent>\n  ): Promise<void> {\n    try {\n      for await (const event of source) {\n        this._buffer.push(event);\n      }\n      this._buffer.finish();\n    } catch (err) {\n      this._buffer.setError(\n        err instanceof Error ? err : new Error(String(err))\n      );\n    }\n  }\n\n  /** Iterate over raw {@link ChatModelStreamEvent}s. */\n  [Symbol.asyncIterator](): AsyncIterator<ChatModelStreamEvent> {\n    return this._buffer.iterate();\n  }\n\n  /** Text content deltas / full text. */\n  get text(): TextContentStream {\n    return new TextContentStream(this._buffer);\n  }\n\n  /** Completed tool calls. */\n  get toolCalls(): ToolCallsStream {\n    return new ToolCallsStream(this._buffer);\n  }\n\n  /** Reasoning content (chain-of-thought). */\n  get reasoning(): ReasoningContentStream {\n    return new ReasoningContentStream(this._buffer);\n  }\n\n  /** Usage metadata snapshots. */\n  get usage(): UsageMetadataStream {\n    return new UsageMetadataStream(this._buffer);\n  }\n\n  /** The fully assembled `AIMessage`, available once the stream finishes. */\n  get output(): PromiseLike<AIMessage> {\n    return { then: (onf, onr) => this._assembleMessage().then(onf, onr) };\n  }\n\n  /** Allows `await stream` to resolve to the fully assembled `AIMessage`. */\n  then<TResult1 = AIMessage, TResult2 = never>(\n    onfulfilled?:\n      | ((value: AIMessage) => TResult1 | PromiseLike<TResult1>)\n      | null,\n    onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null\n  ): PromiseLike<TResult1 | TResult2> {\n    return this._assembleMessage().then(onfulfilled, onrejected);\n  }\n\n  /**\n   * Assemble all stream events into a finalized `AIMessage`.\n   * @internal\n   */\n  private async _assembleMessage(): Promise<AIMessage> {\n    const contentBlocks: Array<ContentBlock | undefined> = [];\n    let id: string | undefined;\n    let usage: UsageMetadata | undefined;\n    let responseMetadata: Record<string, unknown> = {};\n    let finishReason: string | undefined;\n\n    for await (const event of this._buffer.iterate()) {\n      switch (event.type) {\n        case \"message-start\":\n          id = event.id ?? id;\n          if (event.usage) usage = event.usage;\n          break;\n\n        case \"content-block-start\":\n        case \"content-block-delta\":\n          // Overwrite with the latest accumulated snapshot\n          contentBlocks[event.index] = event.content as ContentBlock;\n          break;\n\n        case \"content-block-finish\":\n          contentBlocks[event.index] = event.content;\n          break;\n\n        case \"usage\":\n          usage = event.usage;\n          break;\n\n        case \"message-finish\":\n          finishReason = event.reason;\n          if (event.usage) usage = event.usage;\n          if (event.responseMetadata) {\n            responseMetadata = {\n              ...responseMetadata,\n              ...event.responseMetadata,\n            };\n          }\n          break;\n\n        default:\n          break;\n      }\n    }\n\n    const filteredBlocks = contentBlocks.filter(\n      (b): b is ContentBlock => b != null\n    );\n\n    return new AIMessage({\n      id,\n      content: filteredBlocks,\n      usage_metadata: usage,\n      response_metadata: {\n        ...responseMetadata,\n        ...(finishReason ? { finish_reason: finishReason } : {}),\n        output_version: \"v1\" as const,\n      },\n    });\n  }\n}\n"],"mappings":"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"}

package/dist/language_models/stream.d.cts

@@ -0,0 +1,129 @@
+import { ContentBlock } from "../messages/content/index.cjs";
+import { UsageMetadata } from "../messages/metadata.cjs";
+import { AIMessage } from "../messages/ai.cjs";
+import { ChatModelStreamEvent } from "./event.cjs";
+
+//#region src/language_models/stream.d.ts
+/**
+ * A buffer that caches emitted events for replay.
+ *
+ * Multiple consumers can independently iterate the same buffer —
+ * each gets its own cursor. Events are never consumed or removed.
+ *
+ * @internal
+ */
+declare class ReplayBuffer {
+  private events;
+  private finished;
+  private waiters;
+  private error;
+  push(event: ChatModelStreamEvent): void;
+  finish(): void;
+  setError(err: Error): void;
+  /**
+   * Create an async iterator that replays cached events from the
+   * beginning, then follows live events as they arrive.
+   */
+  iterate(): AsyncGenerator<ChatModelStreamEvent>;
+}
+/**
+ * Typed stream for text content.
+ *
+ * - **Iterate**: yields incremental text deltas (new tokens only).
+ * - **Await**: resolves to the complete concatenated text.
+ * - **`.full`**: yields the running accumulated text after each delta.
+ */
+declare class TextContentStream implements AsyncIterable<string>, PromiseLike<string> {
+  /** @internal */
+  private _buffer;
+  /** @internal */
+  constructor(buffer: ReplayBuffer);
+  /**
+   * Yields the accumulated text so far after each delta.
+   */
+  get full(): AsyncIterable<string>;
+  /**
+   * Yields incremental text deltas (new tokens only).
+   * Computed by diffing successive accumulated states.
+   */
+  [Symbol.asyncIterator](): AsyncIterator<string>;
+  then<TResult1 = string, TResult2 = never>(onfulfilled?: ((value: string) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): PromiseLike<TResult1 | TResult2>;
+}
+/**
+ * Typed stream for tool calls.
+ *
+ * - **Iterate**: yields individual `ToolCall` objects as each completes.
+ * - **Await**: resolves to the full array.
+ * - **`.full`**: yields the accumulated array after each new tool call.
+ */
+declare class ToolCallsStream implements AsyncIterable<ContentBlock.Tools.ToolCall>, PromiseLike<Array<ContentBlock.Tools.ToolCall>> {
+  /** @internal */
+  private _buffer;
+  /** @internal */
+  constructor(buffer: ReplayBuffer);
+  get full(): AsyncIterable<Array<ContentBlock.Tools.ToolCall>>;
+  [Symbol.asyncIterator](): AsyncIterator<ContentBlock.Tools.ToolCall>;
+  then<TResult1 = Array<ContentBlock.Tools.ToolCall>, TResult2 = never>(onfulfilled?: ((value: Array<ContentBlock.Tools.ToolCall>) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): PromiseLike<TResult1 | TResult2>;
+}
+/**
+ * Typed stream for reasoning content (chain-of-thought).
+ * Same interface as {@link TextContentStream} but for reasoning blocks.
+ */
+declare class ReasoningContentStream implements AsyncIterable<string>, PromiseLike<string> {
+  /** @internal */
+  private _buffer;
+  /** @internal */
+  constructor(buffer: ReplayBuffer);
+  get full(): AsyncIterable<string>;
+  [Symbol.asyncIterator](): AsyncIterator<string>;
+  then<TResult1 = string, TResult2 = never>(onfulfilled?: ((value: string) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): PromiseLike<TResult1 | TResult2>;
+}
+/**
+ * Typed stream for usage metadata.
+ *
+ * - **Iterate**: yields usage snapshots as they arrive.
+ * - **Await**: resolves to the final usage snapshot.
+ */
+declare class UsageMetadataStream implements AsyncIterable<UsageMetadata>, PromiseLike<UsageMetadata> {
+  /** @internal */
+  private _buffer;
+  /** @internal */
+  constructor(buffer: ReplayBuffer);
+  [Symbol.asyncIterator](): AsyncIterator<UsageMetadata>;
+  then<TResult1 = UsageMetadata, TResult2 = never>(onfulfilled?: ((value: UsageMetadata) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): PromiseLike<TResult1 | TResult2>;
+}
+/**
+ * The main stream object returned by chat model streaming.
+ *
+ * Implements `AsyncIterable<ChatModelStreamEvent>` for raw event access
+ * and `PromiseLike<AIMessage>` for simple `await` usage.
+ *
+ * All sub-streams are replay-safe: multiple consumers reading from the
+ * same stream work correctly because each gets its own cursor over the
+ * shared buffer.
+ */
+declare class ChatModelStream implements AsyncIterable<ChatModelStreamEvent>, PromiseLike<AIMessage> {
+  /** @internal */
+  private _buffer;
+  /** @internal */
+  constructor(source: AsyncIterable<ChatModelStreamEvent>);
+  private _consume;
+  /** Iterate over raw {@link ChatModelStreamEvent}s. */
+  [Symbol.asyncIterator](): AsyncIterator<ChatModelStreamEvent>;
+  /** Text content deltas / full text. */
+  get text(): TextContentStream;
+  /** Completed tool calls. */
+  get toolCalls(): ToolCallsStream;
+  /** Reasoning content (chain-of-thought). */
+  get reasoning(): ReasoningContentStream;
+  /** Usage metadata snapshots. */
+  get usage(): UsageMetadataStream;
+  /** The fully assembled `AIMessage`, available once the stream finishes. */
+  get output(): PromiseLike<AIMessage>;
+  /** Allows `await stream` to resolve to the fully assembled `AIMessage`. */
+  then<TResult1 = AIMessage, TResult2 = never>(onfulfilled?: ((value: AIMessage) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): PromiseLike<TResult1 | TResult2>;
+  private _assembleMessage;
+}
+//#endregion
+export { ChatModelStream, ReasoningContentStream, TextContentStream, ToolCallsStream, UsageMetadataStream };
+//# sourceMappingURL=stream.d.cts.map

package/dist/language_models/stream.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.cts","names":[],"sources":["../../src/language_models/stream.ts"],"mappings":"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"}