@langchain/langgraph-sdk 0.0.111 → 0.1.0

package/dist/react/manager.cjs

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamManager = void 0;
+const messages_js_1 = require("./messages.cjs");
+const errors_js_1 = require("./errors.cjs");
+class StreamManager {
+    constructor(messages) {
+        Object.defineProperty(this, "abortRef", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new AbortController()
+        });
+        Object.defineProperty(this, "messages", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "listeners", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        Object.defineProperty(this, "state", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "setState", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (newState) => {
+                this.state = { ...this.state, ...newState };
+                this.notifyListeners();
+            }
+        });
+        Object.defineProperty(this, "notifyListeners", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: () => {
+                this.listeners.forEach((listener) => listener());
+            }
+        });
+        Object.defineProperty(this, "subscribe", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (listener) => {
+                this.listeners.add(listener);
+                return () => this.listeners.delete(listener);
+            }
+        });
+        Object.defineProperty(this, "getSnapshot", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: () => this.state
+        });
+        Object.defineProperty(this, "setStreamValues", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (values, kind = "stream") => {
+                if (typeof values === "function") {
+                    const [prevValues, prevKind] = this.state.values ?? [null, "stream"];
+                    const nextValues = values(prevValues, prevKind);
+                    this.setState({ values: nextValues != null ? [nextValues, kind] : null });
+                }
+                else {
+                    const nextValues = values != null ? [values, kind] : null;
+                    this.setState({ values: nextValues });
+                }
+            }
+        });
+        Object.defineProperty(this, "getMutateFn", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (kind, historyValues) => {
+                return (update) => {
+                    const prev = { ...historyValues, ...this.state.values };
+                    const next = typeof update === "function" ? update(prev) : update;
+                    this.setStreamValues({ ...prev, ...next }, kind);
+                };
+            }
+        });
+        Object.defineProperty(this, "matchEventType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (expected, actual, _data) => {
+                return expected === actual || actual.startsWith(`${expected}|`);
+            }
+        });
+        Object.defineProperty(this, "start", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: async (action, options) => {
+                if (this.state.isLoading)
+                    return;
+                try {
+                    this.setState({ isLoading: true, error: undefined });
+                    this.abortRef = new AbortController();
+                    const run = await action(this.abortRef.signal);
+                    let streamError;
+                    for await (const { event, data } of run) {
+                        if (event === "error") {
+                            streamError = new errors_js_1.StreamError(data);
+                            break;
+                        }
+                        const namespace = event.includes("|")
+                            ? event.split("|").slice(1)
+                            : undefined;
+                        const mutate = this.getMutateFn("stream", options.initialValues);
+                        if (event === "metadata")
+                            options.callbacks.onMetadataEvent?.(data);
+                        if (event === "events")
+                            options.callbacks.onLangChainEvent?.(data);
+                        if (this.matchEventType("updates", event, data)) {
+                            options.callbacks.onUpdateEvent?.(data, { namespace, mutate });
+                        }
+                        if (this.matchEventType("custom", event, data)) {
+                            options.callbacks.onCustomEvent?.(data, { namespace, mutate });
+                        }
+                        if (this.matchEventType("checkpoints", event, data)) {
+                            options.callbacks.onCheckpointEvent?.(data, { namespace });
+                        }
+                        if (this.matchEventType("tasks", event, data)) {
+                            options.callbacks.onTaskEvent?.(data, { namespace });
+                        }
+                        if (this.matchEventType("debug", event, data)) {
+                            options.callbacks.onDebugEvent?.(data, { namespace });
+                        }
+                        if (event === "values") {
+                            // don't update values on interrupt values event
+                            if ("__interrupt__" in data)
+                                continue;
+                            this.setStreamValues(data);
+                        }
+                        if (this.matchEventType("messages", event, data)) {
+                            const [serialized, metadata] = data;
+                            const messageId = this.messages.add(serialized, metadata);
+                            if (!messageId) {
+                                console.warn("Failed to add message to manager, no message ID found");
+                                continue;
+                            }
+                            this.setStreamValues((streamValues) => {
+                                const values = { ...options.initialValues, ...streamValues };
+                                // Assumption: we're concatenating the message
+                                const messages = options.getMessages(values).slice();
+                                const { chunk, index } = this.messages.get(messageId, messages.length) ?? {};
+                                if (!chunk || index == null)
+                                    return values;
+                                messages[index] = (0, messages_js_1.toMessageDict)(chunk);
+                                return options.setMessages(values, messages);
+                            });
+                        }
+                    }
+                    if (streamError != null)
+                        throw streamError;
+                    const values = await options.onSuccess?.();
+                    if (typeof values !== "undefined")
+                        this.setStreamValues(values);
+                }
+                catch (error) {
+                    if (!(error instanceof Error && // eslint-disable-line no-instanceof/no-instanceof
+                        (error.name === "AbortError" || error.name === "TimeoutError"))) {
+                        console.error(error);
+                        this.setState({ error });
+                        await options.onError?.(error);
+                    }
+                }
+                finally {
+                    this.setState({ isLoading: false });
+                    this.abortRef = new AbortController();
+                }
+            }
+        });
+        Object.defineProperty(this, "stop", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: async (historyValues, options) => {
+                if (this.abortRef) {
+                    this.abortRef.abort();
+                    this.abortRef = new AbortController();
+                }
+                options.onStop?.({ mutate: this.getMutateFn("stop", historyValues) });
+            }
+        });
+        Object.defineProperty(this, "clear", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: () => {
+                this.setState({ error: undefined, values: null });
+                this.messages.clear();
+            }
+        });
+        this.messages = messages;
+        this.state = { isLoading: false, values: null, error: undefined };
+    }
+    get isLoading() {
+        return this.state.isLoading;
+    }
+    get values() {
+        return this.state.values?.[0] ?? null;
+    }
+    get error() {
+        return this.state.error;
+    }
+}
+exports.StreamManager = StreamManager;

