@langgraph-js/sdk 3.7.0 → 3.7.1

package/dist/client/LowJSServer.d.ts

@@ -0,0 +1,3 @@
+import { LangGraphClientConfig } from "../LangGraphClient.js";
+import { ILangGraphClient } from "@langgraph-js/pure-graph/dist/types.js";
+export declare const createLowerJSClient: (config: Omit<LangGraphClientConfig, "client">) => ILangGraphClient;

package/dist/client/LowJSServer.js

@@ -0,0 +1,80 @@
+import { BytesLineDecoder, SSEDecoder } from "./utils/sse.js";
+const REGEX_RUN_METADATA = /(\/threads\/(?<thread_id>.+))?\/runs\/(?<run_id>.+)/;
+function getRunMetadataFromResponse(response) {
+    const contentLocation = response.headers.get("Content-Location");
+    if (!contentLocation)
+        return void 0;
+    const match = REGEX_RUN_METADATA.exec(contentLocation);
+    if (!match?.groups?.run_id)
+        return void 0;
+    return {
+        run_id: match.groups.run_id,
+        thread_id: match.groups.thread_id || void 0,
+    };
+}
+import { Client } from "@langchain/langgraph-sdk";
+export const createLowerJSClient = (config) => {
+    const client = new Client(config);
+    /** @ts-ignore */
+    client.runs.joinStream = async function (threadId, runId, options) {
+        const opts = typeof options === "object" && options != null && options instanceof AbortSignal ? { signal: options } : options;
+        let [url, init] = this.prepareFetchOptions(threadId != null ? `/threads/${threadId}/runs/${runId}/stream` : `/runs/${runId}/stream`, {
+            method: "GET",
+            timeoutMs: null,
+            signal: opts?.signal,
+            headers: opts?.lastEventId ? { "Last-Event-ID": opts.lastEventId } : void 0,
+            params: {
+                cancel_on_disconnect: opts?.cancelOnDisconnect ? "1" : "0",
+                stream_mode: opts?.streamMode,
+            },
+        });
+        if (this.onRequest != null)
+            init = await this.onRequest(url, init);
+        const response = await this.asyncCaller.fetch(url, init);
+        const stream = (response.body || new ReadableStream({ start: (ctrl) => ctrl.close() })).pipeThrough(BytesLineDecoder()).pipeThrough(SSEDecoder());
+        return stream.pipeTo(new WritableStream({ write: (chunk) => options.onCallback?.(chunk) }));
+    }.bind(client.runs);
+    /** @ts-ignore */
+    client.runs.stream = async function (threadId, assistantId, payload) {
+        const json = {
+            input: payload?.input,
+            command: payload?.command,
+            config: payload?.config,
+            context: payload?.context,
+            metadata: payload?.metadata,
+            stream_mode: payload?.streamMode,
+            stream_subgraphs: payload?.streamSubgraphs,
+            stream_resumable: payload?.streamResumable,
+            feedback_keys: payload?.feedbackKeys,
+            assistant_id: assistantId,
+            interrupt_before: payload?.interruptBefore,
+            interrupt_after: payload?.interruptAfter,
+            checkpoint: payload?.checkpoint,
+            checkpoint_id: payload?.checkpointId,
+            webhook: payload?.webhook,
+            multitask_strategy: payload?.multitaskStrategy,
+            on_completion: payload?.onCompletion,
+            on_disconnect: payload?.onDisconnect,
+            after_seconds: payload?.afterSeconds,
+            if_not_exists: payload?.ifNotExists,
+            checkpoint_during: payload?.checkpointDuring,
+            durability: payload?.durability,
+        };
+        const endpoint = threadId == null ? `/runs/stream` : `/threads/${threadId}/runs/stream`;
+        let [url, init] = this.prepareFetchOptions(endpoint, {
+            method: "POST",
+            json,
+            timeoutMs: null,
+            signal: payload?.signal,
+        });
+        if (this.onRequest != null)
+            init = await this.onRequest(url, init);
+        const response = await this.asyncCaller.fetch(url, init);
+        const runMetadata = getRunMetadataFromResponse(response);
+        if (runMetadata)
+            payload?.onRunCreated?.(runMetadata);
+        const stream = (response.body || new ReadableStream({ start: (ctrl) => ctrl.close() })).pipeThrough(BytesLineDecoder()).pipeThrough(SSEDecoder());
+        return stream.pipeTo(new WritableStream({ write: (chunk) => payload.onCallback?.(chunk) }));
+    }.bind(client.runs);
+    return client;
+};

