@ai-sdk/langchain 0.0.0-70e0935a-20260114150030 → 0.0.0-98261322-20260122142521

package/src/stream-callbacks.test.ts

@@ -0,0 +1,196 @@
+import {
+  createCallbacksTransformer,
+  StreamCallbacks,
+} from './stream-callbacks';
+import { describe, it, expect, vi } from 'vitest';
+
+describe('createCallbacksTransformer', () => {
+  async function processStream(
+    input: string[],
+    callbacks?: StreamCallbacks,
+  ): Promise<string[]> {
+    const transformer = createCallbacksTransformer(callbacks);
+    const readable = new ReadableStream({
+      start(controller) {
+        for (const chunk of input) {
+          controller.enqueue(chunk);
+        }
+        controller.close();
+      },
+    });
+
+    const output: string[] = [];
+    const writable = new WritableStream({
+      write(chunk) {
+        output.push(chunk);
+      },
+    });
+
+    await readable.pipeThrough(transformer).pipeTo(writable);
+    return output;
+  }
+
+  it('should pass through messages without callbacks', async () => {
+    const input = ['Hello', ' ', 'World'];
+    const output = await processStream(input);
+
+    expect(output).toEqual(input);
+  });
+
+  it('should pass through messages with empty callbacks object', async () => {
+    const input = ['Hello', ' ', 'World'];
+    const output = await processStream(input, {});
+
+    expect(output).toEqual(input);
+  });
+
+  it('should call onStart once at the beginning', async () => {
+    const onStart = vi.fn();
+    const input = ['Hello', ' ', 'World'];
+
+    await processStream(input, { onStart });
+
+    expect(onStart).toHaveBeenCalledTimes(1);
+  });
+
+  it('should call async onStart', async () => {
+    const onStart = vi.fn().mockResolvedValue(undefined);
+    const input = ['Hello'];
+
+    await processStream(input, { onStart });
+
+    expect(onStart).toHaveBeenCalledTimes(1);
+  });
+
+  it('should call onToken for each message', async () => {
+    const onToken = vi.fn();
+    const input = ['Hello', ' ', 'World'];
+
+    await processStream(input, { onToken });
+
+    expect(onToken).toHaveBeenCalledTimes(3);
+    expect(onToken).toHaveBeenNthCalledWith(1, 'Hello');
+    expect(onToken).toHaveBeenNthCalledWith(2, ' ');
+    expect(onToken).toHaveBeenNthCalledWith(3, 'World');
+  });
+
+  it('should call async onToken', async () => {
+    const onToken = vi.fn().mockResolvedValue(undefined);
+    const input = ['Hello', 'World'];
+
+    await processStream(input, { onToken });
+
+    expect(onToken).toHaveBeenCalledTimes(2);
+  });
+
+  it('should call onText for each string message', async () => {
+    const onText = vi.fn();
+    const input = ['Hello', ' ', 'World'];
+
+    await processStream(input, { onText });
+
+    expect(onText).toHaveBeenCalledTimes(3);
+    expect(onText).toHaveBeenNthCalledWith(1, 'Hello');
+    expect(onText).toHaveBeenNthCalledWith(2, ' ');
+    expect(onText).toHaveBeenNthCalledWith(3, 'World');
+  });
+
+  it('should call async onText', async () => {
+    const onText = vi.fn().mockResolvedValue(undefined);
+    const input = ['Hello'];
+
+    await processStream(input, { onText });
+
+    expect(onText).toHaveBeenCalledTimes(1);
+  });
+
+  it('should call onFinal with aggregated response', async () => {
+    const onFinal = vi.fn();
+    const input = ['Hello', ' ', 'World'];
+
+    await processStream(input, { onFinal });
+
+    expect(onFinal).toHaveBeenCalledTimes(1);
+    expect(onFinal).toHaveBeenCalledWith('Hello World');
+  });
+
+  it('should call async onFinal', async () => {
+    const onFinal = vi.fn().mockResolvedValue(undefined);
+    const input = ['Hello', 'World'];
+
+    await processStream(input, { onFinal });
+
+    expect(onFinal).toHaveBeenCalledTimes(1);
+    expect(onFinal).toHaveBeenCalledWith('HelloWorld');
+  });
+
+  it('should call onFinal with empty string when no messages', async () => {
+    const onFinal = vi.fn();
+    const input: string[] = [];
+
+    await processStream(input, { onFinal });
+
+    expect(onFinal).toHaveBeenCalledTimes(1);
+    expect(onFinal).toHaveBeenCalledWith('');
+  });
+
+  it('should call all callbacks in correct order', async () => {
+    const callOrder: string[] = [];
+
+    const callbacks: StreamCallbacks = {
+      onStart: () => {
+        callOrder.push('start');
+      },
+      onToken: token => {
+        callOrder.push(`token:${token}`);
+      },
+      onText: text => {
+        callOrder.push(`text:${text}`);
+      },
+      onFinal: completion => {
+        callOrder.push(`final:${completion}`);
+      },
+    };
+
+    const input = ['A', 'B'];
+    await processStream(input, callbacks);
+
+    expect(callOrder).toEqual([
+      'start',
+      'token:A',
+      'text:A',
+      'token:B',
+      'text:B',
+      'final:AB',
+    ]);
+  });
+
+  it('should handle single character messages', async () => {
+    const onToken = vi.fn();
+    const onFinal = vi.fn();
+    const input = ['a', 'b', 'c'];
+
+    await processStream(input, { onToken, onFinal });
+
+    expect(onToken).toHaveBeenCalledTimes(3);
+    expect(onFinal).toHaveBeenCalledWith('abc');
+  });
+
+  it('should handle messages with special characters', async () => {
+    const onFinal = vi.fn();
+    const input = ['Hello\n', 'World\t', '!'];
+
+    await processStream(input, { onFinal });
+
+    expect(onFinal).toHaveBeenCalledWith('Hello\nWorld\t!');
+  });
+
+  it('should handle unicode characters', async () => {
+    const onFinal = vi.fn();
+    const input = ['こんにちは', ' ', '🌍'];
+
+    await processStream(input, { onFinal });
+
+    expect(onFinal).toHaveBeenCalledWith('こんにちは 🌍');
+  });
+});