package/dist/react/manager.d.ts

@@ -0,0 +1,86 @@
+import type { CheckpointsStreamEvent, CustomStreamEvent, DebugStreamEvent, ErrorStreamEvent, EventsStreamEvent, FeedbackStreamEvent, MessagesTupleStreamEvent, MetadataStreamEvent, TasksStreamEvent, UpdatesStreamEvent, ValuesStreamEvent } from "../types.stream.js";
+import { MessageTupleManager } from "./messages.js";
+import type { Message } from "../types.messages.js";
+type BagTemplate = {
+    ConfigurableType?: Record<string, unknown>;
+    InterruptType?: unknown;
+    CustomEventType?: unknown;
+    UpdateType?: unknown;
+};
+type GetUpdateType<Bag extends BagTemplate, StateType extends Record<string, unknown>> = Bag extends {
+    UpdateType: unknown;
+} ? Bag["UpdateType"] : Partial<StateType>;
+type GetCustomEventType<Bag extends BagTemplate> = Bag extends {
+    CustomEventType: unknown;
+} ? Bag["CustomEventType"] : unknown;
+type EventStreamMap<StateType, UpdateType, CustomType> = {
+    values: ValuesStreamEvent<StateType>;
+    updates: UpdatesStreamEvent<UpdateType>;
+    custom: CustomStreamEvent<CustomType>;
+    debug: DebugStreamEvent;
+    messages: MessagesTupleStreamEvent;
+    events: EventsStreamEvent;
+    metadata: MetadataStreamEvent;
+    checkpoints: CheckpointsStreamEvent<StateType>;
+    tasks: TasksStreamEvent<StateType, UpdateType>;
+    error: ErrorStreamEvent;
+    feedback: FeedbackStreamEvent;
+};
+export type EventStreamEvent<StateType, UpdateType, CustomType> = EventStreamMap<StateType, UpdateType, CustomType>[keyof EventStreamMap<StateType, UpdateType, CustomType>];
+interface StreamManagerEventCallbacks<StateType extends Record<string, unknown>, Bag extends BagTemplate = BagTemplate> {
+    onUpdateEvent?: (data: UpdatesStreamEvent<GetUpdateType<Bag, StateType>>["data"], options: {
+        namespace: string[] | undefined;
+        mutate: (update: Partial<StateType> | ((prev: StateType) => Partial<StateType>)) => void;
+    }) => void;
+    onCustomEvent?: (data: GetCustomEventType<Bag>, options: {
+        namespace: string[] | undefined;
+        mutate: (update: Partial<StateType> | ((prev: StateType) => Partial<StateType>)) => void;
+    }) => void;
+    onMetadataEvent?: (data: MetadataStreamEvent["data"]) => void;
+    onLangChainEvent?: (data: EventsStreamEvent["data"]) => void;
+    onDebugEvent?: (data: DebugStreamEvent["data"], options: {
+        namespace: string[] | undefined;
+    }) => void;
+    onCheckpointEvent?: (data: CheckpointsStreamEvent<StateType>["data"], options: {
+        namespace: string[] | undefined;
+    }) => void;
+    onTaskEvent?: (data: TasksStreamEvent<StateType, GetUpdateType<Bag, StateType>>["data"], options: {
+        namespace: string[] | undefined;
+    }) => void;
+}
+export declare class StreamManager<StateType extends Record<string, unknown>, Bag extends BagTemplate = BagTemplate> {
+    private abortRef;
+    private messages;
+    private listeners;
+    private state;
+    constructor(messages: MessageTupleManager);
+    private setState;
+    private notifyListeners;
+    subscribe: (listener: () => void) => (() => void);
+    getSnapshot: () => {
+        isLoading: boolean;
+        values: [values: StateType, kind: "stream" | "stop"] | null;
+        error: unknown;
+    };
+    get isLoading(): boolean;
+    get values(): StateType | null;
+    get error(): unknown;
+    setStreamValues: (values: (StateType | null) | ((prev: StateType | null, kind: "stream" | "stop") => StateType | null), kind?: "stream" | "stop") => void;
+    private getMutateFn;
+    private matchEventType;
+    start: (action: (signal: AbortSignal) => Promise<AsyncGenerator<EventStreamEvent<StateType, GetUpdateType<Bag, StateType>, GetCustomEventType<Bag>>>>, options: {
+        getMessages: (values: StateType) => Message[];
+        setMessages: (current: StateType, messages: Message[]) => StateType;
+        initialValues: StateType;
+        callbacks: StreamManagerEventCallbacks<StateType, Bag>;
+        onSuccess: () => StateType | null | undefined | void | Promise<StateType | null | undefined | void>;
+        onError: (error: unknown) => void | Promise<void>;
+    }) => Promise<void>;
+    stop: (historyValues: StateType, options: {
+        onStop?: (options: {
+            mutate: (update: Partial<StateType> | ((prev: StateType) => Partial<StateType>)) => void;
+        }) => void;
+    }) => Promise<void>;
+    clear: () => void;
+}
+export {};