package/dist/client/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./LanggraphServer.js";
+export * from "./LowJSServer.js";

package/dist/client/index.js

@@ -0,0 +1,2 @@
+export * from "./LanggraphServer.js";
+export * from "./LowJSServer.js";

package/dist/client/utils/sse.d.ts

@@ -0,0 +1,8 @@
+export declare function BytesLineDecoder(): TransformStream<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>;
+interface StreamPart {
+    id: string | undefined;
+    event: string;
+    data: unknown;
+}
+export declare function SSEDecoder(): TransformStream<Uint8Array<ArrayBufferLike>, StreamPart>;
+export {};

package/dist/client/utils/sse.js

@@ -0,0 +1,151 @@
+/** 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 = [];
+    let trailingCr = false;
+    return new TransformStream({
+        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((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));
+            }
+        },
+    });
+}
+export function SSEDecoder() {
+    let event = "";
+    let data = [];
+    let lastEventId = "";
+    let retry = null;
+    const decoder = new TextDecoder();
+    return new TransformStream({
+        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) {
+    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, data) {
+    return JSON.parse(decoder.decode(joinArrays(data)));
+}

package/dist/client/utils/stream.d.ts

@@ -0,0 +1,15 @@
+/** copied from https://github.com/langchain-ai/langgraphjs/tree/main/libs/sdk/src/utils */
+type IterableReadableStreamInterface<T> = ReadableStream<T> & AsyncIterable<T>;
+export declare class IterableReadableStream<T> extends ReadableStream<T> implements IterableReadableStreamInterface<T> {
+    [Symbol.asyncDispose]: () => Promise<void>;
+    /** @ts-ignore */
+    reader: ReadableStreamDefaultReader<T>;
+    ensureReader(): void;
+    next(): Promise<IteratorResult<T>>;
+    return(): Promise<IteratorResult<T>>;
+    throw(e: any): Promise<IteratorResult<T>>;
+    [Symbol.asyncIterator](): this;
+    static fromReadableStream<T>(stream: ReadableStream<T>): IterableReadableStream<T>;
+    static fromAsyncGenerator<T>(generator: AsyncGenerator<T>): IterableReadableStream<T>;
+}
+export {};

package/dist/client/utils/stream.js

