@ai-sdk/langchain 2.0.267 → 2.0.269

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @ai-sdk/langchain
 
+## 2.0.269
+
+### Patch Changes
+
+- Updated dependencies [f1afbf9]
+  - ai@6.0.261
+
+## 2.0.268
+
+### Patch Changes
+
+- 5b63247: Preserve tool input lifecycles when LangGraph steps reuse a provider tool call ID.
+- Updated dependencies [98c656f]
+- Updated dependencies [b253d52]
+- Updated dependencies [9e15cb4]
+  - ai@6.0.260
+
 ## 2.0.267
 
 ### Patch Changes

package/dist/index.js

@@ -615,6 +615,38 @@ function getOrCreateToolCallInfoByIndex(toolCallInfoByIndex, msgId) {
 function getLangGraphNamespaceKey(namespace) {
   return JSON.stringify(namespace != null ? namespace : []);
 }
+function getOrCreateNamespaceSet(setsByNamespace, namespace) {
+  let values = setsByNamespace.get(namespace);
+  if (!values) {
+    values = /* @__PURE__ */ new Set();
+    setsByNamespace.set(namespace, values);
+  }
+  return values;
+}
+function hasEmittedToolCallInCurrentStep(state, toolCallId, namespace) {
+  var _a;
+  return !state.currentStepsByNamespace.has(namespace) ? state.emittedToolCalls.has(toolCallId) : ((_a = state.emittedToolCallsInCurrentStepByNamespace.get(namespace)) == null ? void 0 : _a.has(toolCallId)) === true;
+}
+function markToolCallEmitted(state, toolCallId, namespace) {
+  state.emittedToolCalls.add(toolCallId);
+  if (state.currentStepsByNamespace.has(namespace)) {
+    getOrCreateNamespaceSet(
+      state.emittedToolCallsInCurrentStepByNamespace,
+      namespace
+    ).add(toolCallId);
+  }
+}
+function findMessageCurrentStepNamespace(state, messageId) {
+  for (const [
+    namespace,
+    messageIds
+  ] of state.messageIdsInCurrentStepByNamespace) {
+    if (messageIds.has(messageId)) {
+      return namespace;
+    }
+  }
+  return void 0;
+}
 function closeStepNamespaceMessages(state, stepNamespace, controller) {
   let hasConcurrentMessageParts = false;
   for (const [id, seen] of state.messageSeen) {
@@ -641,7 +673,7 @@ function closeStepNamespaceMessages(state, stepNamespace, controller) {
   return hasConcurrentMessageParts;
 }
 function processLangGraphEvent(event, state, controller) {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
   const {
     messageSeen,
     messageConcat,
@@ -654,6 +686,7 @@ function processLangGraphEvent(event, state, controller) {
   } = state;
   const [rawNamespace, type, data] = parseLangGraphEvent(event);
   const namespace = Array.isArray(rawNamespace) && rawNamespace.every((segment) => typeof segment === "string") ? rawNamespace : void 0;
+  const eventNamespace = getLangGraphNamespaceKey(namespace);
   controller = createLangGraphNamespaceController(controller, state, namespace);
   switch (type) {
     case "custom": {
@@ -685,25 +718,47 @@ function processLangGraphEvent(event, state, controller) {
         state.messageNamespaces.set(msgId, namespace);
       }
       const langgraphStep = typeof (metadata == null ? void 0 : metadata.langgraph_step) === "number" ? metadata.langgraph_step : null;
-      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) {
+      if (langgraphStep !== null) {
+        const currentStep = (_a = state.currentStepsByNamespace.get(eventNamespace)) != null ? _a : null;
+        if (currentStep === null) {
+          if (state.currentStepsByNamespace.size === 0) {
+            controller.enqueue({ type: "start-step" });
+          }
+          state.currentStepsByNamespace.set(eventNamespace, langgraphStep);
+          state.messageIdsInCurrentStepByNamespace.set(
+            eventNamespace,
+            /* @__PURE__ */ new Set()
+          );
+          state.emittedToolCallsInCurrentStepByNamespace.set(
+            eventNamespace,
+            /* @__PURE__ */ new Set()
+          );
+        } else if (langgraphStep !== currentStep) {
           const hasConcurrentMessageParts = closeStepNamespaceMessages(
             state,
-            state.stepNamespace,
+            eventNamespace,
             controller
           );
           if (!hasConcurrentMessageParts) {
             controller.enqueue({ type: "finish-step" });
-            controller.enqueue({ type: "start-step" });
           }
-        } else {
           controller.enqueue({ type: "start-step" });
+          state.currentStepsByNamespace.set(eventNamespace, langgraphStep);
+          state.messageIdsInCurrentStepByNamespace.set(
+            eventNamespace,
+            /* @__PURE__ */ new Set()
+          );
+          state.emittedToolCallsInCurrentStepByNamespace.set(
+            eventNamespace,
+            /* @__PURE__ */ new Set()
+          );
         }
-        state.currentStep = langgraphStep;
+      }
+      if (state.currentStepsByNamespace.has(eventNamespace)) {
+        getOrCreateNamespaceSet(
+          state.messageIdsInCurrentStepByNamespace,
+          eventNamespace
+        ).add(msgId);
       }
       if (import_messages.AIMessageChunk.isInstance(msg)) {
         const existingMessage = messageConcat.get(msgId);
@@ -736,29 +791,33 @@ function processLangGraphEvent(event, state, controller) {
         const toolCallChunks = dataSource.tool_call_chunks;
         if (toolCallChunks == null ? void 0 : toolCallChunks.length) {
           for (const toolCallChunk of toolCallChunks) {
-            const idx = (_a = toolCallChunk.index) != null ? _a : 0;
+            const idx = (_b = toolCallChunk.index) != null ? _b : 0;
             if (toolCallChunk.id) {
               getOrCreateToolCallInfoByIndex(toolCallInfoByIndex, msgId).set(
                 idx,
                 {
                   id: toolCallChunk.id,
-                  name: toolCallChunk.name || ((_c = (_b = concatChunk == null ? void 0 : concatChunk.tool_call_chunks) == null ? void 0 : _b[idx]) == null ? void 0 : _c.name) || "unknown"
+                  name: toolCallChunk.name || ((_d = (_c = concatChunk == null ? void 0 : concatChunk.tool_call_chunks) == null ? void 0 : _c[idx]) == null ? void 0 : _d.name) || "unknown"
                 }
               );
             }
-            const storedToolCallInfo = (_d = toolCallInfoByIndex.get(msgId)) == null ? void 0 : _d.get(idx);
-            const toolCallId = toolCallChunk.id || (storedToolCallInfo == null ? void 0 : storedToolCallInfo.id) || ((_f = (_e = concatChunk == null ? void 0 : concatChunk.tool_call_chunks) == null ? void 0 : _e[idx]) == null ? void 0 : _f.id);
+            const storedToolCallInfo = (_e = toolCallInfoByIndex.get(msgId)) == null ? void 0 : _e.get(idx);
+            const toolCallId = toolCallChunk.id || (storedToolCallInfo == null ? void 0 : storedToolCallInfo.id) || ((_g = (_f = concatChunk == null ? void 0 : concatChunk.tool_call_chunks) == null ? void 0 : _f[idx]) == null ? void 0 : _g.id);
             if (!toolCallId) {
               continue;
             }
-            const toolName = toolCallChunk.name || (storedToolCallInfo == null ? void 0 : storedToolCallInfo.name) || ((_h = (_g = concatChunk == null ? void 0 : concatChunk.tool_call_chunks) == null ? void 0 : _g[idx]) == null ? void 0 : _h.name) || "unknown";
+            const toolName = toolCallChunk.name || (storedToolCallInfo == null ? void 0 : storedToolCallInfo.name) || ((_i = (_h = concatChunk == null ? void 0 : concatChunk.tool_call_chunks) == null ? void 0 : _h[idx]) == null ? void 0 : _i.name) || "unknown";
             const seen = messageSeen.get(msgId);
-            if (!((_i = seen == null ? void 0 : seen.tool) == null ? void 0 : _i.has(toolCallId))) {
+            if (!((_j = seen == null ? void 0 : seen.tool) == null ? void 0 : _j.has(toolCallId))) {
               const updatedSeen = getOrCreateMessageSeen(messageSeen, msgId);
-              (_j = updatedSeen.tool) != null ? _j : updatedSeen.tool = /* @__PURE__ */ new Set();
+              (_k = updatedSeen.tool) != null ? _k : updatedSeen.tool = /* @__PURE__ */ new Set();
               updatedSeen.tool.add(toolCallId);
-              if (!emittedToolCalls.has(toolCallId)) {
-                emittedToolCalls.add(toolCallId);
+              if (!hasEmittedToolCallInCurrentStep(
+                state,
+                toolCallId,
+                eventNamespace
+              )) {
+                markToolCallEmitted(state, toolCallId, eventNamespace);
                 controller.enqueue({
                   type: "tool-input-start",
                   toolCallId,
@@ -786,7 +845,7 @@ function processLangGraphEvent(event, state, controller) {
         }
         const reasoning = extractReasoningFromContentBlocks(msg);
         if (reasoning) {
-          const reasoningId = (_l = (_k = messageReasoningIds.get(msgId)) != null ? _k : chunkReasoningId) != null ? _l : msgId;
+          const reasoningId = (_m = (_l = messageReasoningIds.get(msgId)) != null ? _l : chunkReasoningId) != null ? _m : msgId;
           const seen = messageSeen.get(msgId);
           if (!(seen == null ? void 0 : seen.reasoning)) {
             controller.enqueue({ type: "reasoning-start", id: msgId });
@@ -850,15 +909,18 @@ function processLangGraphEvent(event, state, controller) {
     }
     case "values": {
       for (const [id, seen] of messageSeen) {
+        const messageNamespace = getLangGraphNamespaceKey(
+          state.messageNamespaces.get(id)
+        );
         if (seen.text) controller.enqueue({ type: "text-end", id });
         if (seen.tool) {
           for (const toolCallId of seen.tool) {
             const concatMsg = messageConcat.get(id);
-            const toolCall = (_m = concatMsg == null ? void 0 : concatMsg.tool_calls) == null ? void 0 : _m.find(
+            const toolCall = (_n = concatMsg == null ? void 0 : concatMsg.tool_calls) == null ? void 0 : _n.find(
               (call) => call.id === toolCallId
             );
             if (toolCall) {
-              emittedToolCalls.add(toolCallId);
+              markToolCallEmitted(state, toolCallId, messageNamespace);
               const toolCallKey = `${toolCall.name}:${JSON.stringify(toolCall.args)}`;
               emittedToolCallsByKey.set(toolCallKey, toolCallId);
               controller.enqueue({
@@ -936,8 +998,18 @@ function processLangGraphEvent(event, state, controller) {
             }
             if (toolCalls && toolCalls.length > 0) {
               for (const toolCall of toolCalls) {
-                if (toolCall.id && !emittedToolCalls.has(toolCall.id) && !completedToolCallIds.has(toolCall.id)) {
-                  emittedToolCalls.add(toolCall.id);
+                const messageNamespace = findMessageCurrentStepNamespace(
+                  state,
+                  msgId
+                );
+                const lifecycleNamespace = messageNamespace != null ? messageNamespace : eventNamespace;
+                const wasObservedInCurrentStep = messageNamespace !== void 0;
+                if (toolCall.id && !hasEmittedToolCallInCurrentStep(
+                  state,
+                  toolCall.id,
+                  lifecycleNamespace
+                ) && (wasObservedInCurrentStep || !emittedToolCalls.has(toolCall.id) && !completedToolCallIds.has(toolCall.id))) {
+                  markToolCallEmitted(state, toolCall.id, lifecycleNamespace);
                   const toolCallKey = `${toolCall.name}:${JSON.stringify(toolCall.args)}`;
                   emittedToolCallsByKey.set(toolCallKey, toolCall.id);
                   controller.enqueue({
@@ -1002,7 +1074,7 @@ function processLangGraphEvent(event, state, controller) {
               const toolCallKey = `${toolName}:${JSON.stringify(input)}`;
               const toolCallId = emittedToolCallsByKey.get(toolCallKey) || actionRequest.id || `hitl-${toolName}-${Date.now()}`;
               if (!emittedToolCalls.has(toolCallId)) {
-                emittedToolCalls.add(toolCallId);
+                markToolCallEmitted(state, toolCallId, eventNamespace);
                 emittedToolCallsByKey.set(toolCallKey, toolCallId);
                 controller.enqueue({
                   type: "tool-input-start",
@@ -1213,13 +1285,14 @@ function toUIMessageStream(stream, callbacks) {
     messageSeen: /* @__PURE__ */ new Map(),
     messageNamespaces: /* @__PURE__ */ new Map(),
     messageConcat: /* @__PURE__ */ new Map(),
+    messageIdsInCurrentStepByNamespace: /* @__PURE__ */ new Map(),
     emittedToolCalls: /* @__PURE__ */ new Set(),
+    emittedToolCallsInCurrentStepByNamespace: /* @__PURE__ */ new Map(),
     emittedImages: /* @__PURE__ */ new Set(),
     emittedReasoningIds: /* @__PURE__ */ new Set(),
     messageReasoningIds: /* @__PURE__ */ new Map(),
     toolCallInfoByIndex: /* @__PURE__ */ new Map(),
-    currentStep: null,
-    stepNamespace: null,
+    currentStepsByNamespace: /* @__PURE__ */ new Map(),
     emittedToolCallsByKey: /* @__PURE__ */ new Map(),
     emittedSourceIds: /* @__PURE__ */ new Set()
   };
@@ -1333,7 +1406,7 @@ function toUIMessageStream(stream, callbacks) {
               });
             }
           }
-          if (langGraphState.currentStep !== null) {
+          if (langGraphState.currentStepsByNamespace.size > 0) {
             controller.enqueue({ type: "finish-step" });
           }
           controller.enqueue({ type: "finish" });