@langchain/core 1.1.39 → 1.2.0-dev-1775763803878

package/dist/language_models/compat.js

@@ -0,0 +1,226 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+import { AIMessageChunk } from "../messages/ai.js";
+//#region src/language_models/compat.ts
+/**
+* Compatibility bridge: converts legacy `_streamResponseChunks`
+* (`ChatGenerationChunk` / `AIMessageChunk`) output to the new
+* `ChatModelStreamEvent` protocol.
+*
+* This module is used by `BaseChatModel._streamChatModelEvents` as
+* the default implementation when a provider has not yet implemented
+* native event streaming.
+*
+* @module
+*/
+var compat_exports = /* @__PURE__ */ __exportAll({
+	accumulateContentBlock: () => accumulateContentBlock,
+	convertChunksToEvents: () => convertChunksToEvents,
+	finalizeContentBlock: () => finalizeContentBlock
+});
+/**
+* Convert an async iterable of legacy `ChatGenerationChunk`s into
+* `ChatModelStreamEvent`s.
+*
+* Tracks content blocks by index, synthesizes start/delta/finish events,
+* and emits usage updates. Handles both string content and array content
+* blocks, as well as tool call chunks.
+*
+* @param chunks - The legacy chunk stream from `_streamResponseChunks`.
+* @param options - Optional signal for abort handling.
+* @returns An async generator of {@link ChatModelStreamEvent}.
+*/
+async function* convertChunksToEvents(chunks, options) {
+	const activeBlocks = /* @__PURE__ */ new Map();
+	let messageStarted = false;
+	let lastUsage;
+	for await (const chunk of chunks) {
+		options?.signal?.throwIfAborted();
+		const msg = chunk.message;
+		let usageHandledInStart = false;
+		if (!messageStarted) {
+			messageStarted = true;
+			const startEvent = {
+				type: "message-start",
+				id: msg.id ?? void 0
+			};
+			if (AIMessageChunk.isInstance(msg) && msg.usage_metadata) {
+				startEvent.usage = msg.usage_metadata;
+				lastUsage = { ...msg.usage_metadata };
+				usageHandledInStart = true;
+			}
+			yield startEvent;
+		}
+		const content = msg.content;
+		if (typeof content === "string") {
+			if (content !== "") {
+				const blockIndex = 0;
+				if (!activeBlocks.has(blockIndex)) {
+					const initial = {
+						type: "text",
+						text: ""
+					};
+					activeBlocks.set(blockIndex, {
+						started: true,
+						accumulated: initial
+					});
+					yield {
+						type: "content-block-start",
+						index: blockIndex,
+						content: initial
+					};
+				}
+				const block = activeBlocks.get(blockIndex);
+				const accumulated = {
+					type: "text",
+					text: block.accumulated.text + content
+				};
+				block.accumulated = accumulated;
+				yield {
+					type: "content-block-delta",
+					index: blockIndex,
+					content: accumulated
+				};
+			}
+		} else if (Array.isArray(content)) for (const part of content) {
+			const blockIndex = typeof part.index === "number" ? part.index : activeBlocks.size;
+			if (!activeBlocks.has(blockIndex)) {
+				activeBlocks.set(blockIndex, {
+					started: true,
+					accumulated: { ...part }
+				});
+				yield {
+					type: "content-block-start",
+					index: blockIndex,
+					content: { ...part }
+				};
+			} else {
+				const block = activeBlocks.get(blockIndex);
+				const accumulated = accumulateContentBlock(block.accumulated, part);
+				block.accumulated = accumulated;
+				yield {
+					type: "content-block-delta",
+					index: blockIndex,
+					content: accumulated
+				};
+			}
+		}
+		if (AIMessageChunk.isInstance(msg) && msg.tool_call_chunks && msg.tool_call_chunks.length > 0) for (const toolChunk of msg.tool_call_chunks) {
+			const blockIndex = typeof toolChunk.index === "number" ? toolChunk.index : activeBlocks.size;
+			const delta = {
+				type: "tool_call_chunk",
+				id: toolChunk.id,
+				name: toolChunk.name,
+				args: toolChunk.args,
+				index: blockIndex
+			};
+			if (!activeBlocks.has(blockIndex)) {
+				activeBlocks.set(blockIndex, {
+					started: true,
+					accumulated: { ...delta }
+				});
+				yield {
+					type: "content-block-start",
+					index: blockIndex,
+					content: { ...delta }
+				};
+			} else {
+				const block = activeBlocks.get(blockIndex);
+				const accumulated = accumulateContentBlock(block.accumulated, delta);
+				block.accumulated = accumulated;
+				yield {
+					type: "content-block-delta",
+					index: blockIndex,
+					content: accumulated
+				};
+			}
+		}
+		if (!usageHandledInStart && AIMessageChunk.isInstance(msg) && msg.usage_metadata) {
+			const chunkUsage = msg.usage_metadata;
+			if (!lastUsage) lastUsage = { ...chunkUsage };
+			else lastUsage = {
+				input_tokens: lastUsage.input_tokens + chunkUsage.input_tokens,
+				output_tokens: lastUsage.output_tokens + chunkUsage.output_tokens,
+				total_tokens: lastUsage.total_tokens + chunkUsage.total_tokens
+			};
+			yield {
+				type: "usage",
+				usage: { ...lastUsage }
+			};
+		}
+	}
+	for (const [index, block] of activeBlocks) yield {
+		type: "content-block-finish",
+		index,
+		content: finalizeContentBlock(block.accumulated)
+	};
+	yield {
+		type: "message-finish",
+		reason: "stop",
+		...lastUsage ? { usage: lastUsage } : {}
+	};
+}
+/**
+* Accumulate a content block delta into the running snapshot.
+*/
+function accumulateContentBlock(accumulated, delta) {
+	if (accumulated.type === "text" && delta.type === "text") return {
+		...accumulated,
+		type: "text",
+		text: accumulated.text + (delta.text ?? "")
+	};
+	if (accumulated.type === "reasoning" && delta.type === "reasoning") return {
+		...accumulated,
+		type: "reasoning",
+		reasoning: accumulated.reasoning + (delta.reasoning ?? "")
+	};
+	if ((accumulated.type === "tool_call_chunk" || accumulated.type === "tool_call") && (delta.type === "tool_call_chunk" || delta.type === "tool_call")) {
+		const accTC = accumulated;
+		const deltaTC = delta;
+		return {
+			...accumulated,
+			type: "tool_call_chunk",
+			id: accTC.id ?? deltaTC.id,
+			name: accTC.name ?? deltaTC.name,
+			args: (accTC.args ?? "") + (deltaTC.args ?? ""),
+			index: accTC.index ?? deltaTC.index
+		};
+	}
+	return {
+		...accumulated,
+		...delta
+	};
+}
+/**
+* Finalize a content block for the finish event.
+*
+* For tool calls, attempts to parse the accumulated args JSON string
+* into an object, upgrading from `tool_call_chunk` to `tool_call`.
+*/
+function finalizeContentBlock(block) {
+	if (block.type === "tool_call_chunk") {
+		const chunk = block;
+		let parsedArgs;
+		try {
+			parsedArgs = JSON.parse(chunk.args ?? "{}");
+		} catch {
+			return {
+				type: "invalid_tool_call",
+				id: chunk.id,
+				name: chunk.name,
+				args: chunk.args,
+				error: "Failed to parse tool call arguments as JSON"
+			};
+		}
+		return {
+			type: "tool_call",
+			id: chunk.id,
+			name: chunk.name,
+			args: parsedArgs
+		};
+	}
+	return block;
+}
+//#endregion
+export { accumulateContentBlock, compat_exports, convertChunksToEvents, finalizeContentBlock };
+
+//# sourceMappingURL=compat.js.map

