@ai-sdk/langchain 2.0.301 → 2.0.303

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/langchain",
-  "version": "2.0.301",
+  "version": "2.0.303",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -25,7 +25,7 @@
     }
   },
   "dependencies": {
-    "ai": "6.0.293"
+    "ai": "6.0.295"
   },
   "devDependencies": {
     "@langchain/core": "^1.1.5",
@@ -33,7 +33,7 @@
     "@types/node": "20.17.24",
     "tsup": "^8",
     "typescript": "5.8.3",
-    "@ai-sdk/provider-utils": "4.0.55",
+    "@ai-sdk/provider-utils": "4.0.56",
     "@vercel/ai-tsconfig": "0.0.0"
   },
   "peerDependencies": {

package/src/adapter.ts

@@ -438,6 +438,7 @@ export function toUIMessageStream<TState = unknown>(
     messageIdsInCurrentStepByNamespace: new Map(),
     emittedToolCalls: new Set<string>(),
     emittedToolCallsInCurrentStepByNamespace: new Map(),
+    unfinishedToolCallsByNamespace: new Map(),
     emittedImages: new Set<string>(),
     emittedReasoningIds: new Set<string>(),
     messageReasoningIds: new Map(),

package/src/types.ts

@@ -22,6 +22,8 @@ export interface LangGraphEventState {
   emittedToolCalls: Set<string>;
   /** Tracks tool-input-start chunks emitted in each namespace's current step */
   emittedToolCallsInCurrentStepByNamespace: Map<string, Set<string>>;
+  /** Tracks tool calls still awaiting a terminal output in each namespace */
+  unfinishedToolCallsByNamespace: 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) */

package/src/utils.ts

@@ -1211,6 +1211,27 @@ function markToolCallEmitted(
   }
 }
 
+function markToolCallStarted(
+  state: LangGraphEventState,
+  toolCallId: string,
+  namespace: string,
+): void {
+  markToolCallEmitted(state, toolCallId, namespace);
+  getOrCreateNamespaceSet(state.unfinishedToolCallsByNamespace, namespace).add(
+    toolCallId,
+  );
+}
+
+function hasUnfinishedToolCall(
+  state: LangGraphEventState,
+  toolCallId: string,
+  namespace: string,
+): boolean {
+  return (
+    state.unfinishedToolCallsByNamespace.get(namespace)?.has(toolCallId) ===
+    true
+  );
+}
 function findMessageCurrentStepNamespace(
   state: LangGraphEventState,
   messageId: string,
@@ -1353,6 +1374,7 @@ export function processLangGraphEvent(
        * active UI text/reasoning part, so omit it when another namespace is
        * still active.
        */
+      let startedUIReducerStep = false;
       const langgraphStep =
         typeof metadata?.langgraph_step === 'number'
           ? metadata.langgraph_step
@@ -1363,6 +1385,7 @@ export function processLangGraphEvent(
         if (currentStep === null) {
           if (state.currentStepsByNamespace.size === 0) {
             controller.enqueue({ type: 'start-step' });
+            startedUIReducerStep = true;
           }
           state.currentStepsByNamespace.set(eventNamespace, langgraphStep);
           state.messageIdsInCurrentStepByNamespace.set(
@@ -1390,6 +1413,7 @@ export function processLangGraphEvent(
            * scope while the concurrent message lifecycle remains active.
            */
           controller.enqueue({ type: 'start-step' });
+          startedUIReducerStep = true;
           state.currentStepsByNamespace.set(eventNamespace, langgraphStep);
           state.messageIdsInCurrentStepByNamespace.set(
             eventNamespace,
@@ -1536,7 +1560,7 @@ export function processLangGraphEvent(
                   eventNamespace,
                 )
               ) {
-                markToolCallEmitted(state, toolCallId, eventNamespace);
+                markToolCallStarted(state, toolCallId, eventNamespace);
                 controller.enqueue({
                   type: 'tool-input-start',
                   toolCallId: toolCallId,
@@ -1650,6 +1674,48 @@ export function processLangGraphEvent(
         const status = dataSource.status as string | undefined;
 
         if (toolCallId) {
+          const wasEmittedInCurrentStep = hasEmittedToolCallInCurrentStep(
+            state,
+            toolCallId,
+            eventNamespace,
+          );
+          const isDelayedOutputForPreviousLifecycle =
+            !wasEmittedInCurrentStep &&
+            hasUnfinishedToolCall(state, toolCallId, eventNamespace);
+
+          if (
+            !wasEmittedInCurrentStep &&
+            !isDelayedOutputForPreviousLifecycle
+          ) {
+            /**
+             * A newly observed namespace does not normally start another global
+             * reducer step while another namespace is active. Reused provider
+             * IDs need a distinct reducer scope, however, or the new output
+             * overwrites the prior namespace's tool part.
+             */
+            if (
+              !startedUIReducerStep &&
+              state.currentStepsByNamespace.has(eventNamespace) &&
+              emittedToolCalls.has(toolCallId)
+            ) {
+              controller.enqueue({ type: 'start-step' });
+            }
+
+            markToolCallStarted(state, toolCallId, eventNamespace);
+            controller.enqueue({
+              type: 'tool-input-start',
+              toolCallId,
+              toolName:
+                typeof dataSource.name === 'string'
+                  ? dataSource.name
+                  : 'unknown',
+              dynamic: true,
+            });
+          }
+
+          state.unfinishedToolCallsByNamespace
+            .get(eventNamespace)
+            ?.delete(toolCallId);
           if (status === 'error') {
             // Tool execution failed
             controller.enqueue({
@@ -1861,7 +1927,7 @@ export function processLangGraphEvent(
                     (!emittedToolCalls.has(toolCall.id) &&
                       !completedToolCallIds.has(toolCall.id)))
                 ) {
-                  markToolCallEmitted(state, toolCall.id, lifecycleNamespace);
+                  markToolCallStarted(state, toolCall.id, lifecycleNamespace);
                   // Store mapping for HITL interrupt lookup
                   const toolCallKey = `${toolCall.name}:${JSON.stringify(toolCall.args)}`;
                   emittedToolCallsByKey.set(toolCallKey, toolCall.id);
@@ -2001,7 +2067,7 @@ export function processLangGraphEvent(
                * so the UI knows what tool is being called with proper lifecycle
                */
               if (!emittedToolCalls.has(toolCallId)) {
-                markToolCallEmitted(state, toolCallId, eventNamespace);
+                markToolCallStarted(state, toolCallId, eventNamespace);
                 emittedToolCallsByKey.set(toolCallKey, toolCallId);
                 controller.enqueue({
                   type: 'tool-input-start',