@@ -0,0 +1,104 @@
+/*
+ * Support async iterator syntax for ReadableStreams in all environments.
+ * Source: https://github.com/MattiasBuelens/web-streams-polyfill/pull/122#issuecomment-1627354490
+ */
+export class IterableReadableStream extends ReadableStream {
+    /** @ts-ignore */
+    reader;
+    ensureReader() {
+        if (!this.reader) {
+            this.reader = this.getReader();
+        }
+    }
+    async next() {
+        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() {
+        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) {
+        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(stream) {
+        // 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({
+            start(controller) {
+                return pump();
+                function pump() {
+                    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(generator) {
+        return new IterableReadableStream({
+            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/dist/index.d.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/dist/index.js

@@ -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/dist/react/ChatContext.d.ts

@@ -1,5 +1,6 @@
 import { ReactNode } from "react";
 import { UnionStore } from "../ui-store/index.js";
+import { ILangGraphClient } from "@langgraph-js/pure-graph/dist/types.js";
 export declare const useChat: () => UnionStore<{
     data: {
         artifacts: import("nanostores").PreinitializedWritableAtom<import("../index.js").ComposedArtifact[]> & object;
@@ -63,6 +64,8 @@ interface ChatProviderProps {
     showGraph?: boolean;
     fallbackToAvailableAssistants?: boolean;
     onInitError?: (error: any, currentAgent: string) => void;
+    client?: ILangGraphClient;
+    legacyMode?: boolean;
 }
 export declare const ChatProvider: React.FC<ChatProviderProps>;
 export {};

package/dist/react/ChatContext.js

@@ -9,7 +9,7 @@ export const useChat = () => {
     }
     return context;
 };
-export const ChatProvider = ({ children, defaultAgent = "", apiUrl = "http://localhost:8123", defaultHeaders, withCredentials = false, showHistory = false, showGraph = false, fallbackToAvailableAssistants = false, onInitError, }) => {
+export const ChatProvider = ({ children, defaultAgent = "", apiUrl = "http://localhost:8123", defaultHeaders, withCredentials = false, showHistory = false, showGraph = false, fallbackToAvailableAssistants = false, onInitError, client, legacyMode = false, }) => {
     // 使用 useMemo 稳定 defaultHeaders 的引用
     const stableHeaders = useMemo(() => defaultHeaders || {}, [defaultHeaders]);
     // 使用 useRef 保存 onInitError 的最新引用
@@ -24,14 +24,19 @@ export const ChatProvider = ({ children, defaultAgent = "", apiUrl = "http://loc
                 return fetch(url, options);
             }
             : fetch;
-        return createChatStore(defaultAgent, {
+        const config = {
             apiUrl,
             defaultHeaders: stableHeaders,
             callerOptions: {
                 fetch: F,
                 maxRetries: 1,
             },
-        }, {
+            legacyMode,
+        };
+        /** @ts-ignore */
+        if (client)
+            config.client = client;
+        return createChatStore(defaultAgent, config, {
             showHistory,
             showGraph,
             fallbackToAvailableAssistants,

package/dist/tool/ToolUI.js

@@ -1,13 +1,14 @@
 import { getMessageContent } from "../ui-store/createChatStore.js";
 import { jsonrepair } from "jsonrepair";
 export class ToolRenderData {
+    message;
+    client;
     constructor(message, client) {
         this.message = message;
         this.client = client;
     }
     get state() {
-        var _a, _b;
-        if (this.message.type === "tool" && ((_b = (_a = this.message) === null || _a === void 0 ? void 0 : _a.additional_kwargs) === null || _b === void 0 ? void 0 : _b.done)) {
+        if (this.message.type === "tool" && this.message?.additional_kwargs?.done) {
             return "done";
         }
         if (this.message.tool_input) {

package/dist/tool/createTool.js

@@ -11,9 +11,8 @@ export const createTool = (tool) => {
 export const createUITool = (tool) => {
     const execute = tool.execute ||
         (async (args, context) => {
-            var _a;
             try {
-                const result = await ((_a = tool.handler) === null || _a === void 0 ? void 0 : _a.call(tool, args, context));
+                const result = await tool.handler?.(args, context);
                 if (typeof result === "string") {
                     return [{ type: "text", text: result }];
                 }
@@ -47,9 +46,8 @@ export const createFETool = (tool) => {
         allowAgent: tool.allowAgent,
         allowGraph: tool.allowGraph,
         async execute(args, context) {
-            var _a;
             try {
-                const result = await ((_a = tool.handler) === null || _a === void 0 ? void 0 : _a.call(tool, args, context));
+                const result = await tool.handler?.(args, context);
                 if (typeof result === "string") {
                     return [{ type: "text", text: result }];
                 }
@@ -75,9 +73,8 @@ export const createMCPTool = (tool) => {
         tool.description,
         tool.parameters,
         async (args) => {
-            var _a;
             try {
-                const result = await ((_a = tool.execute) === null || _a === void 0 ? void 0 : _a.call(tool, args));
+                const result = await tool.execute?.(args);
                 if (typeof result === "string") {
                     return { content: [{ type: "text", text: result }] };
                 }

package/dist/tool/utils.js

@@ -25,7 +25,6 @@ export function actionParametersToJsonSchema(actionParameters) {
     };
 }
 function convertAttribute(attribute) {
-    var _a, _b, _c;
     switch (attribute.type) {
         case "string":
             return {
@@ -41,11 +40,11 @@ function convertAttribute(attribute) {
             };
         case "object":
         case "object[]":
-            const properties = (_a = attribute.attributes) === null || _a === void 0 ? void 0 : _a.reduce((acc, attr) => {
+            const properties = attribute.attributes?.reduce((acc, attr) => {
                 acc[attr.name] = convertAttribute(attr);
                 return acc;
             }, {});
-            const required = (_b = attribute.attributes) === null || _b === void 0 ? void 0 : _b.filter((attr) => attr.required !== false).map((attr) => attr.name);
+            const required = attribute.attributes?.filter((attr) => attr.required !== false).map((attr) => attr.name);
             if (attribute.type === "object[]") {
                 return {
                     type: "array",
@@ -65,7 +64,7 @@ function convertAttribute(attribute) {
             };
         default:
             // Handle arrays of primitive types and undefined attribute.type
-            if ((_c = attribute.type) === null || _c === void 0 ? void 0 : _c.endsWith("[]")) {
+            if (attribute.type?.endsWith("[]")) {
                 const itemType = attribute.type.slice(0, -2);
                 return {
                     type: "array",