@langchain/langgraph-sdk 0.0.38 → 0.0.40

package/dist/types.stream.d.ts

@@ -0,0 +1,156 @@
+import type { Message } from "./types.messages.js";
+/**
+ * Stream modes
+ * - "values": Stream only the state values.
+ * - "messages": Stream complete messages.
+ * - "messages-tuple": Stream (message chunk, metadata) tuples.
+ * - "updates": Stream updates to the state.
+ * - "events": Stream events occurring during execution.
+ * - "debug": Stream detailed debug information.
+ * - "custom": Stream custom events.
+ */
+export type StreamMode = "values" | "messages" | "updates" | "events" | "debug" | "custom" | "messages-tuple";
+type MessageTupleMetadata = {
+    tags: string[];
+    [key: string]: unknown;
+};
+type AsSubgraph<TEvent extends {
+    event: string;
+    data: unknown;
+}> = {
+    event: TEvent["event"] | `${TEvent["event"]}|${string}`;
+    data: TEvent["data"];
+};
+/**
+ * Stream event with values after completion of each step.
+ */
+export type ValuesStreamEvent<StateType> = {
+    event: "values";
+    data: StateType;
+};
+/** @internal */
+export type SubgraphValuesStreamEvent<StateType> = AsSubgraph<ValuesStreamEvent<StateType>>;
+/**
+ * Stream event with message chunks coming from LLM invocations inside nodes.
+ */
+export type MessagesTupleStreamEvent = {
+    event: "messages";
+    data: [message: Message, config: MessageTupleMetadata];
+};
+/** @internal */
+export type SubgraphMessagesTupleStreamEvent = AsSubgraph<MessagesTupleStreamEvent>;
+/**
+ * Metadata stream event with information about the run and thread
+ */
+export type MetadataStreamEvent = {
+    event: "metadata";
+    data: {
+        run_id: string;
+        thread_id: string;
+    };
+};
+/**
+ * Stream event with error information.
+ */
+export type ErrorStreamEvent = {
+    event: "error";
+    data: {
+        error: string;
+        message: string;
+    };
+};
+/** @internal */
+export type SubgraphErrorStreamEvent = AsSubgraph<ErrorStreamEvent>;
+/**
+ * Stream event with updates to the state after each step.
+ * The streamed outputs include the name of the node that
+ * produced the update as well as the update.
+ */
+export type UpdatesStreamEvent<UpdateType> = {
+    event: "updates";
+    data: {
+        [node: string]: UpdateType;
+    };
+};
+/** @internal */
+export type SubgraphUpdatesStreamEvent<UpdateType> = AsSubgraph<UpdatesStreamEvent<UpdateType>>;
+/**
+ * Streaming custom data from inside the nodes.
+ */
+export type CustomStreamEvent<T> = {
+    event: "custom";
+    data: T;
+};
+/** @internal */
+export type SubgraphCustomStreamEvent<T> = AsSubgraph<CustomStreamEvent<T>>;
+type MessagesMetadataStreamEvent = {
+    event: "messages/metadata";
+    data: {
+        [messageId: string]: {
+            metadata: unknown;
+        };
+    };
+};
+type MessagesCompleteStreamEvent = {
+    event: "messages/complete";
+    data: Message[];
+};
+type MessagesPartialStreamEvent = {
+    event: "messages/partial";
+    data: Message[];
+};
+/**
+ * Message stream event specific to LangGraph Server.
+ * @deprecated Use `streamMode: "messages-tuple"` instead.
+ */
+export type MessagesStreamEvent = MessagesMetadataStreamEvent | MessagesCompleteStreamEvent | MessagesPartialStreamEvent;
+/** @internal */
+export type SubgraphMessagesStreamEvent = AsSubgraph<MessagesMetadataStreamEvent> | AsSubgraph<MessagesCompleteStreamEvent> | AsSubgraph<MessagesPartialStreamEvent>;
+/**
+ * Stream event with detailed debug information.
+ */
+export type DebugStreamEvent = {
+    event: "debug";
+    data: unknown;
+};
+/** @internal */
+export type SubgraphDebugStreamEvent = AsSubgraph<DebugStreamEvent>;
+/**
+ * Stream event with events occurring during execution.
+ */
+export type EventsStreamEvent = {
+    event: "events";
+    data: unknown;
+};
+/** @internal */
+export type SubgraphEventsStreamEvent = AsSubgraph<EventsStreamEvent>;
+/**
+ * Stream event with a feedback key to signed URL map. Set `feedbackKeys` in
+ * the `RunsStreamPayload` to receive this event.
+ */
+export type FeedbackStreamEvent = {
+    event: "feedback";
+    data: {
+        [feedbackKey: string]: string;
+    };
+};
+type GetStreamModeMap<TStreamMode extends StreamMode | StreamMode[], TStateType = unknown, TUpdateType = TStateType, TCustomType = unknown> = {
+    values: ValuesStreamEvent<TStateType>;
+    updates: UpdatesStreamEvent<TUpdateType>;
+    custom: CustomStreamEvent<TCustomType>;
+    debug: DebugStreamEvent;
+    messages: MessagesStreamEvent;
+    "messages-tuple": MessagesTupleStreamEvent;
+    events: EventsStreamEvent;
+}[TStreamMode extends StreamMode[] ? TStreamMode[number] : TStreamMode] | ErrorStreamEvent | MetadataStreamEvent | FeedbackStreamEvent;
+type GetSubgraphsStreamModeMap<TStreamMode extends StreamMode | StreamMode[], TStateType = unknown, TUpdateType = TStateType, TCustomType = unknown> = {
+    values: SubgraphValuesStreamEvent<TStateType>;
+    updates: SubgraphUpdatesStreamEvent<TUpdateType>;
+    custom: SubgraphCustomStreamEvent<TCustomType>;
+    debug: SubgraphDebugStreamEvent;
+    messages: SubgraphMessagesStreamEvent;
+    "messages-tuple": SubgraphMessagesTupleStreamEvent;
+    events: SubgraphEventsStreamEvent;
+}[TStreamMode extends StreamMode[] ? TStreamMode[number] : TStreamMode] | SubgraphErrorStreamEvent | MetadataStreamEvent | FeedbackStreamEvent;
+export type TypedAsyncGenerator<TStreamMode extends StreamMode | StreamMode[] = [], TSubgraphs extends boolean = false, TStateType = unknown, TUpdateType = TStateType, TCustomType = unknown> = AsyncGenerator<TSubgraphs extends true ? GetSubgraphsStreamModeMap<TStreamMode, TStateType, TUpdateType, TCustomType> : GetStreamModeMap<TStreamMode, TStateType, TUpdateType, TCustomType>>;
+export {};