package/src/stream-callbacks.ts

@@ -0,0 +1,65 @@
+/**
+ * Configuration options and helper callback methods for stream lifecycle events.
+ */
+export interface StreamCallbacks {
+  /** `onStart`: Called once when the stream is initialized. */
+  onStart?: () => Promise<void> | void;
+
+  /** `onFinal`: Called once when the stream is closed with the final completion message. */
+  onFinal?: (completion: string) => Promise<void> | void;
+
+  /** `onToken`: Called for each tokenized message. */
+  onToken?: (token: string) => Promise<void> | void;
+
+  /** `onText`: Called for each text chunk. */
+  onText?: (text: string) => Promise<void> | void;
+}
+
+/**
+ * Creates a transform stream that encodes input messages and invokes optional callback functions.
+ * The transform stream uses the provided callbacks to execute custom logic at different stages of the stream's lifecycle.
+ * - `onStart`: Called once when the stream is initialized.
+ * - `onToken`: Called for each tokenized message.
+ * - `onFinal`: Called once when the stream is closed with the final completion message.
+ *
+ * This function is useful when you want to process a stream of messages and perform specific actions during the stream's lifecycle.
+ *
+ * @param {StreamCallbacks} [callbacks] - An object containing the callback functions.
+ * @return {TransformStream<string, string>} A transform stream that allows the execution of custom logic through callbacks.
+ *
+ * @example
+ * const callbacks = {
+ *   onStart: async () => console.log('Stream started'),
+ *   onToken: async (token) => console.log(`Token: ${token}`),
+ *   onFinal: async () => data.close()
+ * };
+ * const transformer = createCallbacksTransformer(callbacks);
+ */
+export function createCallbacksTransformer(
+  callbacks: StreamCallbacks | undefined = {},
+): TransformStream<string, string> {
+  let aggregatedResponse = '';
+
+  return new TransformStream({
+    async start(): Promise<void> {
+      if (callbacks.onStart) await callbacks.onStart();
+    },
+
+    async transform(message, controller): Promise<void> {
+      controller.enqueue(message);
+
+      aggregatedResponse += message;
+
+      if (callbacks.onToken) await callbacks.onToken(message);
+      if (callbacks.onText && typeof message === 'string') {
+        await callbacks.onText(message);
+      }
+    },
+
+    async flush(): Promise<void> {
+      if (callbacks.onFinal) {
+        await callbacks.onFinal(aggregatedResponse);
+      }
+    },
+  });
+}

package/src/transport.test.ts

@@ -0,0 +1,41 @@
+import { LangSmithDeploymentTransport } from './transport';
+import { describe, it, expect } from 'vitest';
+
+describe('LangSmithDeploymentTransport', () => {
+  it('should create transport with options', () => {
+    const transport = new LangSmithDeploymentTransport({
+      url: 'https://test.langsmith.app',
+      apiKey: 'test-key',
+    });
+
+    expect('sendMessages' in transport).toBe(true);
+    expect('reconnectToStream' in transport).toBe(true);
+  });
+
+  it('should create transport with only url', () => {
+    const transport = new LangSmithDeploymentTransport({
+      url: 'https://test.langsmith.app',
+    });
+
+    expect('sendMessages' in transport).toBe(true);
+  });
+
+  it('should create transport with custom graphId', () => {
+    const transport = new LangSmithDeploymentTransport({
+      url: 'https://test.langsmith.app',
+      graphId: 'custom-agent',
+    });
+
+    expect('sendMessages' in transport).toBe(true);
+  });
+
+  it('should throw error for reconnectToStream', async () => {
+    const transport = new LangSmithDeploymentTransport({
+      url: 'https://test.langsmith.app',
+    });
+
+    await expect(
+      transport.reconnectToStream({ chatId: 'chat-1' }),
+    ).rejects.toThrow('Method not implemented.');
+  });
+});

