@langgraph-js/sdk 3.6.0 → 3.7.1

package/src/client/utils/sse.ts

@@ -0,0 +1,176 @@
+/** copied from https://github.com/langchain-ai/langgraphjs/tree/main/libs/sdk/src/utils */
+const CR = "\r".charCodeAt(0);
+const LF = "\n".charCodeAt(0);
+const NULL = "\0".charCodeAt(0);
+const COLON = ":".charCodeAt(0);
+const SPACE = " ".charCodeAt(0);
+
+const TRAILING_NEWLINE = [CR, LF];
+
+export function BytesLineDecoder() {
+    let buffer: Uint8Array[] = [];
+    let trailingCr = false;
+
+    return new TransformStream<Uint8Array, Uint8Array>({
+        start() {
+            buffer = [];
+            trailingCr = false;
+        },
+
+        transform(chunk, controller) {
+            // See https://docs.python.org/3/glossary.html#term-universal-newlines
+            let text = chunk;
+
+            // Handle trailing CR from previous chunk
+            if (trailingCr) {
+                text = joinArrays([[CR], text]);
+                trailingCr = false;
+            }
+
+            // Check for trailing CR in current chunk
+            if (text.length > 0 && text.at(-1) === CR) {
+                trailingCr = true;
+                text = text.subarray(0, -1);
+            }
+
+            if (!text.length) return;
+            const trailingNewline = TRAILING_NEWLINE.includes(text.at(-1)!);
+
+            const lastIdx = text.length - 1;
+            const { lines } = text.reduce<{ lines: Uint8Array[]; from: number }>(
+                (acc, cur, idx) => {
+                    if (acc.from > idx) return acc;
+
+                    if (cur === CR || cur === LF) {
+                        acc.lines.push(text.subarray(acc.from, idx));
+                        if (cur === CR && text[idx + 1] === LF) {
+                            acc.from = idx + 2;
+                        } else {
+                            acc.from = idx + 1;
+                        }
+                    }
+
+                    if (idx === lastIdx && acc.from <= lastIdx) {
+                        acc.lines.push(text.subarray(acc.from));
+                    }
+
+                    return acc;
+                },
+                { lines: [], from: 0 }
+            );
+
+            if (lines.length === 1 && !trailingNewline) {
+                buffer.push(lines[0]);
+                return;
+            }
+
+            if (buffer.length) {
+                // Include existing buffer in first line
+                buffer.push(lines[0]);
+                lines[0] = joinArrays(buffer);
+                buffer = [];
+            }
+
+            if (!trailingNewline) {
+                // If the last segment is not newline terminated,
+                // buffer it for the next chunk
+                if (lines.length) buffer = [lines.pop()!];
+            }
+
+            // Enqueue complete lines
+            for (const line of lines) {
+                controller.enqueue(line);
+            }
+        },
+
+        flush(controller) {
+            if (buffer.length) {
+                controller.enqueue(joinArrays(buffer));
+            }
+        },
+    });
+}
+
+interface StreamPart {
+    id: string | undefined;
+    event: string;
+    data: unknown;
+}
+
+export function SSEDecoder() {
+    let event = "";
+    let data: Uint8Array[] = [];
+    let lastEventId = "";
+    let retry: number | null = null;
+
+    const decoder = new TextDecoder();
+
+    return new TransformStream<Uint8Array, StreamPart>({
+        transform(chunk, controller) {
+            // Handle empty line case
+            if (!chunk.length) {
+                if (!event && !data.length && !lastEventId && retry == null) return;
+
+                const sse = {
+                    id: lastEventId || undefined,
+                    event,
+                    data: data.length ? decodeArraysToJson(decoder, data) : null,
+                };
+
+                // NOTE: as per the SSE spec, do not reset lastEventId
+                event = "";
+                data = [];
+                retry = null;
+
+                controller.enqueue(sse);
+                return;
+            }
+
+            // Ignore comments
+            if (chunk[0] === COLON) return;
+
+            const sepIdx = chunk.indexOf(COLON);
+            if (sepIdx === -1) return;
+
+            const fieldName = decoder.decode(chunk.subarray(0, sepIdx));
+            let value = chunk.subarray(sepIdx + 1);
+            if (value[0] === SPACE) value = value.subarray(1);
+
+            if (fieldName === "event") {
+                event = decoder.decode(value);
+            } else if (fieldName === "data") {
+                data.push(value);
+            } else if (fieldName === "id") {
+                if (value.indexOf(NULL) === -1) lastEventId = decoder.decode(value);
+            } else if (fieldName === "retry") {
+                const retryNum = Number.parseInt(decoder.decode(value), 10);
+                if (!Number.isNaN(retryNum)) retry = retryNum;
+            }
+        },
+
+        flush(controller) {
+            if (event) {
+                controller.enqueue({
+                    id: lastEventId || undefined,
+                    event,
+                    data: data.length ? decodeArraysToJson(decoder, data) : null,
+                });
+            }
+        },
+    });
+}
+
+function joinArrays(data: ArrayLike<number>[]) {
+    const totalLength = data.reduce((acc, curr) => acc + curr.length, 0);
+    const merged = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const c of data) {
+        merged.set(c, offset);
+        offset += c.length;
+    }
+    return merged;
+}
+
+function decodeArraysToJson(decoder: TextDecoder, data: ArrayLike<number>[]) {
+    return JSON.parse(decoder.decode(joinArrays(data)));
+}