package/dist/types.stream.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/async_caller.cjs

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AsyncCaller = void 0;
 const p_retry_1 = __importDefault(require("p-retry"));
 const p_queue_1 = __importDefault(require("p-queue"));
+const fetch_js_1 = require("../singletons/fetch.cjs");
 const STATUS_NO_RETRY = [
     400, // Bad Request
     401, // Unauthorized
@@ -189,7 +190,7 @@ class AsyncCaller {
         return this.call(callable, ...args);
     }
     fetch(...args) {
-        const fetchFn = this.customFetch ?? fetch;
+        const fetchFn = this.customFetch ?? (0, fetch_js_1._getFetchImplementation)();
         return this.call(() => fetchFn(...args).then((res) => (res.ok ? res : Promise.reject(res))));
     }
 }

package/dist/utils/async_caller.js

@@ -1,5 +1,6 @@
 import pRetry from "p-retry";
 import PQueueMod from "p-queue";
+import { _getFetchImplementation } from "../singletons/fetch.js";
 const STATUS_NO_RETRY = [
     400, // Bad Request
     401, // Unauthorized
@@ -183,7 +184,7 @@ export class AsyncCaller {
         return this.call(callable, ...args);
     }
     fetch(...args) {
-        const fetchFn = this.customFetch ?? fetch;
+        const fetchFn = this.customFetch ?? _getFetchImplementation();
         return this.call(() => fetchFn(...args).then((res) => (res.ok ? res : Promise.reject(res))));
     }
 }