package/dist/react/manager.js

@@ -0,0 +1,215 @@
+import { toMessageDict } from "./messages.js";
+import { StreamError } from "./errors.js";
+export class StreamManager {
+    constructor(messages) {
+        Object.defineProperty(this, "abortRef", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new AbortController()
+        });
+        Object.defineProperty(this, "messages", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "listeners", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        Object.defineProperty(this, "state", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "setState", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (newState) => {
+                this.state = { ...this.state, ...newState };
+                this.notifyListeners();
+            }
+        });
+        Object.defineProperty(this, "notifyListeners", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: () => {
+                this.listeners.forEach((listener) => listener());
+            }
+        });
+        Object.defineProperty(this, "subscribe", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (listener) => {
+                this.listeners.add(listener);
+                return () => this.listeners.delete(listener);
+            }
+        });
+        Object.defineProperty(this, "getSnapshot", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: () => this.state
+        });
+        Object.defineProperty(this, "setStreamValues", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (values, kind = "stream") => {
+                if (typeof values === "function") {
+                    const [prevValues, prevKind] = this.state.values ?? [null, "stream"];
+                    const nextValues = values(prevValues, prevKind);
+                    this.setState({ values: nextValues != null ? [nextValues, kind] : null });
+                }
+                else {
+                    const nextValues = values != null ? [values, kind] : null;
+                    this.setState({ values: nextValues });
+                }
+            }
+        });
+        Object.defineProperty(this, "getMutateFn", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (kind, historyValues) => {
+                return (update) => {
+                    const prev = { ...historyValues, ...this.state.values };
+                    const next = typeof update === "function" ? update(prev) : update;
+                    this.setStreamValues({ ...prev, ...next }, kind);
+                };
+            }
+        });
+        Object.defineProperty(this, "matchEventType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (expected, actual, _data) => {
+                return expected === actual || actual.startsWith(`${expected}|`);
+            }
+        });
+        Object.defineProperty(this, "start", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: async (action, options) => {
+                if (this.state.isLoading)
+                    return;
+                try {
+                    this.setState({ isLoading: true, error: undefined });
+                    this.abortRef = new AbortController();
+                    const run = await action(this.abortRef.signal);
+                    let streamError;
+                    for await (const { event, data } of run) {
+                        if (event === "error") {
+                            streamError = new StreamError(data);
+                            break;
+                        }
+                        const namespace = event.includes("|")
+                            ? event.split("|").slice(1)
+                            : undefined;
+                        const mutate = this.getMutateFn("stream", options.initialValues);
+                        if (event === "metadata")
+                            options.callbacks.onMetadataEvent?.(data);
+                        if (event === "events")
+                            options.callbacks.onLangChainEvent?.(data);
+                        if (this.matchEventType("updates", event, data)) {
+                            options.callbacks.onUpdateEvent?.(data, { namespace, mutate });
+                        }
+                        if (this.matchEventType("custom", event, data)) {
+                            options.callbacks.onCustomEvent?.(data, { namespace, mutate });
+                        }
+                        if (this.matchEventType("checkpoints", event, data)) {
+                            options.callbacks.onCheckpointEvent?.(data, { namespace });
+                        }
+                        if (this.matchEventType("tasks", event, data)) {
+                            options.callbacks.onTaskEvent?.(data, { namespace });
+                        }
+                        if (this.matchEventType("debug", event, data)) {
+                            options.callbacks.onDebugEvent?.(data, { namespace });
+                        }
+                        if (event === "values") {
+                            // don't update values on interrupt values event
+                            if ("__interrupt__" in data)
+                                continue;
+                            this.setStreamValues(data);
+                        }
+                        if (this.matchEventType("messages", event, data)) {
+                            const [serialized, metadata] = data;
+                            const messageId = this.messages.add(serialized, metadata);
+                            if (!messageId) {
+                                console.warn("Failed to add message to manager, no message ID found");
+                                continue;
+                            }
+                            this.setStreamValues((streamValues) => {
+                                const values = { ...options.initialValues, ...streamValues };
+                                // Assumption: we're concatenating the message
+                                const messages = options.getMessages(values).slice();
+                                const { chunk, index } = this.messages.get(messageId, messages.length) ?? {};
+                                if (!chunk || index == null)
+                                    return values;
+                                messages[index] = toMessageDict(chunk);
+                                return options.setMessages(values, messages);
+                            });
+                        }
+                    }
+                    if (streamError != null)
+                        throw streamError;
+                    const values = await options.onSuccess?.();
+                    if (typeof values !== "undefined")
+                        this.setStreamValues(values);
+                }
+                catch (error) {
+                    if (!(error instanceof Error && // eslint-disable-line no-instanceof/no-instanceof
+                        (error.name === "AbortError" || error.name === "TimeoutError"))) {
+                        console.error(error);
+                        this.setState({ error });
+                        await options.onError?.(error);
+                    }
+                }
+                finally {
+                    this.setState({ isLoading: false });
+                    this.abortRef = new AbortController();
+                }
+            }
+        });
+        Object.defineProperty(this, "stop", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: async (historyValues, options) => {
+                if (this.abortRef) {
+                    this.abortRef.abort();
+                    this.abortRef = new AbortController();
+                }
+                options.onStop?.({ mutate: this.getMutateFn("stop", historyValues) });
+            }
+        });
+        Object.defineProperty(this, "clear", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: () => {
+                this.setState({ error: undefined, values: null });
+                this.messages.clear();
+            }
+        });
+        this.messages = messages;
+        this.state = { isLoading: false, values: null, error: undefined };
+    }
+    get isLoading() {
+        return this.state.isLoading;
+    }
+    get values() {
+        return this.state.values?.[0] ?? null;
+    }
+    get error() {
+        return this.state.error;
+    }
+}

