@ai-sdk/langchain 2.0.20 → 2.0.21

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @ai-sdk/langchain
 
+## 2.0.21
+
+### Patch Changes
+
+- 75da969: fix(langchain): re-enable support for streamEvents in toUIMessageStream
+
 ## 2.0.20
 
 ### Patch Changes

package/README.md

@@ -56,6 +56,33 @@ return createUIMessageStreamResponse({
 });
 ```
 
+### Streaming with `streamEvents`
+
+You can also use `toUIMessageStream` with `streamEvents()` for more granular event handling:
+
+```ts
+import { toBaseMessages, toUIMessageStream } from '@ai-sdk/langchain';
+import { createUIMessageStreamResponse } from 'ai';
+
+// Using streamEvents with an agent
+const langchainMessages = await toBaseMessages(uiMessages);
+const streamEvents = agent.streamEvents(
+  { messages: langchainMessages },
+  { version: 'v2' },
+);
+
+// Convert to UI message stream response
+return createUIMessageStreamResponse({
+  stream: toUIMessageStream(streamEvents),
+});
+```
+
+The adapter automatically detects the stream type and handles:
+
+- `on_chat_model_stream` events for text streaming
+- `on_tool_start` and `on_tool_end` events for tool calls
+- Reasoning content from contentBlocks
+
 ### Custom Data Streaming
 
 LangChain tools can emit custom data events using `config.writer()`. The adapter converts these to typed `data-{type}` parts:
@@ -174,16 +201,28 @@ Converts a LangChain/LangGraph stream to an AI SDK `UIMessageStream`.
 
 **Parameters:**
 
-- `stream`: `ReadableStream` - LangGraph stream with `streamMode: ['values', 'messages']`
+- `stream`: `AsyncIterable | ReadableStream` - A stream from LangChain `model.stream()`, LangGraph `graph.stream()`, or `streamEvents()`
 
 **Returns:** `ReadableStream<UIMessageChunk>`
 
-**Supported stream events:**
+**Supported stream types:**
+
+- **Model streams** - Direct `AIMessageChunk` streams from `model.stream()`
+- **LangGraph streams** - Streams with `streamMode: ['values', 'messages']`
+- **streamEvents** - Event streams from `agent.streamEvents()` or `model.streamEvents()`
+
+**Supported LangGraph stream events:**
 
 - `messages` - Streaming message chunks (text, tool calls)
 - `values` - State updates that finalize pending message chunks
 - `custom` - Custom data events (emitted as `data-{type}` chunks)
 
+**Supported streamEvents events:**
+
+- `on_chat_model_stream` - Token streaming from chat models
+- `on_tool_start` - Tool execution start
+- `on_tool_end` - Tool execution end with output
+
 ### `LangSmithDeploymentTransport`
 
 A `ChatTransport` implementation for LangSmith/LangGraph deployments.

package/dist/index.d.mts

@@ -46,11 +46,12 @@ declare function convertModelMessages(modelMessages: ModelMessage[]): BaseMessag
 /**
  * Converts a LangChain stream to an AI SDK UIMessageStream.
  *
- * This function automatically detects the stream type and handles both:
+ * This function automatically detects the stream type and handles:
  * - Direct model streams (AsyncIterable from `model.stream()`)
  * - LangGraph streams (ReadableStream with `streamMode: ['values', 'messages']`)
+ * - streamEvents streams (from `agent.streamEvents()` or `model.streamEvents()`)
  *
- * @param stream - A stream from LangChain model.stream() or LangGraph graph.stream().
+ * @param stream - A stream from LangChain model.stream(), graph.stream(), or streamEvents().
  * @param callbacks - Optional callbacks for stream lifecycle events.
  * @returns A ReadableStream of UIMessageChunk objects.
  *
@@ -71,6 +72,15 @@ declare function convertModelMessages(modelMessages: ModelMessage[]): BaseMessag
  * return createUIMessageStreamResponse({
  *   stream: toUIMessageStream(graphStream),
  * });
+ *
+ * // With streamEvents
+ * const streamEvents = agent.streamEvents(
+ *   { messages },
+ *   { version: "v2" }
+ * );
+ * return createUIMessageStreamResponse({
+ *   stream: toUIMessageStream(streamEvents),
+ * });
  * ```
  */
 declare function toUIMessageStream(stream: AsyncIterable<AIMessageChunk> | ReadableStream, callbacks?: StreamCallbacks): ReadableStream<UIMessageChunk>;

