@ai-sdk/langchain 2.0.254 → 2.0.256

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @ai-sdk/langchain
 
+## 2.0.256
+
+### Patch Changes
+
+- 5995d53: Preserve LangGraph subgraph namespaces and step lifecycles without letting concurrent namespace counters split active text or reasoning streams.
+- Updated dependencies [2171d15]
+  - ai@6.0.248
+
+## 2.0.255
+
+### Patch Changes
+
+- ai@6.0.247
+
 ## 2.0.254
 
 ### Patch Changes

package/dist/index.js

@@ -34,7 +34,77 @@ var import_ai = require("ai");
 // src/utils.ts
 var import_messages = require("@langchain/core/messages");
 function parseLangGraphEvent(event) {
-  return event.length === 3 ? [event[1], event[2]] : [event[0], event[1]];
+  return event.length === 3 ? [event[0], event[1], event[2]] : [void 0, event[0], event[1]];
+}
+function getLangGraphProviderMetadata(namespace) {
+  return namespace === void 0 ? void 0 : {
+    langchain: {
+      namespace
+    }
+  };
+}
+function addLangGraphNamespace(chunk, namespace) {
+  var _a;
+  if (namespace === void 0) {
+    return chunk;
+  }
+  switch (chunk.type) {
+    case "text-start":
+    case "text-delta":
+    case "text-end":
+    case "reasoning-start":
+    case "reasoning-delta":
+    case "reasoning-end":
+    case "tool-input-start":
+    case "tool-input-available":
+    case "tool-input-error":
+    case "tool-output-available":
+    case "tool-output-error":
+    case "source-url":
+    case "source-document":
+    case "file": {
+      return {
+        ...chunk,
+        providerMetadata: {
+          ...chunk.providerMetadata,
+          langchain: {
+            ...(_a = chunk.providerMetadata) == null ? void 0 : _a.langchain,
+            namespace
+          }
+        }
+      };
+    }
+    default:
+      return chunk;
+  }
+}
+function createLangGraphNamespaceController(controller, state, eventNamespace) {
+  return {
+    get desiredSize() {
+      return controller.desiredSize;
+    },
+    close: () => controller.close(),
+    error: (reason) => controller.error(reason),
+    enqueue: (chunk) => {
+      if (chunk === void 0) {
+        return;
+      }
+      let messageNamespace;
+      switch (chunk.type) {
+        case "text-start":
+        case "text-delta":
+        case "text-end":
+        case "reasoning-start":
+        case "reasoning-delta":
+        case "reasoning-end":
+          messageNamespace = state.messageNamespaces.get(chunk.id);
+          break;
+      }
+      controller.enqueue(
+        addLangGraphNamespace(chunk, messageNamespace != null ? messageNamespace : eventNamespace)
+      );
+    }
+  };
 }
 function convertToolResultPart(block) {
   const content = (() => {
@@ -542,6 +612,34 @@ function getOrCreateToolCallInfoByIndex(toolCallInfoByIndex, msgId) {
   }
   return toolCallInfo;
 }
+function getLangGraphNamespaceKey(namespace) {
+  return JSON.stringify(namespace != null ? namespace : []);
+}
+function closeStepNamespaceMessages(state, stepNamespace, controller) {
+  let hasConcurrentMessageParts = false;
+  for (const [id, seen] of state.messageSeen) {
+    const messageNamespace = getLangGraphNamespaceKey(
+      state.messageNamespaces.get(id)
+    );
+    if (messageNamespace !== stepNamespace) {
+      if (seen.text || seen.reasoning) {
+        hasConcurrentMessageParts = true;
+      }
+      continue;
+    }
+    if (seen.text) {
+      controller.enqueue({ type: "text-end", id });
+    }
+    if (seen.reasoning) {
+      controller.enqueue({ type: "reasoning-end", id });
+    }
+    state.messageSeen.delete(id);
+    state.messageNamespaces.delete(id);
+    state.messageConcat.delete(id);
+    state.messageReasoningIds.delete(id);
+  }
+  return hasConcurrentMessageParts;
+}
 function processLangGraphEvent(event, state, controller) {
   var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
   const {
@@ -554,7 +652,9 @@ function processLangGraphEvent(event, state, controller) {
     toolCallInfoByIndex,
     emittedToolCallsByKey
   } = state;
-  const [type, data] = parseLangGraphEvent(event);
+  const [rawNamespace, type, data] = parseLangGraphEvent(event);
+  const namespace = Array.isArray(rawNamespace) && rawNamespace.every((segment) => typeof segment === "string") ? rawNamespace : void 0;
+  controller = createLangGraphNamespaceController(controller, state, namespace);
   switch (type) {
     case "custom": {
       let customTypeName = "custom";
@@ -581,23 +681,28 @@ function processLangGraphEvent(event, state, controller) {
       const msg = rawMsg;
       const msgId = getMessageId(msg);
       if (!msgId) return;
+      if (namespace !== void 0) {
+        state.messageNamespaces.set(msgId, namespace);
+      }
       const langgraphStep = typeof (metadata == null ? void 0 : metadata.langgraph_step) === "number" ? metadata.langgraph_step : null;
-      if (langgraphStep !== null && langgraphStep !== state.currentStep) {
+      const eventNamespace = getLangGraphNamespaceKey(namespace);
+      if (langgraphStep !== null && state.stepNamespace === null) {
+        state.stepNamespace = eventNamespace;
+      }
+      if (langgraphStep !== null && eventNamespace === state.stepNamespace && langgraphStep !== state.currentStep) {
         if (state.currentStep !== null) {
-          for (const [id, seen] of messageSeen) {
-            if (seen.text) {
-              controller.enqueue({ type: "text-end", id });
-            }
-            if (seen.reasoning) {
-              controller.enqueue({ type: "reasoning-end", id });
-            }
-            messageSeen.delete(id);
-            messageConcat.delete(id);
-            messageReasoningIds.delete(id);
+          const hasConcurrentMessageParts = closeStepNamespaceMessages(
+            state,
+            state.stepNamespace,
+            controller
+          );
+          if (!hasConcurrentMessageParts) {
+            controller.enqueue({ type: "finish-step" });
+            controller.enqueue({ type: "start-step" });
           }
-          controller.enqueue({ type: "finish-step" });
+        } else {
+          controller.enqueue({ type: "start-step" });
         }
-        controller.enqueue({ type: "start-step" });
         state.currentStep = langgraphStep;
       }
       if (import_messages.AIMessageChunk.isInstance(msg)) {
@@ -770,6 +875,7 @@ function processLangGraphEvent(event, state, controller) {
           controller.enqueue({ type: "reasoning-end", id });
         }
         messageSeen.delete(id);
+        state.messageNamespaces.delete(id);
         messageConcat.delete(id);
         messageReasoningIds.delete(id);
       }
@@ -1105,6 +1211,7 @@ function toUIMessageStream(stream, callbacks) {
   };
   const langGraphState = {
     messageSeen: /* @__PURE__ */ new Map(),
+    messageNamespaces: /* @__PURE__ */ new Map(),
     messageConcat: /* @__PURE__ */ new Map(),
     emittedToolCalls: /* @__PURE__ */ new Set(),
     emittedImages: /* @__PURE__ */ new Set(),
@@ -1112,6 +1219,7 @@ function toUIMessageStream(stream, callbacks) {
     messageReasoningIds: /* @__PURE__ */ new Map(),
     toolCallInfoByIndex: /* @__PURE__ */ new Map(),
     currentStep: null,
+    stepNamespace: null,
     emittedToolCallsByKey: /* @__PURE__ */ new Map(),
     emittedSourceIds: /* @__PURE__ */ new Set()
   };
@@ -1180,7 +1288,7 @@ function toUIMessageStream(stream, callbacks) {
             );
           } else {
             const eventArray = value;
-            const [type, data] = parseLangGraphEvent(eventArray);
+            const [, type, data] = parseLangGraphEvent(eventArray);
             if (type === "values") {
               lastValuesData = data;
             }
@@ -1207,11 +1315,22 @@ function toUIMessageStream(stream, callbacks) {
           controller.enqueue({ type: "finish" });
         } else if (streamType === "langgraph") {
           for (const [id, seen] of langGraphState.messageSeen) {
+            const providerMetadata = getLangGraphProviderMetadata(
+              langGraphState.messageNamespaces.get(id)
+            );
             if (seen.text) {
-              controller.enqueue({ type: "text-end", id });
+              controller.enqueue({
+                type: "text-end",
+                id,
+                ...providerMetadata !== void 0 && { providerMetadata }
+              });
             }
             if (seen.reasoning) {
-              controller.enqueue({ type: "reasoning-end", id });
+              controller.enqueue({
+                type: "reasoning-end",
+                id,
+                ...providerMetadata !== void 0 && { providerMetadata }
+              });
             }
           }
           if (langGraphState.currentStep !== null) {