package/dist/react/messages.cjs

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toMessageDict = exports.MessageTupleManager = void 0;
+const messages_1 = require("@langchain/core/messages");
+function tryConvertToChunk(message) {
+    try {
+        return (0, messages_1.convertToChunk)(message);
+    }
+    catch {
+        return null;
+    }
+}
+class MessageTupleManager {
+    constructor() {
+        Object.defineProperty(this, "chunks", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        this.chunks = {};
+    }
+    add(serialized, metadata) {
+        // TODO: this is sometimes sent from the API
+        // figure out how to prevent this or move this to LC.js
+        if (serialized.type.endsWith("MessageChunk")) {
+            // eslint-disable-next-line no-param-reassign
+            serialized.type = serialized.type
+                .slice(0, -"MessageChunk".length)
+                .toLowerCase();
+        }
+        const message = (0, messages_1.coerceMessageLikeToMessage)(serialized);
+        const chunk = tryConvertToChunk(message);
+        const { id } = chunk ?? message;
+        if (!id) {
+            console.warn("No message ID found for chunk, ignoring in state", serialized);
+            return null;
+        }
+        this.chunks[id] ??= {};
+        this.chunks[id].metadata = metadata ?? this.chunks[id].metadata;
+        if (chunk) {
+            const prev = this.chunks[id].chunk;
+            this.chunks[id].chunk =
+                ((0, messages_1.isBaseMessageChunk)(prev) ? prev : null)?.concat(chunk) ?? chunk;
+        }
+        else {
+            this.chunks[id].chunk = message;
+        }
+        return id;
+    }
+    clear() {
+        this.chunks = {};
+    }
+    get(id, defaultIndex) {
+        if (id == null)
+            return null;
+        if (this.chunks[id] == null)
+            return null;
+        if (defaultIndex != null)
+            this.chunks[id].index ??= defaultIndex;
+        return this.chunks[id];
+    }
+}
+exports.MessageTupleManager = MessageTupleManager;
+const toMessageDict = (chunk) => {
+    const { type, data } = chunk.toDict();
+    return { ...data, type };
+};
+exports.toMessageDict = toMessageDict;

package/dist/react/messages.d.ts

@@ -0,0 +1,18 @@
+import { type BaseMessage, type BaseMessageChunk } from "@langchain/core/messages";
+import type { Message } from "../types.messages.js";
+export declare class MessageTupleManager {
+    chunks: Record<string, {
+        chunk?: BaseMessageChunk | BaseMessage;
+        metadata?: Record<string, unknown>;
+        index?: number;
+    }>;
+    constructor();
+    add(serialized: Message, metadata: Record<string, unknown> | undefined): string | null;
+    clear(): void;
+    get(id: string | null | undefined, defaultIndex?: number): {
+        chunk?: BaseMessageChunk | BaseMessage;
+        metadata?: Record<string, unknown>;
+        index?: number;
+    } | null;
+}
+export declare const toMessageDict: (chunk: BaseMessage) => Message;

package/dist/react/messages.js

@@ -0,0 +1,64 @@
+import { convertToChunk, coerceMessageLikeToMessage, isBaseMessageChunk, } from "@langchain/core/messages";
+function tryConvertToChunk(message) {
+    try {
+        return convertToChunk(message);
+    }
+    catch {
+        return null;
+    }
+}
+export class MessageTupleManager {
+    constructor() {
+        Object.defineProperty(this, "chunks", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        this.chunks = {};
+    }
+    add(serialized, metadata) {
+        // TODO: this is sometimes sent from the API
+        // figure out how to prevent this or move this to LC.js
+        if (serialized.type.endsWith("MessageChunk")) {
+            // eslint-disable-next-line no-param-reassign
+            serialized.type = serialized.type
+                .slice(0, -"MessageChunk".length)
+                .toLowerCase();
+        }
+        const message = coerceMessageLikeToMessage(serialized);
+        const chunk = tryConvertToChunk(message);
+        const { id } = chunk ?? message;
+        if (!id) {
+            console.warn("No message ID found for chunk, ignoring in state", serialized);
+            return null;
+        }
+        this.chunks[id] ??= {};
+        this.chunks[id].metadata = metadata ?? this.chunks[id].metadata;
+        if (chunk) {
+            const prev = this.chunks[id].chunk;
+            this.chunks[id].chunk =
+                (isBaseMessageChunk(prev) ? prev : null)?.concat(chunk) ?? chunk;
+        }
+        else {
+            this.chunks[id].chunk = message;
+        }
+        return id;
+    }
+    clear() {
+        this.chunks = {};
+    }
+    get(id, defaultIndex) {
+        if (id == null)
+            return null;
+        if (this.chunks[id] == null)
+            return null;
+        if (defaultIndex != null)
+            this.chunks[id].index ??= defaultIndex;
+        return this.chunks[id];
+    }
+}
+export const toMessageDict = (chunk) => {
+    const { type, data } = chunk.toDict();
+    return { ...data, type };
+};