@ai-sdk/langchain 2.0.254 → 2.0.256

package/src/adapter.ts

@@ -20,6 +20,7 @@ import {
   extractReasoningFromContentBlocks,
   extractCitationsFromContentBlocks,
   emitSourceChunks,
+  getLangGraphProviderMetadata,
 } from './utils';
 import { type LangGraphEventState } from './types';
 import { type StreamCallbacks } from './stream-callbacks';
@@ -432,6 +433,7 @@ export function toUIMessageStream<TState = unknown>(
    */
   const langGraphState: LangGraphEventState = {
     messageSeen: new Map(),
+    messageNamespaces: new Map(),
     messageConcat: new Map(),
     emittedToolCalls: new Set<string>(),
     emittedImages: new Set<string>(),
@@ -439,6 +441,7 @@ export function toUIMessageStream<TState = unknown>(
     messageReasoningIds: new Map(),
     toolCallInfoByIndex: new Map(),
     currentStep: null as number | null,
+    stepNamespace: null,
     emittedToolCallsByKey: new Map<string, string>(),
     emittedSourceIds: new Set<string>(),
   };
@@ -542,7 +545,7 @@ export function toUIMessageStream<TState = unknown>(
             );
           } else {
             const eventArray = value as unknown[];
-            const [type, data] = parseLangGraphEvent(eventArray);
+            const [, type, data] = parseLangGraphEvent(eventArray);
 
             if (type === 'values') {
               lastValuesData = data as TState;
@@ -583,11 +586,22 @@ export function toUIMessageStream<TState = unknown>(
            * where the values handler never ran to emit *-end events.
            */
           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 !== undefined && { providerMetadata }),
+              });
             }
             if (seen.reasoning) {
-              controller.enqueue({ type: 'reasoning-end', id });
+              controller.enqueue({
+                type: 'reasoning-end',
+                id,
+                ...(providerMetadata !== undefined && { providerMetadata }),
+              });
             }
           }
 

package/src/types.ts

@@ -12,6 +12,8 @@ export interface LangGraphMessageSeen {
 export interface LangGraphEventState {
   /** Tracks which message IDs have been seen */
   messageSeen: Map<string, LangGraphMessageSeen>;
+  /** Maps message IDs to the LangGraph namespace that emitted them */
+  messageNamespaces: Map<string, string[]>;
   /** Accumulates message chunks for later reference */
   messageConcat: Map<string, AIMessageChunk>;
   /** Tracks which tool call IDs have emitted tool-input-start */
@@ -26,6 +28,8 @@ export interface LangGraphEventState {
   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;
   /** 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

@@ -29,16 +29,104 @@ import {
 } from './types';
 
 /**
- * Parses a LangGraph event tuple into [type, data].
+ * Parses a LangGraph event tuple into [namespace, type, data].
  * Handles both 2-element [type, data] and 3-element [namespace, type, data] formats.
  *
  * @param event - The raw LangGraph event array.
- * @returns A tuple of [type, data].
+ * @returns A tuple of [namespace, type, data].
  */
 export function parseLangGraphEvent(
   event: unknown[],
-): [type: unknown, data: unknown] {
-  return event.length === 3 ? [event[1], event[2]] : [event[0], event[1]];
+): [namespace: unknown | undefined, type: unknown, data: unknown] {
+  return event.length === 3
+    ? [event[0], event[1], event[2]]
+    : [undefined, event[0], event[1]];
+}
+
+export function getLangGraphProviderMetadata(
+  namespace: string[] | undefined,
+): ProviderMetadata | undefined {
+  return namespace === undefined
+    ? undefined
+    : {
+        langchain: {
+          namespace,
+        },
+      };
+}
+
+function addLangGraphNamespace(
+  chunk: UIMessageChunk,
+  namespace: string[] | undefined,
+): UIMessageChunk {
+  if (namespace === undefined) {
+    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: {
+            ...chunk.providerMetadata?.langchain,
+            namespace,
+          },
+        },
+      };
+    }
+    default:
+      return chunk;
+  }
+}
+
+function createLangGraphNamespaceController(
+  controller: ReadableStreamDefaultController<UIMessageChunk>,
+  state: LangGraphEventState,
+  eventNamespace: string[] | undefined,
+): ReadableStreamDefaultController<UIMessageChunk> {
+  return {
+    get desiredSize() {
+      return controller.desiredSize;
+    },
+    close: () => controller.close(),
+    error: reason => controller.error(reason),
+    enqueue: chunk => {
+      if (chunk === undefined) {
+        return;
+      }
+
+      let messageNamespace: string[] | undefined;
+      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 ?? eventNamespace),
+      );
+    },
+  };
 }
 
 /**
@@ -1077,6 +1165,53 @@ function getOrCreateToolCallInfoByIndex(
   return toolCallInfo;
 }
 
+/**
+ * Normalizes legacy tuples without a namespace and explicit empty root
+ * namespaces to the same key.
+ */
+function getLangGraphNamespaceKey(namespace: string[] | undefined): string {
+  return JSON.stringify(namespace ?? []);
+}
+
+/**
+ * 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.
+ */
+function closeStepNamespaceMessages(
+  state: LangGraphEventState,
+  stepNamespace: string,
+  controller: ReadableStreamDefaultController<UIMessageChunk>,
+): boolean {
+  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;
+}
+
 /**
  * Processes a LangGraph event and emits UI message chunks.
  *
@@ -1099,7 +1234,13 @@ export function processLangGraphEvent(
     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
+      : undefined;
+  controller = createLangGraphNamespaceController(controller, state, namespace);
 
   switch (type) {
     case 'custom': {
@@ -1147,32 +1288,45 @@ export function processLangGraphEvent(
 
       if (!msgId) return;
 
+      if (namespace !== undefined) {
+        state.messageNamespaces.set(msgId, namespace);
+      }
+
       /**
-       * Track LangGraph step changes and emit start-step/finish-step events.
-       * Before emitting finish-step, close any open text/reasoning parts so
-       * the client does not receive orphaned deltas after its
-       * activeReasoningParts / activeTextParts have been cleared.
+       * 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.
        */
       const langgraphStep =
         typeof 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;
       }
 
@@ -1470,6 +1624,7 @@ export function processLangGraphEvent(
         }
 
         messageSeen.delete(id);
+        state.messageNamespaces.delete(id);
         messageConcat.delete(id);
         messageReasoningIds.delete(id);
       }