@ai-sdk/langchain 3.0.66 → 3.0.68

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @ai-sdk/langchain
 
+## 3.0.68
+
+### Patch Changes
+
+- ai@7.0.68
+
+## 3.0.67
+
+### Patch Changes
+
+- 404a9d9: Preserve tool input lifecycles when LangGraph steps reuse a provider tool call ID.
+  - ai@7.0.67
+
 ## 3.0.66
 
 ### Patch Changes

package/dist/index.js

@@ -636,6 +636,51 @@ 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 hasEmittedToolInputInCurrentStep(state, toolCallId, namespace) {
+  var _a;
+  return !state.currentStepsByNamespace.has(namespace) ? state.emittedToolInputs.has(toolCallId) : ((_a = state.emittedToolInputsInCurrentStepByNamespace.get(namespace)) == null ? void 0 : _a.has(toolCallId)) === true;
+}
+function markToolInputEmitted(state, toolCallId, namespace) {
+  state.emittedToolInputs.add(toolCallId);
+  if (state.currentStepsByNamespace.has(namespace)) {
+    getOrCreateNamespaceSet(
+      state.emittedToolInputsInCurrentStepByNamespace,
+      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) {
@@ -662,7 +707,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,
@@ -671,11 +716,11 @@ function processLangGraphEvent(event, state, controller) {
     emittedReasoningIds,
     messageReasoningIds,
     toolCallInfoByIndex,
-    emittedToolCallsByKey,
-    emittedToolInputs
+    emittedToolCallsByKey
   } = 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": {
@@ -707,25 +752,55 @@ 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()
+          );
+          state.emittedToolInputsInCurrentStepByNamespace.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.emittedToolInputsInCurrentStepByNamespace.set(
+            eventNamespace,
+            /* @__PURE__ */ new Set()
+          );
         }
-        state.currentStep = langgraphStep;
+      }
+      if (state.currentStepsByNamespace.has(eventNamespace)) {
+        getOrCreateNamespaceSet(
+          state.messageIdsInCurrentStepByNamespace,
+          eventNamespace
+        ).add(msgId);
       }
       if (isAIMessageChunkInstance(msg)) {
         const existingMessage = messageConcat.get(msgId);
@@ -758,29 +833,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 toolCallIndex = (_a = toolCallChunk.index) != null ? _a : 0;
+            const toolCallIndex = (_b = toolCallChunk.index) != null ? _b : 0;
             if (toolCallChunk.id) {
               getOrCreateToolCallInfoByIndex(toolCallInfoByIndex, msgId).set(
                 toolCallIndex,
                 {
                   id: toolCallChunk.id,
-                  name: toolCallChunk.name || ((_c = (_b = concatChunk == null ? void 0 : concatChunk.tool_call_chunks) == null ? void 0 : _b[toolCallIndex]) == null ? void 0 : _c.name) || "unknown"
+                  name: toolCallChunk.name || ((_d = (_c = concatChunk == null ? void 0 : concatChunk.tool_call_chunks) == null ? void 0 : _c[toolCallIndex]) == null ? void 0 : _d.name) || "unknown"
                 }
               );
             }
-            const storedToolCallInfo = (_d = toolCallInfoByIndex.get(msgId)) == null ? void 0 : _d.get(toolCallIndex);
-            const toolCallId = toolCallChunk.id || (storedToolCallInfo == null ? void 0 : storedToolCallInfo.id) || ((_f = (_e = concatChunk == null ? void 0 : concatChunk.tool_call_chunks) == null ? void 0 : _e[toolCallIndex]) == null ? void 0 : _f.id);
+            const storedToolCallInfo = (_e = toolCallInfoByIndex.get(msgId)) == null ? void 0 : _e.get(toolCallIndex);
+            const toolCallId = toolCallChunk.id || (storedToolCallInfo == null ? void 0 : storedToolCallInfo.id) || ((_g = (_f = concatChunk == null ? void 0 : concatChunk.tool_call_chunks) == null ? void 0 : _f[toolCallIndex]) == 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[toolCallIndex]) == 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[toolCallIndex]) == 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,
@@ -808,7 +887,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 });
@@ -878,9 +957,14 @@ function processLangGraphEvent(event, state, controller) {
       const toolCallId = typeof payload.toolCallId === "string" ? payload.toolCallId : void 0;
       const toolName = typeof payload.name === "string" ? payload.name : "unknown";
       if (!toolCallId) return;
-      const ensureToolInputLifecycle = () => {
-        if (!emittedToolCalls.has(toolCallId)) {
-          emittedToolCalls.add(toolCallId);
+      const ensureToolInputLifecycle = ({
+        allowPreviousStep
+      }) => {
+        if (!hasEmittedToolCallInCurrentStep(state, toolCallId, eventNamespace)) {
+          if (allowPreviousStep && emittedToolCalls.has(toolCallId)) {
+            return;
+          }
+          markToolCallEmitted(state, toolCallId, eventNamespace);
           controller.enqueue({
             type: "tool-input-start",
             toolCallId,
@@ -888,8 +972,8 @@ function processLangGraphEvent(event, state, controller) {
             dynamic: true
           });
         }
-        if (!emittedToolInputs.has(toolCallId)) {
-          emittedToolInputs.add(toolCallId);
+        if (!hasEmittedToolInputInCurrentStep(state, toolCallId, eventNamespace)) {
+          markToolInputEmitted(state, toolCallId, eventNamespace);
           controller.enqueue({
             type: "tool-input-available",
             toolCallId,
@@ -903,11 +987,11 @@ function processLangGraphEvent(event, state, controller) {
         case "on_tool_start": {
           const toolCallKey = `${toolName}:${JSON.stringify(payload.input)}`;
           emittedToolCallsByKey.set(toolCallKey, toolCallId);
-          ensureToolInputLifecycle();
+          ensureToolInputLifecycle({ allowPreviousStep: false });
           break;
         }
         case "on_tool_event": {
-          ensureToolInputLifecycle();
+          ensureToolInputLifecycle({ allowPreviousStep: true });
           controller.enqueue({
             type: "tool-output-available",
             toolCallId,
@@ -917,7 +1001,7 @@ function processLangGraphEvent(event, state, controller) {
           break;
         }
         case "on_tool_end": {
-          ensureToolInputLifecycle();
+          ensureToolInputLifecycle({ allowPreviousStep: true });
           controller.enqueue({
             type: "tool-output-available",
             toolCallId,
@@ -926,7 +1010,7 @@ function processLangGraphEvent(event, state, controller) {
           break;
         }
         case "on_tool_error": {
-          ensureToolInputLifecycle();
+          ensureToolInputLifecycle({ allowPreviousStep: true });
           controller.enqueue({
             type: "tool-output-error",
             toolCallId,
@@ -939,19 +1023,26 @@ 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);
-              if (!emittedToolInputs.has(toolCallId)) {
-                emittedToolInputs.add(toolCallId);
+              if (!hasEmittedToolInputInCurrentStep(
+                state,
+                toolCallId,
+                messageNamespace
+              )) {
+                markToolInputEmitted(state, toolCallId, messageNamespace);
                 controller.enqueue({
                   type: "tool-input-available",
                   toolCallId,
@@ -1028,8 +1119,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({
@@ -1038,7 +1139,7 @@ function processLangGraphEvent(event, state, controller) {
                     toolName: toolCall.name,
                     dynamic: true
                   });
-                  emittedToolInputs.add(toolCall.id);
+                  markToolInputEmitted(state, toolCall.id, lifecycleNamespace);
                   controller.enqueue({
                     type: "tool-input-available",
                     toolCallId: toolCall.id,
@@ -1095,7 +1196,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",
@@ -1103,7 +1204,7 @@ function processLangGraphEvent(event, state, controller) {
                   toolName,
                   dynamic: true
                 });
-                emittedToolInputs.add(toolCallId);
+                markToolInputEmitted(state, toolCallId, eventNamespace);
                 controller.enqueue({
                   type: "tool-input-available",
                   toolCallId,
@@ -1308,14 +1409,16 @@ function toUIMessageStream(stream, options) {
     messageSeen: /* @__PURE__ */ new Map(),
     messageNamespaces: /* @__PURE__ */ new Map(),
     messageConcat: /* @__PURE__ */ new Map(),
+    messageIdsInCurrentStepByNamespace: /* @__PURE__ */ new Map(),
     emittedToolCalls: /* @__PURE__ */ new Set(),
+    emittedToolCallsInCurrentStepByNamespace: /* @__PURE__ */ new Map(),
     emittedToolInputs: /* @__PURE__ */ new Set(),
+    emittedToolInputsInCurrentStepByNamespace: /* @__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()
   };
@@ -1435,7 +1538,7 @@ function toUIMessageStream(stream, options) {
               });
             }
           }
-          if (langGraphState.currentStep !== null) {
+          if (langGraphState.currentStepsByNamespace.size > 0) {
             controller.enqueue({ type: "finish-step" });
           }
           if (sendFinish) {