package/dist/language_models/compat.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compat.js","names":[],"sources":["../../src/language_models/compat.ts"],"sourcesContent":["/**\n * Compatibility bridge: converts legacy `_streamResponseChunks`\n * (`ChatGenerationChunk` / `AIMessageChunk`) output to the new\n * `ChatModelStreamEvent` protocol.\n *\n * This module is used by `BaseChatModel._streamChatModelEvents` as\n * the default implementation when a provider has not yet implemented\n * native event streaming.\n *\n * @module\n */\n\nimport { AIMessageChunk } from \"../messages/ai.js\";\nimport type { ContentBlock } from \"../messages/content/index.js\";\nimport type { ChatGenerationChunk } from \"../outputs.js\";\nimport type { ChatModelStreamEvent } from \"./event.js\";\n\n/**\n * Convert an async iterable of legacy `ChatGenerationChunk`s into\n * `ChatModelStreamEvent`s.\n *\n * Tracks content blocks by index, synthesizes start/delta/finish events,\n * and emits usage updates. Handles both string content and array content\n * blocks, as well as tool call chunks.\n *\n * @param chunks - The legacy chunk stream from `_streamResponseChunks`.\n * @param options - Optional signal for abort handling.\n * @returns An async generator of {@link ChatModelStreamEvent}.\n */\nexport async function* convertChunksToEvents(\n  chunks: AsyncIterable<ChatGenerationChunk>,\n  options?: { signal?: AbortSignal }\n): AsyncGenerator<ChatModelStreamEvent> {\n  // Track active content blocks for the bridge\n  const activeBlocks = new Map<\n    number,\n    { started: boolean; accumulated: ContentBlock }\n  >();\n  let messageStarted = false;\n  let lastUsage:\n    | { input_tokens: number; output_tokens: number; total_tokens: number }\n    | undefined;\n\n  for await (const chunk of chunks) {\n    options?.signal?.throwIfAborted();\n\n    const msg = chunk.message;\n\n    // Emit message-start on the first chunk\n    let usageHandledInStart = false;\n    if (!messageStarted) {\n      messageStarted = true;\n      const startEvent: ChatModelStreamEvent = {\n        type: \"message-start\" as const,\n        id: msg.id ?? undefined,\n      };\n      // If first chunk has usage (e.g., Anthropic input tokens)\n      if (AIMessageChunk.isInstance(msg) && msg.usage_metadata) {\n        (startEvent as { usage?: unknown }).usage = msg.usage_metadata;\n        lastUsage = { ...msg.usage_metadata };\n        usageHandledInStart = true;\n      }\n      yield startEvent;\n    }\n\n    // Process content from the chunk\n    const content = msg.content;\n    if (typeof content === \"string\") {\n      if (content !== \"\") {\n        // Simple string content → single text block at index 0\n        const blockIndex = 0;\n\n        if (!activeBlocks.has(blockIndex)) {\n          const initial: ContentBlock.Text = { type: \"text\", text: \"\" };\n          activeBlocks.set(blockIndex, {\n            started: true,\n            accumulated: initial,\n          });\n          yield {\n            type: \"content-block-start\" as const,\n            index: blockIndex,\n            content: initial,\n          };\n        }\n\n        const block = activeBlocks.get(blockIndex)!;\n        const prevText = (block.accumulated as ContentBlock.Text).text;\n        const accumulated: ContentBlock.Text = {\n          type: \"text\",\n          text: prevText + content,\n        };\n        block.accumulated = accumulated;\n\n        yield {\n          type: \"content-block-delta\" as const,\n          index: blockIndex,\n          content: accumulated,\n        };\n      }\n    } else if (Array.isArray(content)) {\n      for (const part of content) {\n        const blockIndex =\n          typeof part.index === \"number\" ? part.index : activeBlocks.size;\n\n        if (!activeBlocks.has(blockIndex)) {\n          activeBlocks.set(blockIndex, {\n            started: true,\n            accumulated: { ...part },\n          });\n          yield {\n            type: \"content-block-start\" as const,\n            index: blockIndex,\n            content: { ...part },\n          };\n        } else {\n          // Accumulate into existing block\n          const block = activeBlocks.get(blockIndex)!;\n          const accumulated = accumulateContentBlock(block.accumulated, part);\n          block.accumulated = accumulated;\n\n          yield {\n            type: \"content-block-delta\" as const,\n            index: blockIndex,\n            content: accumulated,\n          };\n        }\n      }\n    }\n\n    // Handle tool call chunks from the legacy path\n    if (\n      AIMessageChunk.isInstance(msg) &&\n      msg.tool_call_chunks &&\n      msg.tool_call_chunks.length > 0\n    ) {\n      for (const toolChunk of msg.tool_call_chunks) {\n        const blockIndex =\n          typeof toolChunk.index === \"number\"\n            ? toolChunk.index\n            : activeBlocks.size;\n\n        const delta: ContentBlock = {\n          type: \"tool_call_chunk\" as const,\n          id: toolChunk.id,\n          name: toolChunk.name,\n          args: toolChunk.args,\n          index: blockIndex,\n        };\n\n        if (!activeBlocks.has(blockIndex)) {\n          activeBlocks.set(blockIndex, {\n            started: true,\n            accumulated: { ...delta },\n          });\n          yield {\n            type: \"content-block-start\" as const,\n            index: blockIndex,\n            content: { ...delta },\n          };\n        } else {\n          const block = activeBlocks.get(blockIndex)!;\n          const accumulated = accumulateContentBlock(block.accumulated, delta);\n          block.accumulated = accumulated;\n\n          yield {\n            type: \"content-block-delta\" as const,\n            index: blockIndex,\n            content: accumulated,\n          };\n        }\n      }\n    }\n\n    // Accumulate usage (legacy chunks use additive usage, not snapshots)\n    if (\n      !usageHandledInStart &&\n      AIMessageChunk.isInstance(msg) &&\n      msg.usage_metadata\n    ) {\n      const chunkUsage = msg.usage_metadata;\n      if (!lastUsage) {\n        lastUsage = { ...chunkUsage };\n      } else {\n        lastUsage = {\n          input_tokens: lastUsage.input_tokens + chunkUsage.input_tokens,\n          output_tokens: lastUsage.output_tokens + chunkUsage.output_tokens,\n          total_tokens: lastUsage.total_tokens + chunkUsage.total_tokens,\n        };\n      }\n      yield { type: \"usage\" as const, usage: { ...lastUsage } };\n    }\n  }\n\n  // Emit content-block-finish for all active blocks\n  for (const [index, block] of activeBlocks) {\n    const finalized = finalizeContentBlock(block.accumulated);\n    yield {\n      type: \"content-block-finish\" as const,\n      index,\n      content: finalized,\n    };\n  }\n\n  // Emit message-finish\n  yield {\n    type: \"message-finish\" as const,\n    reason: \"stop\" as const,\n    ...(lastUsage ? { usage: lastUsage } : {}),\n  };\n}\n\n/**\n * Accumulate a content block delta into the running snapshot.\n */\nexport function accumulateContentBlock(\n  accumulated: ContentBlock,\n  delta: ContentBlock\n): ContentBlock {\n  if (accumulated.type === \"text\" && delta.type === \"text\") {\n    return {\n      ...accumulated,\n      type: \"text\" as const,\n      text:\n        (accumulated as ContentBlock.Text).text +\n        ((delta as ContentBlock.Text).text ?? \"\"),\n    } as ContentBlock.Text;\n  }\n\n  if (accumulated.type === \"reasoning\" && delta.type === \"reasoning\") {\n    return {\n      ...accumulated,\n      type: \"reasoning\" as const,\n      reasoning:\n        (accumulated as ContentBlock.Reasoning).reasoning +\n        ((delta as ContentBlock.Reasoning).reasoning ?? \"\"),\n    } as ContentBlock.Reasoning;\n  }\n\n  if (\n    (accumulated.type === \"tool_call_chunk\" ||\n      accumulated.type === \"tool_call\") &&\n    (delta.type === \"tool_call_chunk\" || delta.type === \"tool_call\")\n  ) {\n    const accTC = accumulated as ContentBlock.Tools.ToolCallChunk;\n    const deltaTC = delta as ContentBlock.Tools.ToolCallChunk;\n    return {\n      ...accumulated,\n      type: \"tool_call_chunk\" as const,\n      id: accTC.id ?? deltaTC.id,\n      name: accTC.name ?? deltaTC.name,\n      args: (accTC.args ?? \"\") + (deltaTC.args ?? \"\"),\n      index: accTC.index ?? deltaTC.index,\n    } as ContentBlock.Tools.ToolCallChunk;\n  }\n\n  // For block types we don't know how to merge, just spread the delta over\n  return { ...accumulated, ...delta };\n}\n\n/**\n * Finalize a content block for the finish event.\n *\n * For tool calls, attempts to parse the accumulated args JSON string\n * into an object, upgrading from `tool_call_chunk` to `tool_call`.\n */\nexport function finalizeContentBlock(block: ContentBlock): ContentBlock {\n  if (block.type === \"tool_call_chunk\") {\n    const chunk = block as ContentBlock.Tools.ToolCallChunk;\n    let parsedArgs: unknown;\n    try {\n      parsedArgs = JSON.parse(chunk.args ?? \"{}\");\n    } catch {\n      // If JSON parsing fails, return as invalid tool call\n      return {\n        type: \"invalid_tool_call\" as const,\n        id: chunk.id,\n        name: chunk.name,\n        args: chunk.args,\n        error: \"Failed to parse tool call arguments as JSON\",\n      } as ContentBlock.Tools.InvalidToolCall;\n    }\n    return {\n      type: \"tool_call\" as const,\n      id: chunk.id,\n      name: chunk.name!,\n      args: parsedArgs,\n    } as ContentBlock.Tools.ToolCall;\n  }\n\n  return block;\n}\n"],"mappings":"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"}