package/dist/index.d.ts

@@ -46,11 +46,12 @@ declare function convertModelMessages(modelMessages: ModelMessage[]): BaseMessag
 /**
  * Converts a LangChain stream to an AI SDK UIMessageStream.
  *
- * This function automatically detects the stream type and handles both:
+ * This function automatically detects the stream type and handles:
  * - Direct model streams (AsyncIterable from `model.stream()`)
  * - LangGraph streams (ReadableStream with `streamMode: ['values', 'messages']`)
+ * - streamEvents streams (from `agent.streamEvents()` or `model.streamEvents()`)
  *
- * @param stream - A stream from LangChain model.stream() or LangGraph graph.stream().
+ * @param stream - A stream from LangChain model.stream(), graph.stream(), or streamEvents().
  * @param callbacks - Optional callbacks for stream lifecycle events.
  * @returns A ReadableStream of UIMessageChunk objects.
  *
@@ -71,6 +72,15 @@ declare function convertModelMessages(modelMessages: ModelMessage[]): BaseMessag
  * return createUIMessageStreamResponse({
  *   stream: toUIMessageStream(graphStream),
  * });
+ *
+ * // With streamEvents
+ * const streamEvents = agent.streamEvents(
+ *   { messages },
+ *   { version: "v2" }
+ * );
+ * return createUIMessageStreamResponse({
+ *   stream: toUIMessageStream(streamEvents),
+ * });
  * ```
  */
 declare function toUIMessageStream(stream: AsyncIterable<AIMessageChunk> | ReadableStream, callbacks?: StreamCallbacks): ReadableStream<UIMessageChunk>;

package/dist/index.js

@@ -668,13 +668,116 @@ function convertModelMessages(modelMessages) {
   }
   return result;
 }