package/src/client/utils/stream.ts

@@ -0,0 +1,114 @@
+/** copied from https://github.com/langchain-ai/langgraphjs/tree/main/libs/sdk/src/utils */
+// in this case don't quite match.
+type IterableReadableStreamInterface<T> = ReadableStream<T> & AsyncIterable<T>;
+
+/*
+ * Support async iterator syntax for ReadableStreams in all environments.
+ * Source: https://github.com/MattiasBuelens/web-streams-polyfill/pull/122#issuecomment-1627354490
+ */
+export class IterableReadableStream<T> extends ReadableStream<T> implements IterableReadableStreamInterface<T> {
+    /** @ts-ignore */
+    public reader: ReadableStreamDefaultReader<T>;
+
+    ensureReader() {
+        if (!this.reader) {
+            this.reader = this.getReader();
+        }
+    }
+
+    async next(): Promise<IteratorResult<T>> {
+        this.ensureReader();
+        try {
+            const result = await this.reader.read();
+            if (result.done) {
+                this.reader.releaseLock(); // release lock when stream becomes closed
+                return {
+                    done: true,
+                    value: undefined,
+                };
+            } else {
+                return {
+                    done: false,
+                    value: result.value,
+                };
+            }
+        } catch (e) {
+            this.reader.releaseLock(); // release lock when stream becomes errored
+            throw e;
+        }
+    }
+
+    async return(): Promise<IteratorResult<T>> {
+        this.ensureReader();
+        // If wrapped in a Node stream, cancel is already called.
+        if (this.locked) {
+            const cancelPromise = this.reader.cancel(); // cancel first, but don't await yet
+            this.reader.releaseLock(); // release lock first
+            await cancelPromise; // now await it
+        }
+        return { done: true, value: undefined };
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async throw(e: any): Promise<IteratorResult<T>> {
+        this.ensureReader();
+        if (this.locked) {
+            const cancelPromise = this.reader.cancel(); // cancel first, but don't await yet
+            this.reader.releaseLock(); // release lock first
+            await cancelPromise; // now await it
+        }
+        throw e;
+    }
+
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore Not present in Node 18 types, required in latest Node 22
+    async [Symbol.asyncDispose]() {
+        await this.return();
+    }
+
+    [Symbol.asyncIterator]() {
+        return this;
+    }
+
+    static fromReadableStream<T>(stream: ReadableStream<T>) {
+        // From https://developer.mozilla.org/en-US/docs/Web/API/Streams_API/Using_readable_streams#reading_the_stream
+        const reader = stream.getReader();
+        return new IterableReadableStream<T>({
+            start(controller) {
+                return pump();
+                function pump(): Promise<T | undefined> {
+                    return reader.read().then(({ done, value }) => {
+                        // When no more data needs to be consumed, close the stream
+                        if (done) {
+                            controller.close();
+                            return;
+                        }
+                        // Enqueue the next data chunk into our target stream
+                        controller.enqueue(value);
+                        return pump();
+                    });
+                }
+            },
+            cancel() {
+                reader.releaseLock();
+            },
+        });
+    }
+
+    static fromAsyncGenerator<T>(generator: AsyncGenerator<T>) {
+        return new IterableReadableStream<T>({
+            async pull(controller) {
+                const { value, done } = await generator.next();
+                // When no more data needs to be consumed, close the stream
+                if (done) {
+                    controller.close();
+                }
+                // Fix: `else if (value)` will hang the streaming when nullish value (e.g. empty string) is pulled
+                controller.enqueue(value);
+            },
+            async cancel(reason) {
+                await generator.return(reason);
+            },
+        });
+    }
+}

package/src/index.ts

@@ -6,3 +6,4 @@ export * from "./ui-store/index.js";
 export * from "./ToolManager.js";
 export * from "./TestKit.js";
 export * from "./artifacts/index.js";
+export * from "./client/index.js";

package/src/react/ChatContext.ts

@@ -2,6 +2,7 @@ import { createElement, createContext, useContext, useMemo, ReactNode, useEffect
 
 import { createChatStore, UnionStore, useUnionStore } from "../ui-store/index.js";
 import { useStore } from "@nanostores/react";
+import { ILangGraphClient } from "@langgraph-js/pure-graph/dist/types.js";
 
 const ChatContext = createContext<UnionStore<ReturnType<typeof createChatStore>> | undefined>(undefined);
 
@@ -23,6 +24,8 @@ interface ChatProviderProps {
     showGraph?: boolean;
     fallbackToAvailableAssistants?: boolean;
     onInitError?: (error: any, currentAgent: string) => void;
+    client?: ILangGraphClient;
+    legacyMode?: boolean;
 }
 
 export const ChatProvider: React.FC<ChatProviderProps> = ({
@@ -35,6 +38,8 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     showGraph = false,
     fallbackToAvailableAssistants = false,
     onInitError,
+    client,
+    legacyMode = false,
 }) => {
     // 使用 useMemo 稳定 defaultHeaders 的引用
     const stableHeaders = useMemo(() => defaultHeaders || {}, [defaultHeaders]);
@@ -53,22 +58,22 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
               }
             : fetch;
 
-        return createChatStore(
-            defaultAgent,
-            {
-                apiUrl,
-                defaultHeaders: stableHeaders,
-                callerOptions: {
-                    fetch: F,
-                    maxRetries: 1,
-                },
+        const config = {
+            apiUrl,
+            defaultHeaders: stableHeaders,
+            callerOptions: {
+                fetch: F,
+                maxRetries: 1,
             },
-            {
-                showHistory,
-                showGraph,
-                fallbackToAvailableAssistants,
-            }
-        );
+            legacyMode,
+        };
+        /** @ts-ignore */
+        if (client) config.client = client;
+        return createChatStore(defaultAgent, config, {
+            showHistory,
+            showGraph,
+            fallbackToAvailableAssistants,
+        });
     }, [defaultAgent, apiUrl, stableHeaders, withCredentials, showHistory, showGraph, fallbackToAvailableAssistants]);
 
     const unionStore = useUnionStore(store, useStore);

package/src/vue/ChatContext.ts

@@ -2,6 +2,7 @@ import { defineComponent, inject, provide, onMounted, defineExpose, type Injecti
 import { createChatStore } from "../ui-store/index.js";
 import { useStore } from "@nanostores/vue";
 import { PreinitializedWritableAtom, StoreValue } from "nanostores";
+import { ILangGraphClient } from "@langgraph-js/pure-graph/dist/types.js";
 
 /**
  * @zh UnionStore 类型用于合并 store 的 data 和 mutations，使其可以直接访问。
@@ -55,6 +56,8 @@ export interface ChatProviderProps {
     showGraph?: boolean;
     fallbackToAvailableAssistants?: boolean;
     onInitError?: (error: any, currentAgent: string) => void;
+    client?: ILangGraphClient;
+    legacyMode?: boolean;
 }
 
 /**
@@ -78,6 +81,8 @@ export const useChatProvider = (props: ChatProviderProps) => {
                 fetch: F,
                 maxRetries: 1,
             },
+            client: props.client,
+            legacyMode: props.legacyMode,
         },
         {
             showHistory: props.showHistory,

package/test/TestKit.test.ts

@@ -1,14 +1,22 @@
 import { expect, test } from "vitest";
-import { TestLangGraphChat, createChatStore } from "../src";
+import { TestLangGraphChat, createChatStore, createLowerJSClient } from "../src";
 
 test("test", async () => {
+    const client = await createLowerJSClient({
+        apiUrl: "http://localhost:8123",
+        defaultHeaders: {
+            Authorization: "Bearer 123",
+        },
+    });
     const testChat = new TestLangGraphChat(
         createChatStore(
-            "agent",
+            "graph",
             {
                 defaultHeaders: {
                     Authorization: "Bearer 123",
                 },
+                client,
+                legacyMode: true,
             },
             {}
         ),

package/tsconfig.json

@@ -11,7 +11,7 @@
         // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
 
         /* Language and Environment */
-        "target": "ES2019" /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */,
+        "target": "ES2022" /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */,
         // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
         // "jsx": "preserve",                                /* Specify what JSX code is generated. */
         // "experimentalDecorators": true,                   /* Enable experimental support for legacy experimental decorators. */