package/dist/language_models/event.cjs

@@ -0,0 +1,12 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/language_models/event.ts
+var event_exports = /* @__PURE__ */ require("../_virtual/_rolldown/runtime.cjs").__exportAll({});
+//#endregion
+Object.defineProperty(exports, "event_exports", {
+	enumerable: true,
+	get: function() {
+		return event_exports;
+	}
+});
+
+//# sourceMappingURL=event.cjs.map

package/dist/language_models/event.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"event.cjs","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/event.d.cts

@@ -0,0 +1,193 @@
+import { ContentBlock, PartialContentBlock } from "../messages/content/index.cjs";
+import { UsageMetadata } from "../messages/metadata.cjs";
+
+//#region src/language_models/event.d.ts
+/**
+ * Emitted once at the start of a model response.
+ */
+interface MessageStartEvent {
+  type: "message-start";
+  /** Optional message ID assigned by the provider. */
+  id?: string;
+  /**
+   * Initial usage snapshot, if the provider reports input token counts
+   * before content begins streaming (e.g., Anthropic's `message_start`).
+   */
+  usage?: UsageMetadata;
+}
+/**
+ * Finish reason for a model response.
+ *
+ * - `"stop"`: Natural end of generation.
+ * - `"length"`: Hit max token limit.
+ * - `"tool_use"`: Model is requesting tool execution.
+ * - `"content_filter"`: Content was filtered by safety systems.
+ */
+type FinishReason = "stop" | "length" | "tool_use" | "content_filter";
+/**
+ * Emitted once when the model response is complete.
+ */
+interface MessageFinishEvent {
+  type: "message-finish";
+  /** Why the model stopped generating. */
+  reason: FinishReason;
+  /** Final usage snapshot. */
+  usage?: UsageMetadata;
+  /** Provider-specific response metadata (model name, response ID, headers, etc.). */
+  responseMetadata?: Record<string, unknown>;
+}
+/**
+ * Emitted when a new content block begins streaming.
+ *
+ * @example
+ * ```ts
+ * // Text block starting
+ * { type: "content-block-start", index: 0,
+ *   content: { type: "text", text: "" } }
+ *
+ * // Tool call starting
+ * { type: "content-block-start", index: 1,
+ *   content: { type: "tool_call", id: "call_1", name: "search", args: "" } }
+ *
+ * // Reasoning starting
+ * { type: "content-block-start", index: 2,
+ *   content: { type: "reasoning", reasoning: "" } }
+ * ```
+ */
+interface ContentBlockStartEvent {
+  type: "content-block-start";
+  /** Positional index of this block within the message. */
+  index: number;
+  /** Initial state of the content block. */
+  content: ContentBlock;
+}
+/**
+ * Emitted for each incremental update within a content block.
+ *
+ * Carries the **accumulated state** of the content block so far.
+ * The content is deeply partial — not all fields may be populated during
+ * streaming (e.g., a tool call may have `name` but `args` is still being
+ * streamed as a partial JSON string).
+ *
+ * Consumers who need incremental deltas (e.g., new tokens only) should
+ * track the previous state and diff against the new accumulated state.
+ *
+ * Aggregation into `AIMessage` is trivial:
+ * `message.content[event.index] = event.content`
+ *
+ * @example
+ * ```ts
+ * // First text delta — accumulated so far
+ * { type: "content-block-delta", index: 0,
+ *   content: { type: "text", text: "Hello" } }
+ *
+ * // Second text delta — accumulated so far
+ * { type: "content-block-delta", index: 0,
+ *   content: { type: "text", text: "Hello world" } }
+ *
+ * // Tool call args — accumulated so far
+ * { type: "content-block-delta", index: 1,
+ *   content: { type: "tool_call", id: "call_1", name: "search", args: '{"q":"wea' } }
+ * ```
+ */
+interface ContentBlockDeltaEvent {
+  type: "content-block-delta";
+  /** Positional index of the block being updated. */
+  index: number;
+  /** Accumulated state of the content block after this update. Deeply partial. */
+  content: PartialContentBlock;
+}
+/**
+ * Emitted when a content block is complete.
+ *
+ * The `content` carries the **finalized** block. For tool calls, this means
+ * args have been parsed from a JSON string into an object.
+ *
+ * @example
+ * ```ts
+ * // Finalized text block
+ * { type: "content-block-finish", index: 0,
+ *   content: { type: "text", text: "The weather is sunny." } }
+ *
+ * // Finalized tool call (args parsed)
+ * { type: "content-block-finish", index: 1,
+ *   content: { type: "tool_call", id: "call_1", name: "search",
+ *              args: { q: "weather" } } }
+ * ```
+ */
+interface ContentBlockFinishEvent {
+  type: "content-block-finish";
+  /** Positional index of the completed block. */
+  index: number;
+  /** Finalized content block. */
+  content: ContentBlock;
+}
+/**
+ * Emitted whenever the provider reports updated usage information.
+ *
+ * May appear at any point during streaming. Each event carries a
+ * **running snapshot** of usage (not an additive delta), so consumers
+ * can simply take the latest value.
+ *
+ * @example
+ * ```ts
+ * // After message_start (Anthropic: input tokens known)
+ * { type: "usage", usage: { input_tokens: 1234, output_tokens: 0, total_tokens: 1234 } }
+ *
+ * // After streaming completes
+ * { type: "usage", usage: { input_tokens: 1234, output_tokens: 567, total_tokens: 1801 } }
+ * ```
+ */
+interface UsageUpdateEvent {
+  type: "usage";
+  /** Current usage snapshot. */
+  usage: UsageMetadata;
+}
+/**
+ * Passthrough for native provider events that don't map to standard types.
+ *
+ * Provider adapters map recognized events to standard {@link ChatModelStreamEvent}
+ * types and forward everything else as `ProviderEvent`. This ensures no information
+ * is silently dropped.
+ *
+ * @example
+ * ```ts
+ * // OpenAI server-side web search in progress
+ * { type: "provider", provider: "openai",
+ *   name: "response.web_search_call.searching",
+ *   payload: { item_id: "ws_123", output_index: 0 } }
+ *
+ * // Anthropic context management signal
+ * { type: "provider", provider: "anthropic",
+ *   name: "context_management",
+ *   payload: { ... } }
+ * ```
+ */
+interface ProviderEvent {
+  type: "provider";
+  /** Provider identifier (e.g., `"openai"`, `"anthropic"`, `"google"`). */
+  provider: string;
+  /** Raw event type name from the provider SDK. */
+  name: string;
+  /** Raw event payload from the provider SDK. */
+  payload: unknown;
+}
+/**
+ * Emitted on unrecoverable stream errors.
+ */
+interface StreamErrorEvent {
+  type: "error";
+  /** Human-readable error message. */
+  message: string;
+  /** Optional error code for programmatic handling. */
+  code?: string;
+}
+/**
+ * Union of all chat model stream event types.
+ *
+ * This is the type yielded by `ChatModelStream[Symbol.asyncIterator]()`.
+ */
+type ChatModelStreamEvent = MessageStartEvent | MessageFinishEvent | ContentBlockStartEvent | ContentBlockDeltaEvent | ContentBlockFinishEvent | UsageUpdateEvent | ProviderEvent | StreamErrorEvent;
+//#endregion
+export { ChatModelStreamEvent, ContentBlockDeltaEvent, ContentBlockFinishEvent, ContentBlockStartEvent, FinishReason, MessageFinishEvent, MessageStartEvent, ProviderEvent, StreamErrorEvent, UsageUpdateEvent };
+//# sourceMappingURL=event.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"event.d.cts","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.d.ts

