@ai-sdk/langchain 3.0.0-beta.18 → 3.0.0-beta.180

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@ai-sdk/langchain",
-  "version": "3.0.0-beta.18",
+  "version": "3.0.0-beta.180",
+  "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",
-  "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
   "files": [
     "dist/**/*",
@@ -20,20 +20,20 @@
     "./package.json": "./package.json",
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.js"
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
     }
   },
   "dependencies": {
-    "ai": "7.0.0-beta.18"
+    "ai": "7.0.0-beta.180"
   },
   "devDependencies": {
-    "@langchain/core": "^1.1.5",
-    "@langchain/langgraph": "^1.0.5",
-    "@types/node": "20.17.24",
-    "tsup": "^8",
+    "@langchain/core": "^1.1.46",
+    "@langchain/langgraph": "^1.3.0",
+    "@types/node": "22.19.19",
+    "tsup": "^8.5.1",
     "typescript": "5.8.3",
-    "@ai-sdk/provider-utils": "5.0.0-beta.2",
+    "@ai-sdk/provider-utils": "5.0.0-beta.49",
     "@vercel/ai-tsconfig": "0.0.0"
   },
   "peerDependencies": {
@@ -46,15 +46,17 @@
     }
   },
   "engines": {
-    "node": ">=18"
+    "node": ">=22"
   },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "provenance": true
   },
   "homepage": "https://ai-sdk.dev/docs",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/vercel/ai.git"
+    "url": "https://github.com/vercel/ai",
+    "directory": "packages/langchain"
   },
   "bugs": {
     "url": "https://github.com/vercel/ai/issues"
@@ -66,9 +68,7 @@
     "build": "pnpm clean && tsup --tsconfig tsconfig.build.json",
     "build:watch": "pnpm clean && tsup --watch",
     "clean": "del-cli dist *.tsbuildinfo",
-    "lint": "eslint \"./**/*.ts*\"",
     "type-check": "tsc --build",
-    "prettier-check": "prettier --check \"./**/*.ts*\"",
     "test": "pnpm test:node && pnpm test:edge",
     "test:update": "pnpm test:node -u",
     "test:watch": "vitest --config vitest.node.config.js",

package/src/adapter.ts

@@ -1,12 +1,12 @@
 import {
   SystemMessage,
-  BaseMessage,
-  AIMessageChunk,
+  type BaseMessage,
+  type AIMessageChunk,
 } from '@langchain/core/messages';
 import {
+  convertToModelMessages,
   type UIMessage,
   type UIMessageChunk,
-  convertToModelMessages,
   type ModelMessage,
 } from 'ai';
 import {
@@ -18,9 +18,11 @@ import {
   parseLangGraphEvent,
   isToolResultPart,
   extractReasoningFromContentBlocks,
+  extractCitationsFromContentBlocks,
+  emitSourceChunks,
 } from './utils';
-import { type LangGraphEventState } from './types';
-import { type StreamCallbacks } from './stream-callbacks';
+import type { LangGraphEventState } from './types';
+import type { StreamCallbacks } from './stream-callbacks';
 
 /**
  * Converts AI SDK UIMessages to LangChain BaseMessage objects.
@@ -132,6 +134,7 @@ function processStreamEventsEvent(
     textStarted: boolean;
     textMessageId: string | null;
     reasoningMessageId: string | null;
+    emittedSourceIds: Set<string>;
   },
   controller: ReadableStreamDefaultController<UIMessageChunk>,
 ): void {
@@ -150,8 +153,41 @@ function processStreamEventsEvent(
   switch (event.event) {
     case 'on_chat_model_start': {
       /**
-       * Handle model start - capture message metadata if available
-       * run_id is at event level in v2, but check data for backwards compatibility
+       * End the previous model turn's reasoning stream before a new LLM invocation.
+       * Without this, reasoning-delta chunks from the next turn could attach to the
+       * wrong reasoning part in the UI message stream.
+       */
+      if (state.reasoningStarted) {
+        controller.enqueue({
+          type: 'reasoning-end',
+          id:
+            state.reasoningMessageId != null
+              ? state.reasoningMessageId
+              : state.messageId,
+        });
+        state.reasoningStarted = false;
+        state.reasoningMessageId = null;
+      }
+
+      /**
+       * End the previous model turn's text stream before a new LLM invocation.
+       * The streamEvents adapter otherwise leaves `textStarted` true, so all later
+       * text-delta chunks append to the first text part — tools still grow the parts
+       * array, which breaks chronological order in the assistant message.
+       */
+      if (state.textStarted) {
+        controller.enqueue({
+          type: 'text-end',
+          id:
+            state.textMessageId != null ? state.textMessageId : state.messageId,
+        });
+        state.textStarted = false;
+        state.textMessageId = null;
+      }
+
+      /**
+       * Handle model start — capture message metadata if available.
+       * `run_id` is on the event in streamEvents v2; fall back to `data` for compatibility.
        */
       const runId = event.run_id || (event.data.run_id as string | undefined);
       if (runId) {
@@ -241,6 +277,16 @@ function processStreamEventsEvent(
             id: state.textMessageId ?? state.messageId,
           });
         }
+
+        const citations = extractCitationsFromContentBlocks(chunk);
+        if (citations.length > 0) {
+          emitSourceChunks(
+            citations,
+            state.messageId,
+            state.emittedSourceIds,
+            controller,
+          );
+        }
       }
       break;
     }
