@ai-sdk/langchain 3.0.65 → 3.0.67

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/langchain",
-  "version": "3.0.65",
+  "version": "3.0.67",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -25,7 +25,7 @@
     }
   },
   "dependencies": {
-    "ai": "7.0.65"
+    "ai": "7.0.67"
   },
   "devDependencies": {
     "@langchain/core": "^1.1.46",

package/src/adapter.ts

@@ -458,14 +458,16 @@ export function toUIMessageStream<TState = unknown>(
     messageSeen: new Map(),
     messageNamespaces: new Map(),
     messageConcat: new Map(),
+    messageIdsInCurrentStepByNamespace: new Map(),
     emittedToolCalls: new Set<string>(),
+    emittedToolCallsInCurrentStepByNamespace: new Map(),
     emittedToolInputs: new Set<string>(),
+    emittedToolInputsInCurrentStepByNamespace: new Map(),
     emittedImages: new Set<string>(),
     emittedReasoningIds: new Set<string>(),
     messageReasoningIds: new Map(),
     toolCallInfoByIndex: new Map(),
-    currentStep: null as number | null,
-    stepNamespace: null,
+    currentStepsByNamespace: new Map(),
     emittedToolCallsByKey: new Map<string, string>(),
     emittedSourceIds: new Set<string>(),
   };
@@ -638,7 +640,7 @@ export function toUIMessageStream<TState = unknown>(
           /**
            * Emit finish-step if a step was started
            */
-          if (langGraphState.currentStep !== null) {
+          if (langGraphState.currentStepsByNamespace.size > 0) {
             controller.enqueue({ type: 'finish-step' });
           }
           if (sendFinish) {

package/src/types.ts

@@ -16,10 +16,16 @@ export interface LangGraphEventState {
   messageNamespaces: Map<string, string[]>;
   /** Accumulates message chunks for later reference */
   messageConcat: Map<string, AIMessageChunk>;
+  /** Tracks message IDs observed in each namespace's current LangGraph step */
+  messageIdsInCurrentStepByNamespace: Map<string, Set<string>>;
   /** Tracks which tool call IDs have emitted tool-input-start */
   emittedToolCalls: Set<string>;
+  /** Tracks tool-input-start chunks emitted in each namespace's current step */
+  emittedToolCallsInCurrentStepByNamespace: Map<string, Set<string>>;
   /** Tracks which tool call IDs have emitted complete tool inputs */
   emittedToolInputs: Set<string>;
+  /** Tracks complete tool inputs emitted in each namespace's current step */
+  emittedToolInputsInCurrentStepByNamespace: Map<string, Set<string>>;
   /** Maps image IDs to their message IDs (for chunks that don't include the ID) */
   emittedImages: Set<string>;
   /** Maps reasoning block IDs to their message IDs (for chunks that don't include the ID) */
@@ -28,10 +34,8 @@ export interface LangGraphEventState {
   messageReasoningIds: Map<string, string>;
   /** Maps message ID + tool call index to tool call info (for streaming chunks without ID) */
   toolCallInfoByIndex: Map<string, Map<number, { id: string; name: string }>>;
-  /** Tracks the current LangGraph step for start-step/finish-step events */
-  currentStep: number | null;
-  /** Namespace whose step counter drives the global UI step lifecycle */
-  stepNamespace: string | null;
+  /** Tracks each namespace's current LangGraph step */
+  currentStepsByNamespace: Map<string, number>;
   /** Maps tool call key (name:argsJson) to tool call ID for HITL interrupt handling */
   emittedToolCallsByKey: Map<string, string>;
   /** Tracks source IDs already emitted to avoid duplicates across messages/values events */

package/src/utils.ts

@@ -1252,10 +1252,89 @@ function getLangGraphNamespaceKey(namespace: string[] | undefined): string {
   return JSON.stringify(namespace ?? []);
 }
 
+function getOrCreateNamespaceSet(
+  setsByNamespace: Map<string, Set<string>>,
+  namespace: string,
+): Set<string> {
+  let values = setsByNamespace.get(namespace);
+  if (!values) {
+    values = new Set();
+    setsByNamespace.set(namespace, values);
+  }
+  return values;
+}
+
+function hasEmittedToolCallInCurrentStep(
+  state: LangGraphEventState,
+  toolCallId: string,
+  namespace: string,
+): boolean {
+  return !state.currentStepsByNamespace.has(namespace)
+    ? state.emittedToolCalls.has(toolCallId)
+    : state.emittedToolCallsInCurrentStepByNamespace
+        .get(namespace)
+        ?.has(toolCallId) === true;
+}
+
+function markToolCallEmitted(
+  state: LangGraphEventState,
+  toolCallId: string,
+  namespace: string,
+): void {
+  state.emittedToolCalls.add(toolCallId);
+  if (state.currentStepsByNamespace.has(namespace)) {
+    getOrCreateNamespaceSet(
+      state.emittedToolCallsInCurrentStepByNamespace,
+      namespace,
+    ).add(toolCallId);
+  }
+}
+
+function hasEmittedToolInputInCurrentStep(
+  state: LangGraphEventState,
+  toolCallId: string,
+  namespace: string,
+): boolean {
+  return !state.currentStepsByNamespace.has(namespace)
+    ? state.emittedToolInputs.has(toolCallId)
+    : state.emittedToolInputsInCurrentStepByNamespace
+        .get(namespace)
+        ?.has(toolCallId) === true;
+}
+
+function markToolInputEmitted(
+  state: LangGraphEventState,
+  toolCallId: string,
+  namespace: string,
+): void {
+  state.emittedToolInputs.add(toolCallId);
+  if (state.currentStepsByNamespace.has(namespace)) {
+    getOrCreateNamespaceSet(
+      state.emittedToolInputsInCurrentStepByNamespace,
+      namespace,
+    ).add(toolCallId);
+  }
+}
+
+function findMessageCurrentStepNamespace(
+  state: LangGraphEventState,
+  messageId: string,
+): string | undefined {
+  for (const [
+    namespace,
+    messageIds,
+  ] of state.messageIdsInCurrentStepByNamespace) {
+    if (messageIds.has(messageId)) {
+      return namespace;
+    }
+  }
+  return undefined;
+}
+
 /**
- * Ends and clears message state for the namespace that drives the global UI
- * step lifecycle. Returns whether another namespace still has active text or
- * reasoning that would be invalidated by a global finish-step chunk.
+ * Ends and clears message state for an advancing namespace. Returns whether
+ * another namespace still has active text or reasoning that would be
+ * invalidated by a global finish-step chunk.
  */
 function closeStepNamespaceMessages(
   state: LangGraphEventState,
@@ -1312,7 +1391,6 @@ export function processLangGraphEvent(
     messageReasoningIds,
     toolCallInfoByIndex,
     emittedToolCallsByKey,
-    emittedToolInputs,
   } = state;
   const [rawNamespace, type, data] = parseLangGraphEvent(event);
   const namespace =
@@ -1320,6 +1398,7 @@ export function processLangGraphEvent(
     rawNamespace.every(segment => typeof segment === 'string')
       ? rawNamespace
       : undefined;
+  const eventNamespace = getLangGraphNamespaceKey(namespace);
   controller = createLangGraphNamespaceController(controller, state, namespace);
 
   switch (type) {
@@ -1373,41 +1452,73 @@ export function processLangGraphEvent(
       }
 
       /**
-       * The first namespace with a step counter drives the global UI step
-       * lifecycle. This is the root namespace for complete subgraph streams and
-       * the selected namespace for streams filtered to one subgraph.
-       *
-       * Other namespaces have independent counters and must not change this
-       * cursor. A finish-step chunk clears every active UI text/reasoning part,
-       * so suppress the global boundary when another namespace is still active.
+       * Each namespace has an independent LangGraph step counter. Advancing a
+       * namespace starts a new reducer scope so provider-scoped tool call IDs
+       * can be reused in that namespace. A finish-step chunk clears every
+       * active UI text/reasoning part, so omit it when another namespace is
+       * still active.
        */
       const langgraphStep =
         typeof 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 =
+          state.currentStepsByNamespace.get(eventNamespace) ?? null;
+        if (currentStep === null) {
+          if (state.currentStepsByNamespace.size === 0) {
+            controller.enqueue({ type: 'start-step' });
+          }
+          state.currentStepsByNamespace.set(eventNamespace, langgraphStep);
+          state.messageIdsInCurrentStepByNamespace.set(
+            eventNamespace,
+            new Set(),
+          );
+          state.emittedToolCallsInCurrentStepByNamespace.set(
+            eventNamespace,
+            new Set(),
+          );
+          state.emittedToolInputsInCurrentStepByNamespace.set(
+            eventNamespace,
+            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 {
+
+          /**
+           * A concurrent namespace prevents finish-step because it would close
+           * that namespace's active text/reasoning parts. Still emit start-step
+           * so tool calls in the advancing namespace have a distinct reducer
+           * scope while the concurrent message lifecycle remains active.
+           */
           controller.enqueue({ type: 'start-step' });
+          state.currentStepsByNamespace.set(eventNamespace, langgraphStep);
+          state.messageIdsInCurrentStepByNamespace.set(
+            eventNamespace,
+            new Set(),
+          );
+          state.emittedToolCallsInCurrentStepByNamespace.set(
+            eventNamespace,
+            new Set(),
+          );
+          state.emittedToolInputsInCurrentStepByNamespace.set(
+            eventNamespace,
+            new Set(),
+          );
         }
-        state.currentStep = langgraphStep;
+      }
+      if (state.currentStepsByNamespace.has(eventNamespace)) {
+        getOrCreateNamespaceSet(
+          state.messageIdsInCurrentStepByNamespace,
+          eventNamespace,
+        ).add(msgId);
       }
 
       /**
@@ -1533,8 +1644,14 @@ export function processLangGraphEvent(
               updatedSeen.tool ??= 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: toolCallId,
@@ -1693,9 +1810,19 @@ export function processLangGraphEvent(
 
       if (!toolCallId) return;
 
-      const ensureToolInputLifecycle = () => {
-        if (!emittedToolCalls.has(toolCallId)) {
-          emittedToolCalls.add(toolCallId);
+      const ensureToolInputLifecycle = ({
+        allowPreviousStep,
+      }: {
+        allowPreviousStep: boolean;
+      }) => {
+        if (
+          !hasEmittedToolCallInCurrentStep(state, toolCallId, eventNamespace)
+        ) {
+          if (allowPreviousStep && emittedToolCalls.has(toolCallId)) {
+            return;
+          }
+
+          markToolCallEmitted(state, toolCallId, eventNamespace);
           controller.enqueue({
             type: 'tool-input-start',
             toolCallId,
@@ -1704,8 +1831,10 @@ export function processLangGraphEvent(
           });
         }
 
-        if (!emittedToolInputs.has(toolCallId)) {
-          emittedToolInputs.add(toolCallId);
+        if (
+          !hasEmittedToolInputInCurrentStep(state, toolCallId, eventNamespace)
+        ) {
+          markToolInputEmitted(state, toolCallId, eventNamespace);
           controller.enqueue({
             type: 'tool-input-available',
             toolCallId,
@@ -1721,12 +1850,12 @@ export function processLangGraphEvent(
           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,
@@ -1737,7 +1866,7 @@ export function processLangGraphEvent(
         }
 
         case 'on_tool_end': {
-          ensureToolInputLifecycle();
+          ensureToolInputLifecycle({ allowPreviousStep: true });
           controller.enqueue({
             type: 'tool-output-available',
             toolCallId,
@@ -1747,7 +1876,7 @@ export function processLangGraphEvent(
         }
 
         case 'on_tool_error': {
-          ensureToolInputLifecycle();
+          ensureToolInputLifecycle({ allowPreviousStep: true });
           controller.enqueue({
             type: 'tool-output-error',
             toolCallId,
@@ -1765,6 +1894,9 @@ export function processLangGraphEvent(
        * Finalize all pending message chunks
        */
       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) {
@@ -1774,12 +1906,18 @@ export function processLangGraphEvent(
             );
 
             if (toolCall) {
-              emittedToolCalls.add(toolCallId);
+              markToolCallEmitted(state, toolCallId, messageNamespace);
               // Store mapping for HITL interrupt lookup
               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,
@@ -1924,18 +2062,30 @@ export function processLangGraphEvent(
 
             if (toolCalls && toolCalls.length > 0) {
               for (const toolCall of toolCalls) {
+                const messageNamespace = findMessageCurrentStepNamespace(
+                  state,
+                  msgId,
+                );
+                const lifecycleNamespace = messageNamespace ?? eventNamespace;
+                const wasObservedInCurrentStep = messageNamespace !== undefined;
                 /**
-                 * Only emit if we haven't already processed this tool call
-                 * AND if it's not a historical tool call that already has a ToolMessage response.
-                 * Historical completed tool calls should not be re-emitted as this would create
-                 * orphaned tool parts in the UI without corresponding outputs.
+                 * Emit tool calls recovered from a message in the current step,
+                 * even when a prior step used the same provider-scoped ID.
+                 * Otherwise, preserve stream-wide suppression for historical
+                 * completed calls and values-only streams without step metadata.
                  */
                 if (
                   toolCall.id &&
-                  !emittedToolCalls.has(toolCall.id) &&
-                  !completedToolCallIds.has(toolCall.id)
+                  !hasEmittedToolCallInCurrentStep(
+                    state,
+                    toolCall.id,
+                    lifecycleNamespace,
+                  ) &&
+                  (wasObservedInCurrentStep ||
+                    (!emittedToolCalls.has(toolCall.id) &&
+                      !completedToolCallIds.has(toolCall.id)))
                 ) {
-                  emittedToolCalls.add(toolCall.id);
+                  markToolCallEmitted(state, toolCall.id, lifecycleNamespace);
                   // Store mapping for HITL interrupt lookup
                   const toolCallKey = `${toolCall.name}:${JSON.stringify(toolCall.args)}`;
                   emittedToolCallsByKey.set(toolCallKey, toolCall.id);
@@ -1950,7 +2100,7 @@ export function processLangGraphEvent(
                     toolName: toolCall.name,
                     dynamic: true,
                   });
-                  emittedToolInputs.add(toolCall.id);
+                  markToolInputEmitted(state, toolCall.id, lifecycleNamespace);
                   controller.enqueue({
                     type: 'tool-input-available',
                     toolCallId: toolCall.id,
@@ -2076,7 +2226,7 @@ export function processLangGraphEvent(
                * so the UI knows what tool is being called with proper lifecycle
                */
               if (!emittedToolCalls.has(toolCallId)) {
-                emittedToolCalls.add(toolCallId);
+                markToolCallEmitted(state, toolCallId, eventNamespace);
                 emittedToolCallsByKey.set(toolCallKey, toolCallId);
                 controller.enqueue({
                   type: 'tool-input-start',
@@ -2084,7 +2234,7 @@ export function processLangGraphEvent(
                   toolName,
                   dynamic: true,
                 });
-                emittedToolInputs.add(toolCallId);
+                markToolInputEmitted(state, toolCallId, eventNamespace);
                 controller.enqueue({
                   type: 'tool-input-available',
                   toolCallId,