@@ -0,0 +1,193 @@
+import { ContentBlock, PartialContentBlock } from "../messages/content/index.js";
+import { UsageMetadata } from "../messages/metadata.js";
+
+//#region src/language_models/event.d.ts
+/**
+ * Emitted once at the start of a model response.
+ */
+interface MessageStartEvent {
+  type: "message-start";
+  /** Optional message ID assigned by the provider. */
+  id?: string;
+  /**
+   * Initial usage snapshot, if the provider reports input token counts
+   * before content begins streaming (e.g., Anthropic's `message_start`).
+   */
+  usage?: UsageMetadata;
+}
+/**
+ * Finish reason for a model response.
+ *
+ * - `"stop"`: Natural end of generation.
+ * - `"length"`: Hit max token limit.
+ * - `"tool_use"`: Model is requesting tool execution.
+ * - `"content_filter"`: Content was filtered by safety systems.
+ */
+type FinishReason = "stop" | "length" | "tool_use" | "content_filter";
+/**
+ * Emitted once when the model response is complete.
+ */
+interface MessageFinishEvent {
+  type: "message-finish";
+  /** Why the model stopped generating. */
+  reason: FinishReason;
+  /** Final usage snapshot. */
+  usage?: UsageMetadata;
+  /** Provider-specific response metadata (model name, response ID, headers, etc.). */
+  responseMetadata?: Record<string, unknown>;
+}
+/**
+ * Emitted when a new content block begins streaming.
+ *
+ * @example
+ * ```ts
+ * // Text block starting
+ * { type: "content-block-start", index: 0,
+ *   content: { type: "text", text: "" } }
+ *
+ * // Tool call starting
+ * { type: "content-block-start", index: 1,
+ *   content: { type: "tool_call", id: "call_1", name: "search", args: "" } }
+ *
+ * // Reasoning starting
+ * { type: "content-block-start", index: 2,
+ *   content: { type: "reasoning", reasoning: "" } }
+ * ```
+ */
+interface ContentBlockStartEvent {
+  type: "content-block-start";
+  /** Positional index of this block within the message. */
+  index: number;
+  /** Initial state of the content block. */
+  content: ContentBlock;
+}
+/**
+ * Emitted for each incremental update within a content block.
+ *
+ * Carries the **accumulated state** of the content block so far.
+ * The content is deeply partial — not all fields may be populated during
+ * streaming (e.g., a tool call may have `name` but `args` is still being
+ * streamed as a partial JSON string).
+ *
+ * Consumers who need incremental deltas (e.g., new tokens only) should
+ * track the previous state and diff against the new accumulated state.
+ *
+ * Aggregation into `AIMessage` is trivial:
+ * `message.content[event.index] = event.content`
+ *
+ * @example
+ * ```ts
+ * // First text delta — accumulated so far
+ * { type: "content-block-delta", index: 0,
+ *   content: { type: "text", text: "Hello" } }
+ *
+ * // Second text delta — accumulated so far
+ * { type: "content-block-delta", index: 0,
+ *   content: { type: "text", text: "Hello world" } }
+ *
+ * // Tool call args — accumulated so far
+ * { type: "content-block-delta", index: 1,
+ *   content: { type: "tool_call", id: "call_1", name: "search", args: '{"q":"wea' } }
+ * ```
+ */
+interface ContentBlockDeltaEvent {
+  type: "content-block-delta";
+  /** Positional index of the block being updated. */
+  index: number;
+  /** Accumulated state of the content block after this update. Deeply partial. */
+  content: PartialContentBlock;
+}
+/**
+ * Emitted when a content block is complete.
+ *
+ * The `content` carries the **finalized** block. For tool calls, this means
+ * args have been parsed from a JSON string into an object.
+ *
+ * @example
+ * ```ts
+ * // Finalized text block
+ * { type: "content-block-finish", index: 0,
+ *   content: { type: "text", text: "The weather is sunny." } }
+ *
+ * // Finalized tool call (args parsed)
+ * { type: "content-block-finish", index: 1,
+ *   content: { type: "tool_call", id: "call_1", name: "search",
+ *              args: { q: "weather" } } }
+ * ```
+ */
+interface ContentBlockFinishEvent {
+  type: "content-block-finish";
+  /** Positional index of the completed block. */
+  index: number;
+  /** Finalized content block. */
+  content: ContentBlock;
+}
+/**
+ * Emitted whenever the provider reports updated usage information.
+ *
+ * May appear at any point during streaming. Each event carries a
+ * **running snapshot** of usage (not an additive delta), so consumers
+ * can simply take the latest value.
+ *
+ * @example
+ * ```ts
+ * // After message_start (Anthropic: input tokens known)
+ * { type: "usage", usage: { input_tokens: 1234, output_tokens: 0, total_tokens: 1234 } }
+ *
+ * // After streaming completes
+ * { type: "usage", usage: { input_tokens: 1234, output_tokens: 567, total_tokens: 1801 } }
+ * ```
+ */
+interface UsageUpdateEvent {
+  type: "usage";
+  /** Current usage snapshot. */
+  usage: UsageMetadata;
+}
+/**
+ * Passthrough for native provider events that don't map to standard types.
+ *
+ * Provider adapters map recognized events to standard {@link ChatModelStreamEvent}
+ * types and forward everything else as `ProviderEvent`. This ensures no information
+ * is silently dropped.
+ *
+ * @example
+ * ```ts
+ * // OpenAI server-side web search in progress
+ * { type: "provider", provider: "openai",
+ *   name: "response.web_search_call.searching",
+ *   payload: { item_id: "ws_123", output_index: 0 } }
+ *
+ * // Anthropic context management signal
+ * { type: "provider", provider: "anthropic",
+ *   name: "context_management",
+ *   payload: { ... } }
+ * ```
+ */
+interface ProviderEvent {
+  type: "provider";
+  /** Provider identifier (e.g., `"openai"`, `"anthropic"`, `"google"`). */
+  provider: string;
+  /** Raw event type name from the provider SDK. */
+  name: string;
+  /** Raw event payload from the provider SDK. */
+  payload: unknown;
+}
+/**
+ * Emitted on unrecoverable stream errors.
+ */
+interface StreamErrorEvent {
+  type: "error";
+  /** Human-readable error message. */
+  message: string;
+  /** Optional error code for programmatic handling. */
+  code?: string;
+}
+/**
+ * Union of all chat model stream event types.
+ *
+ * This is the type yielded by `ChatModelStream[Symbol.asyncIterator]()`.
+ */
+type ChatModelStreamEvent = MessageStartEvent | MessageFinishEvent | ContentBlockStartEvent | ContentBlockDeltaEvent | ContentBlockFinishEvent | UsageUpdateEvent | ProviderEvent | StreamErrorEvent;
+//#endregion
+export { ChatModelStreamEvent, ContentBlockDeltaEvent, ContentBlockFinishEvent, ContentBlockStartEvent, FinishReason, MessageFinishEvent, MessageStartEvent, ProviderEvent, StreamErrorEvent, UsageUpdateEvent };
+//# sourceMappingURL=event.d.ts.map