package/src/transport.ts

@@ -0,0 +1,88 @@
+import { AIMessageChunk } from '@langchain/core/messages';
+import {
+  type UIMessage,
+  type UIMessageChunk,
+  type ChatTransport,
+  type ChatRequestOptions,
+} from 'ai';
+import {
+  RemoteGraph,
+  type RemoteGraphParams,
+} from '@langchain/langgraph/remote';
+import { toBaseMessages, toUIMessageStream } from './adapter';
+
+/**
+ * Options for configuring a LangSmith deployment transport.
+ * Extends RemoteGraphParams but makes graphId optional (defaults to 'agent').
+ */
+export type LangSmithDeploymentTransportOptions = Omit<
+  RemoteGraphParams,
+  'graphId'
+> & {
+  /**
+   * The ID of the graph to connect to.
+   * @default 'agent'
+   */
+  graphId?: string;
+};
+
+/**
+ * A ChatTransport implementation for LangSmith/LangGraph deployments.
+ *
+ * This transport enables seamless integration between the AI SDK's useChat hook
+ * and LangSmith deployed LangGraph agents.
+ *
+ * @example
+ * ```ts
+ * import { LangSmithDeploymentTransport } from '@ai-sdk/langchain';
+ *
+ * // Use with useChat
+ * const { messages, input, handleSubmit } = useChat({
+ *   transport: new LangSmithDeploymentTransport({
+ *     url: 'https://your-deployment.us.langgraph.app',
+ *     apiKey: 'my-api-key',
+ *   }),
+ * });
+ * ```
+ */
+export class LangSmithDeploymentTransport<UI_MESSAGE extends UIMessage>
+  implements ChatTransport<UI_MESSAGE>
+{
+  protected graph: RemoteGraph;
+
+  constructor(options: LangSmithDeploymentTransportOptions) {
+    this.graph = new RemoteGraph({
+      ...options,
+      graphId: options.graphId ?? 'agent',
+    });
+  }
+
+  async sendMessages(
+    options: {
+      trigger: 'submit-message' | 'regenerate-message';
+      chatId: string;
+      messageId: string | undefined;
+      messages: UI_MESSAGE[];
+      abortSignal: AbortSignal | undefined;
+    } & ChatRequestOptions,
+  ): Promise<ReadableStream<UIMessageChunk>> {
+    const baseMessages = await toBaseMessages(options.messages);
+
+    const stream = await this.graph.stream(
+      { messages: baseMessages },
+      { streamMode: ['values', 'messages'] },
+    );
+
+    return toUIMessageStream(
+      stream as AsyncIterable<AIMessageChunk> | ReadableStream,
+    );
+  }
+
+  async reconnectToStream(
+    _options: {
+      chatId: string;
+    } & ChatRequestOptions,
+  ): Promise<ReadableStream<UIMessageChunk> | null> {
+    throw new Error('Method not implemented.');
+  }
+}

package/src/types.ts

@@ -0,0 +1,75 @@
+import { type AIMessageChunk } from '@langchain/core/messages';
+
+/**
+ * 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> }
+  >;
+  /** 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) */
+  emittedToolCalls: 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>;
+  /** Maps message ID + tool call index to tool call info (for streaming chunks without ID) */
+  toolCallInfoByIndex: Record<
+    string,
+    Record<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>;
+}
+
+/**
+ * Type for reasoning content block from LangChain
+ */
+export interface ReasoningContentBlock {
+  type: 'reasoning';
+  reasoning: string;
+}
+
+/**
+ * Type for thinking content block from LangChain (Anthropic-style)
+ */
+export interface ThinkingContentBlock {
+  type: 'thinking';
+  thinking: string;
+  signature?: string;
+}
+
+/**
+ * Type for GPT-5 reasoning output block
+ */
+export interface GPT5ReasoningOutput {
+  id: string;
+  type: 'reasoning';
+  summary: {
+    type: 'summary_text';
+    text: string;
+  }[];
+}
+
+/**
+ * Type for image generation tool outputs from LangChain/OpenAI
+ */
+export interface ImageGenerationOutput {
+  id: string;
+  type: 'image_generation_call';
+  status: string;
+  result?: string; // base64 image data
+  revised_prompt?: string;
+  size?: string;
+  output_format?: string;
+  quality?: string;
+  background?: string;
+}