+function isStreamEventsEvent(value) {
+  if (value == null || typeof value !== "object") return false;
+  const obj = value;
+  if (!("event" in obj) || typeof obj.event !== "string") return false;
+  if (!("data" in obj)) return false;
+  return obj.data === null || typeof obj.data === "object";
+}
+function processStreamEventsEvent(event, state, controller) {
+  var _a, _b, _c;
+  if (event.run_id && !state.started) {
+    state.messageId = event.run_id;
+  }
+  if (!event.data) return;
+  switch (event.event) {
+    case "on_chat_model_start": {
+      const runId = event.run_id || event.data.run_id;
+      if (runId) {
+        state.messageId = runId;
+      }
+      break;
+    }
+    case "on_chat_model_stream": {
+      const chunk = event.data.chunk;
+      if (chunk && typeof chunk === "object") {
+        const chunkId = chunk.id;
+        if (chunkId) {
+          state.messageId = chunkId;
+        }
+        const reasoning = extractReasoningFromContentBlocks(chunk);
+        if (reasoning) {
+          if (!state.reasoningStarted) {
+            state.reasoningMessageId = state.messageId;
+            controller.enqueue({
+              type: "reasoning-start",
+              id: state.messageId
+            });
+            state.reasoningStarted = true;
+            state.started = true;
+          }
+          controller.enqueue({
+            type: "reasoning-delta",
+            delta: reasoning,
+            id: (_a = state.reasoningMessageId) != null ? _a : state.messageId
+          });
+        }
+        const content = chunk.content;
+        const text = typeof content === "string" ? content : Array.isArray(content) ? content.filter(
+          (c) => typeof c === "object" && c !== null && "type" in c && c.type === "text"
+        ).map((c) => c.text).join("") : "";
+        if (text) {
+          if (state.reasoningStarted && !state.textStarted) {
+            controller.enqueue({
+              type: "reasoning-end",
+              id: (_b = state.reasoningMessageId) != null ? _b : state.messageId
+            });
+            state.reasoningStarted = false;
+          }
+          if (!state.textStarted) {
+            state.textMessageId = state.messageId;
+            controller.enqueue({ type: "text-start", id: state.messageId });
+            state.textStarted = true;
+            state.started = true;
+          }
+          controller.enqueue({
+            type: "text-delta",
+            delta: text,
+            id: (_c = state.textMessageId) != null ? _c : state.messageId
+          });
+        }
+      }
+      break;
+    }
+    case "on_tool_start": {
+      const runId = event.run_id || event.data.run_id;
+      const name = event.name || event.data.name;
+      if (runId && name) {
+        controller.enqueue({
+          type: "tool-input-start",
+          toolCallId: runId,
+          toolName: name,
+          dynamic: true
+        });
+      }
+      break;
+    }
+    case "on_tool_end": {
+      const runId = event.run_id || event.data.run_id;
+      const output = event.data.output;
+      if (runId) {
+        controller.enqueue({
+          type: "tool-output-available",
+          toolCallId: runId,
+          output
+        });
+      }
+      break;
+    }
+  }
+}
 function toUIMessageStream(stream, callbacks) {
   const textChunks = [];
   const modelState = {
     started: false,
     messageId: "langchain-msg-1",
     reasoningStarted: false,
-    textStarted: false
+    textStarted: false,
+    /** Track the ID used for text-start to ensure text-end uses the same ID */
+    textMessageId: null,
+    /** Track the ID used for reasoning-start to ensure reasoning-end uses the same ID */
+    reasoningMessageId: null
   };
   const langGraphState = {
     messageSeen: {},
@@ -721,7 +824,7 @@ function toUIMessageStream(stream, callbacks) {
   };
   return new ReadableStream({
     async start(controller) {
-      var _a, _b;
+      var _a, _b, _c, _d;
       await ((_a = callbacks == null ? void 0 : callbacks.onStart) == null ? void 0 : _a.call(callbacks));
       const wrappedController = createCallbackController(controller);
       controller.enqueue({ type: "start" });
@@ -732,6 +835,8 @@ function toUIMessageStream(stream, callbacks) {
           if (streamType === null) {
             if (Array.isArray(value)) {
               streamType = "langgraph";
+            } else if (isStreamEventsEvent(value)) {
+              streamType = "streamEvents";
             } else {
               streamType = "model";
             }
@@ -742,6 +847,12 @@ function toUIMessageStream(stream, callbacks) {
               modelState,
               wrappedController
             );
+          } else if (streamType === "streamEvents") {
+            processStreamEventsEvent(
+              value,
+              modelState,
+              wrappedController
+            );
           } else {
             processLangGraphEvent(
               value,
@@ -750,19 +861,22 @@ function toUIMessageStream(stream, callbacks) {
             );
           }
         }
-        if (streamType === "model") {
+        if (streamType === "model" || streamType === "streamEvents") {
           if (modelState.reasoningStarted) {
             controller.enqueue({
               type: "reasoning-end",
-              id: modelState.messageId
+              id: (_b = modelState.reasoningMessageId) != null ? _b : modelState.messageId
             });
           }
           if (modelState.textStarted) {
-            controller.enqueue({ type: "text-end", id: modelState.messageId });
+            controller.enqueue({
+              type: "text-end",
+              id: (_c = modelState.textMessageId) != null ? _c : modelState.messageId
+            });
           }
           controller.enqueue({ type: "finish" });
         }
-        await ((_b = callbacks == null ? void 0 : callbacks.onFinal) == null ? void 0 : _b.call(callbacks, textChunks.join("")));
+        await ((_d = callbacks == null ? void 0 : callbacks.onFinal) == null ? void 0 : _d.call(callbacks, textChunks.join("")));
       } catch (error) {
         controller.enqueue({
           type: "error",