@@ -378,27 +424,24 @@ export function toUIMessageStream<TState = unknown>(
     textMessageId: null as string | null,
     /** Track the ID used for reasoning-start to ensure reasoning-end uses the same ID */
     reasoningMessageId: null as string | null,
+    emittedSourceIds: new Set<string>(),
   };
 
   /**
    * State for LangGraph stream handling
    */
   const langGraphState: LangGraphEventState = {
-    messageSeen: {} as Record<
-      string,
-      { text?: boolean; reasoning?: boolean; tool?: Record<string, boolean> }
-    >,
-    messageConcat: {} as Record<string, AIMessageChunk>,
+    messageSeen: new Map(),
+    messageConcat: new Map(),
     emittedToolCalls: new Set<string>(),
+    emittedToolInputs: new Set<string>(),
     emittedImages: new Set<string>(),
     emittedReasoningIds: new Set<string>(),
-    messageReasoningIds: {} as Record<string, string>,
-    toolCallInfoByIndex: {} as Record<
-      string,
-      Record<number, { id: string; name: string }>
-    >,
+    messageReasoningIds: new Map(),
+    toolCallInfoByIndex: new Map(),
     currentStep: null as number | null,
     emittedToolCallsByKey: new Map<string, string>(),
+    emittedSourceIds: new Set<string>(),
   };
 
   /**
@@ -535,6 +578,20 @@ export function toUIMessageStream<TState = unknown>(
           }
           controller.enqueue({ type: 'finish' });
         } else if (streamType === 'langgraph') {
+          /**
+           * Close any open text/reasoning parts before finishing.
+           * This handles streams without values events (e.g. streamMode: 'messages')
+           * where the values handler never ran to emit *-end events.
+           */
+          for (const [id, seen] of langGraphState.messageSeen) {
+            if (seen.text) {
+              controller.enqueue({ type: 'text-end', id });
+            }
+            if (seen.reasoning) {
+              controller.enqueue({ type: 'reasoning-end', id });
+            }
+          }
+
           /**
            * Emit finish-step if a step was started
            */

package/src/transport.ts

@@ -1,9 +1,9 @@
-import { AIMessageChunk } from '@langchain/core/messages';
-import {
-  type UIMessage,
-  type UIMessageChunk,
-  type ChatTransport,
-  type ChatRequestOptions,
+import type { AIMessageChunk } from '@langchain/core/messages';
+import type {
+  UIMessage,
+  UIMessageChunk,
+  ChatTransport,
+  ChatRequestOptions,
 } from 'ai';
 import {
   RemoteGraph,
@@ -45,9 +45,9 @@ export type LangSmithDeploymentTransportOptions = Omit<
  * });
  * ```
  */
-export class LangSmithDeploymentTransport<UI_MESSAGE extends UIMessage>
-  implements ChatTransport<UI_MESSAGE>
-{
+export class LangSmithDeploymentTransport<
+  UI_MESSAGE extends UIMessage,
+> implements ChatTransport<UI_MESSAGE> {
   protected graph: RemoteGraph;
 
   constructor(options: LangSmithDeploymentTransportOptions) {

package/src/types.ts

@@ -1,33 +1,49 @@
-import { type AIMessageChunk } from '@langchain/core/messages';
+import type { AIMessageChunk } from '@langchain/core/messages';
+
+export interface LangGraphMessageSeen {
+  text?: boolean;
+  reasoning?: boolean;
+  tool?: Set<string>;
+}
 
 /**
  * State for LangGraph event processing
  */
 export interface LangGraphEventState {
   /** Tracks which message IDs have been seen */
-  messageSeen: Record<
-    string,
-    { text?: boolean; reasoning?: boolean; tool?: Record<string, boolean> }
-  >;
+  messageSeen: Map<string, LangGraphMessageSeen>;
   /** Accumulates message chunks for later reference */
-  messageConcat: Record<string, AIMessageChunk>;
-  /** Maps tool call IDs to their message IDs (for chunks that don't include the ID) */
+  messageConcat: Map<string, AIMessageChunk>;
+  /** Tracks which tool call IDs have emitted tool-input-start */
   emittedToolCalls: Set<string>;
+  /** Tracks which tool call IDs have emitted complete tool inputs */
+  emittedToolInputs: 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) */
   emittedReasoningIds: Set<string>;
   /** Maps message IDs to their reasoning block IDs (for chunks that don't include the ID) */
-  messageReasoningIds: Record<string, string>;
+  messageReasoningIds: Map<string, string>;
   /** Maps message ID + tool call index to tool call info (for streaming chunks without ID) */
-  toolCallInfoByIndex: Record<
-    string,
-    Record<number, { id: string; name: string }>
-  >;
+  toolCallInfoByIndex: Map<string, Map<number, { id: string; name: string }>>;
   /** Tracks the current LangGraph step for start-step/finish-step events */
   currentStep: number | 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 */
+  emittedSourceIds: Set<string>;
+}
+
+/**
+ * A LangChain citation projected to the fields the AI SDK source parts can carry.
+ */
+export interface NormalizedCitation {
+  url?: string;
+  title?: string;
+  source?: string;
+  citedText?: string;
+  startIndex?: number;
+  endIndex?: number;
 }
 
 /**