package/dist/utils/sse.cjs

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SSEDecoder = exports.BytesLineDecoder = void 0;
+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];
+class BytesLineDecoder extends TransformStream {
+    constructor() {
+        let buffer = [];
+        let trailingCr = false;
+        super({
+            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));
+                }
+            },
+        });
+    }
+}
+exports.BytesLineDecoder = BytesLineDecoder;
+class SSEDecoder extends TransformStream {
+    constructor() {
+        let event = "";
+        let data = [];
+        let lastEventId = "";
+        let retry = null;
+        const decoder = new TextDecoder();
+        super({
+            transform(chunk, controller) {
+                // Handle empty line case
+                if (!chunk.length) {
+                    if (!event && !data.length && !lastEventId && retry == null)
+                        return;
+                    const sse = {
+                        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));
+                    if (!Number.isNaN(retryNum))
+                        retry = retryNum;
+                }
+            },
+            flush(controller) {
+                if (event) {
+                    controller.enqueue({
+                        event,
+                        data: data.length ? decodeArraysToJson(decoder, data) : null,
+                    });
+                }
+            },
+        });
+    }
+}
+exports.SSEDecoder = SSEDecoder;
+function joinArrays(data) {
+    const totalLength = data.reduce((acc, curr) => acc + curr.length, 0);
+    let 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/utils/sse.d.ts

@@ -0,0 +1,11 @@
+export declare class BytesLineDecoder extends TransformStream<Uint8Array, Uint8Array> {
+    constructor();
+}
+interface StreamPart {
+    event: string;
+    data: unknown;
+}
+export declare class SSEDecoder extends TransformStream<Uint8Array, StreamPart> {
+    constructor();
+}
+export {};

package/dist/utils/sse.js

@@ -0,0 +1,152 @@
+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 class BytesLineDecoder extends TransformStream {
+    constructor() {
+        let buffer = [];
+        let trailingCr = false;
+        super({
+            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 class SSEDecoder extends TransformStream {
+    constructor() {
+        let event = "";
+        let data = [];
+        let lastEventId = "";
+        let retry = null;
+        const decoder = new TextDecoder();
+        super({
+            transform(chunk, controller) {
+                // Handle empty line case
+                if (!chunk.length) {
+                    if (!event && !data.length && !lastEventId && retry == null)
+                        return;
+                    const sse = {
+                        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));
+                    if (!Number.isNaN(retryNum))
+                        retry = retryNum;
+                }
+            },
+            flush(controller) {
+                if (event) {
+                    controller.enqueue({
+                        event,
+                        data: data.length ? decodeArraysToJson(decoder, data) : null,
+                    });
+                }
+            },
+        });
+    }
+}
+function joinArrays(data) {
+    const totalLength = data.reduce((acc, curr) => acc + curr.length, 0);
+    let 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph-sdk",
-  "version": "0.0.38",
+  "version": "0.0.40",
   "description": "Client library for interacting with the LangGraph API",
   "type": "module",
   "packageManager": "yarn@1.22.19",
@@ -22,18 +22,25 @@
   },
   "devDependencies": {
     "@jest/globals": "^29.7.0",
+    "@langchain/core": "^0.3.31",
     "@langchain/scripts": "^0.1.4",
     "@tsconfig/recommended": "^1.0.2",
     "@types/jest": "^29.5.12",
     "@types/node": "^20.12.12",
     "@types/uuid": "^9.0.1",
+    "@types/react": "18.3.2",
     "concat-md": "^0.5.1",
     "jest": "^29.7.0",
     "prettier": "^3.2.5",
     "ts-jest": "^29.1.2",
     "typedoc": "^0.26.1",
     "typedoc-plugin-markdown": "^4.1.0",
-    "typescript": "^5.4.5"
+    "typescript": "^5.4.5",
+    "react": "^18.3.1"
+  },
+  "peerDependencies": {
+    "react": "^18 || ^19",
+    "@langchain/core": ">=0.2.31 <0.4.0"
   },
   "exports": {
     ".": {
@@ -54,6 +61,15 @@
       "import": "./client.js",
       "require": "./client.cjs"
     },
+    "./react": {
+      "types": {
+        "import": "./react.d.ts",
+        "require": "./react.d.cts",
+        "default": "./react.d.ts"
+      },
+      "import": "./react.js",
+      "require": "./react.cjs"
+    },
     "./package.json": "./package.json"
   },
   "files": [
@@ -65,6 +81,10 @@
     "client.cjs",
     "client.js",
     "client.d.ts",
-    "client.d.cts"
+    "client.d.cts",
+    "react.cjs",
+    "react.js",
+    "react.d.ts",
+    "react.d.cts"
   ]
 }

package/react.cjs

@@ -0,0 +1 @@
+module.exports = require('./dist/react/index.cjs');

package/react.d.cts

@@ -0,0 +1 @@
+export * from './dist/react/index.js'

package/react.d.ts

@@ -0,0 +1 @@
+export * from './dist/react/index.js'

package/react.js

@@ -0,0 +1 @@
+export * from './dist/react/index.js'

package/dist/utils/eventsource-parser/index.cjs

@@ -1,7 +0,0 @@
-"use strict";
-// From https://github.com/rexxars/eventsource-parser
-// Inlined due to CJS import issues
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createParser = void 0;
-var parse_js_1 = require("./parse.cjs");
-Object.defineProperty(exports, "createParser", { enumerable: true, get: function () { return parse_js_1.createParser; } });

package/dist/utils/eventsource-parser/index.d.ts

@@ -1,2 +0,0 @@
-export { createParser } from "./parse.js";
-export type { EventSourceParseCallback, EventSourceParser, ParsedEvent, ParseEvent, ReconnectInterval, } from "./types.js";

package/dist/utils/eventsource-parser/index.js

@@ -1,3 +0,0 @@
-// From https://github.com/rexxars/eventsource-parser
-// Inlined due to CJS import issues
-export { createParser } from "./parse.js";