@langchain/langgraph-sdk 0.0.1-rc.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2024 LangChain
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/client.cjs

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

package/client.d.cts

@@ -0,0 +1 @@
+export * from './dist/client.cjs'

package/client.d.ts

@@ -0,0 +1 @@
+export * from './dist/client.mjs'

package/client.js

@@ -0,0 +1 @@
+export * from './dist/client.mjs'

package/dist/client.d.mts

@@ -0,0 +1,111 @@
+import { Assistant, AssistantGraph, Config, GraphSchema, Metadata, Run, RunEvent, Thread, ThreadState } from "./schema.js";
+import { AsyncCaller, AsyncCallerParams } from "./utils/async_caller.mjs";
+import { IterableReadableStreamInterface } from "./utils/stream.mjs";
+interface ClientConfig {
+    apiUrl?: string;
+    callerOptions?: AsyncCallerParams;
+    timeoutMs?: number;
+}
+declare class BaseClient {
+    protected asyncCaller: AsyncCaller;
+    protected timeoutMs: number;
+    protected apiUrl: string;
+    constructor(config?: ClientConfig);
+    protected prepareFetchOptions(path: string, options?: RequestInit & {
+        json?: unknown;
+        params?: Record<string, unknown>;
+    }): [url: URL, init: RequestInit];
+    protected fetch<T>(path: string, options?: RequestInit & {
+        json?: unknown;
+        params?: Record<string, unknown>;
+    }): Promise<T>;
+}
+declare class AssistantsClient extends BaseClient {
+    get(assistantId: string): Promise<Assistant>;
+    getGraph(assistantId: string): Promise<AssistantGraph>;
+    getSchemas(assistantId: string): Promise<GraphSchema>;
+    create(payload: {
+        graphId?: string;
+        config?: Config;
+        metadata?: Metadata;
+    }): Promise<Assistant>;
+    upsert(assistantId: string, payload: {
+        graphId?: string;
+        config?: Config;
+        metadata?: Metadata;
+    }): Promise<Assistant>;
+    search(query: {
+        metadata?: Metadata;
+        limit?: number;
+        offset?: number;
+    }): Promise<Assistant[]>;
+}
+declare class ThreadsClient extends BaseClient {
+    get(threadId: string): Promise<Thread>;
+    create(payload: {
+        metadata?: Metadata;
+    }): Promise<Thread>;
+    upsert(threadId: string, payload: {
+        metadata?: Metadata;
+    }): Promise<Thread>;
+    delete(threadId: string): Promise<void>;
+    search(query: {
+        metadata?: Metadata;
+        limit?: number;
+        offset?: number;
+    }): Promise<Thread[]>;
+    getState(threadId: string): Promise<ThreadState>;
+    updateState(threadIdOrConfig: string | Config, values: Record<string, unknown>, options?: {
+        asNode?: string;
+    }): Promise<void>;
+    patchState(threadIdOrConfig: string | Config, metadata: Record<string, unknown>): Promise<void>;
+    getHistory(threadId: string, options?: {
+        limit?: number;
+        before?: Config;
+    }): Promise<ThreadState[]>;
+}
+declare class RunsClient extends BaseClient {
+    stream(threadId: string, assistantId: string, options?: {
+        input?: Record<string, unknown>;
+        streamMode?: "values" | "messages" | "updates" | "events" | "debug";
+        metadata?: Metadata;
+        config?: Config;
+        interruptBefore?: string[];
+        interruptAfter?: string[];
+    }): Promise<IterableReadableStreamInterface<{
+        event: string;
+        data: unknown;
+    }>>;
+    create(threadId: string, assistantId: string, options?: {
+        input?: Record<string, unknown>;
+        metadata?: Metadata;
+        config?: Config;
+        interruptBefore?: string[];
+        interruptAfter?: string[];
+        webhook?: string;
+    }): Promise<Run>;
+    wait(threadId: string, assistantId: string, options?: {
+        input?: Record<string, unknown>;
+        streamMode?: "values" | "messages" | "updates" | "events" | "debug";
+        metadata?: Metadata;
+        config?: Config;
+        interruptBefore?: string[];
+        interruptAfter?: string[];
+    }): Promise<ThreadState["values"]>;
+    list(threadId: string, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<Run[]>;
+    get(threadId: string, runId: string): Promise<Run>;
+    listEvents(threadId: string, runId: string, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<RunEvent[]>;
+}
+export declare class Client {
+    assistants: AssistantsClient;
+    threads: ThreadsClient;
+    runs: RunsClient;
+    constructor(config?: ClientConfig);
+}
+export {};

package/dist/client.mjs

@@ -0,0 +1,289 @@
+import { AsyncCaller } from "./utils/async_caller.mjs";
+import { createParser } from "eventsource-parser";
+import { IterableReadableStream, } from "./utils/stream.mjs";
+class BaseClient {
+    constructor(config) {
+        Object.defineProperty(this, "asyncCaller", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "timeoutMs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "apiUrl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.asyncCaller = new AsyncCaller({
+            maxRetries: 5,
+            maxConcurrency: 5,
+            ...config?.callerOptions,
+        });
+        this.timeoutMs = config?.timeoutMs || 12_000;
+        this.apiUrl = config?.apiUrl || "http://localhost:8123";
+    }
+    prepareFetchOptions(path, options) {
+        const mutatedOptions = { ...options };
+        if (mutatedOptions.json) {
+            mutatedOptions.body = JSON.stringify(mutatedOptions.json);
+            mutatedOptions.headers = {
+                ...mutatedOptions.headers,
+                "Content-Type": "application/json",
+            };
+            delete mutatedOptions.json;
+        }
+        const targetUrl = new URL(`${this.apiUrl}${path}`);
+        if (mutatedOptions.params) {
+            for (const [key, value] of Object.entries(mutatedOptions.params)) {
+                if (value == null)
+                    continue;
+                let strValue = typeof value === "string" || typeof value === "number"
+                    ? value.toString()
+                    : JSON.stringify(value);
+                targetUrl.searchParams.append(key, strValue);
+            }
+            delete mutatedOptions.params;
+        }
+        return [targetUrl, mutatedOptions];
+    }
+    async fetch(path, options) {
+        const response = await this.asyncCaller.fetch(...this.prepareFetchOptions(path, options));
+        return response.json();
+    }
+}
+class AssistantsClient extends BaseClient {
+    async get(assistantId) {
+        return this.fetch(`/assistants/${assistantId}`);
+    }
+    async getGraph(assistantId) {
+        return this.fetch(`/assistants/${assistantId}/graph`);
+    }
+    async getSchemas(assistantId) {
+        return this.fetch(`/assistants/${assistantId}/schemas`);
+    }
+    async create(payload) {
+        return this.fetch("/assistants", {
+            method: "POST",
+            body: JSON.stringify({
+                graph_id: payload.graphId,
+                config: payload.config,
+                metadata: payload.metadata,
+            }),
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+    async upsert(assistantId, payload) {
+        return this.fetch(`/assistants/${assistantId}`, {
+            method: "PUT",
+            json: {
+                graph_id: payload.graphId,
+                config: payload.config,
+                metadata: payload.metadata,
+            },
+        });
+    }
+    async search(query) {
+        return this.fetch("/assistants/search", {
+            method: "POST",
+            json: {
+                metadata: query.metadata ?? undefined,
+                limit: query.limit ?? 10,
+                offset: query.offset ?? 0,
+            },
+        });
+    }
+}
+class ThreadsClient extends BaseClient {
+    async get(threadId) {
+        return this.fetch(`/threads/${threadId}`);
+    }
+    async create(payload) {
+        return this.fetch(`/threads`, {
+            method: "POST",
+            json: { metadata: payload },
+        });
+    }
+    async upsert(threadId, payload) {
+        return this.fetch(`/threads/${threadId}`, {
+            method: "PUT",
+            json: { metadata: payload },
+        });
+    }
+    async delete(threadId) {
+        return this.fetch(`/threads/${threadId}`, {
+            method: "DELETE",
+        });
+    }
+    async search(query) {
+        return this.fetch("/threads/search", {
+            method: "POST",
+            json: {
+                metadata: query.metadata ?? undefined,
+                limit: query.limit ?? 10,
+                offset: query.offset ?? 0,
+            },
+        });
+    }
+    async getState(threadId) {
+        return this.fetch(`/threads/${threadId}/state`);
+    }
+    async updateState(threadIdOrConfig, values, options) {
+        let config = undefined;
+        let threadId;
+        if (typeof threadIdOrConfig !== "string") {
+            config = threadIdOrConfig;
+            if (typeof config.configurable.thread_id !== "string") {
+                throw new Error("Thread ID is required when updating state with a config.");
+            }
+            threadId = config.configurable.thread_id;
+        }
+        else {
+            config = undefined;
+            threadId = threadIdOrConfig;
+        }
+        return this.fetch(`/threads/${threadId}/state`, {
+            method: "POST",
+            json: { values, config, as_node: options?.asNode },
+        });
+    }
+    async patchState(threadIdOrConfig, metadata) {
+        let threadId;
+        if (typeof threadIdOrConfig !== "string") {
+            if (typeof threadIdOrConfig.configurable.thread_id !== "string") {
+                throw new Error("Thread ID is required when updating state with a config.");
+            }
+            threadId = threadIdOrConfig.configurable.thread_id;
+        }
+        else {
+            threadId = threadIdOrConfig;
+        }
+        return this.fetch(`/threads/${threadId}/state`, {
+            method: "PATCH",
+            json: { metadata: metadata },
+        });
+    }
+    async getHistory(threadId, options) {
+        return this.fetch(`/threads/${threadId}/history`, {
+            params: {
+                limit: options?.limit ?? 10,
+                before: options?.before,
+            },
+        });
+    }
+}
+class RunsClient extends BaseClient {
+    async stream(threadId, assistantId, options) {
+        const response = await this.asyncCaller.fetch(...this.prepareFetchOptions(`/threads/${threadId}/runs/stream`, {
+            method: "POST",
+            json: {
+                input: options?.input,
+                config: options?.config,
+                metadata: options?.metadata,
+                stream_mode: options?.streamMode,
+                assistant_id: assistantId,
+                interrupt_before: options?.interruptBefore,
+                interrupt_after: options?.interruptAfter,
+            },
+        }));
+        let parser;
+        const textDecoder = new TextDecoder();
+        const stream = (response.body || new ReadableStream({ start: (ctrl) => ctrl.close() })).pipeThrough(new TransformStream({
+            async start(ctrl) {
+                parser = createParser((event) => {
+                    if (event.type === "event" && event.data === "[DONE]") {
+                        ctrl.terminate();
+                        return;
+                    }
+                    if ("data" in event) {
+                        ctrl.enqueue({
+                            event: event.event ?? "event",
+                            data: JSON.parse(event.data),
+                        });
+                    }
+                });
+            },
+            async transform(chunk) {
+                parser.feed(textDecoder.decode(chunk));
+            },
+        }));
+        return IterableReadableStream.fromReadableStream(stream);
+    }
+    async create(threadId, assistantId, options) {
+        return this.fetch(`/threads/${threadId}/runs`, {
+            method: "POST",
+            json: {
+                input: options?.input,
+                config: options?.config,
+                metadata: options?.metadata,
+                assistant_id: assistantId,
+                interrupt_before: options?.interruptBefore,
+                interrupt_after: options?.interruptAfter,
+                webhook: options?.webhook,
+            },
+        });
+    }
+    async wait(threadId, assistantId, options) {
+        return this.fetch(`/threads/${threadId}/runs/wait`, {
+            method: "POST",
+            json: {
+                input: options?.input,
+                config: options?.config,
+                metadata: options?.metadata,
+                assistant_id: assistantId,
+                interrupt_before: options?.interruptBefore,
+                interrupt_after: options?.interruptAfter,
+            },
+        });
+    }
+    async list(threadId, options) {
+        return this.fetch(`/threads/${threadId}/runs`, {
+            params: {
+                limit: options?.limit ?? 10,
+                offset: options?.offset ?? 0,
+            },
+        });
+    }
+    async get(threadId, runId) {
+        return this.fetch(`/threads/${threadId}/runs/${runId}`);
+    }
+    async listEvents(threadId, runId, options) {
+        return this.fetch(`/threads/${threadId}/runs/${runId}/events`, {
+            params: {
+                limit: options?.limit ?? 10,
+                offset: options?.offset ?? 0,
+            },
+        });
+    }
+}
+export class Client {
+    constructor(config) {
+        Object.defineProperty(this, "assistants", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "threads", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "runs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.assistants = new AssistantsClient(config);
+        this.threads = new ThreadsClient(config);
+        this.runs = new RunsClient(config);
+    }
+}

package/dist/index.d.mts

@@ -0,0 +1 @@
+export { Client } from "./client.mjs";

package/dist/index.mjs

@@ -0,0 +1 @@
+export { Client } from "./client.mjs";

package/dist/schema.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/schema.d.ts

@@ -0,0 +1,67 @@
+type Optional<T> = T | null | undefined;
+export interface Config {
+    /**
+     * Tags for this call and any sub-calls (eg. a Chain calling an LLM).
+     * You can use these to filter calls.
+     */
+    tags: string[];
+    /**
+     * Maximum number of times a call can recurse.
+     * If not provided, defaults to 25.
+     */
+    recursion_limit: number;
+    /**
+     * Runtime values for attributes previously made configurable on this Runnable.
+     */
+    configurable: Record<string, unknown>;
+}
+export interface GraphSchema {
+    graph_id: string;
+    state_schema: Record<string, unknown>;
+    config_schema: Record<string, unknown>;
+}
+export type Metadata = Optional<Record<string, unknown>>;
+export interface Assistant {
+    assistant_id: string;
+    graph_id: string;
+    config: Config;
+    created_at: string;
+    updated_at: string;
+    metadata: Metadata;
+}
+export type AssistantGraph = Record<string, Array<Record<string, unknown>>>;
+export interface Thread {
+    thread_id: string;
+    created_at: string;
+    updated_at: string;
+    metadata: Metadata;
+}
+export interface ThreadState {
+    values: Record<string, unknown>[] | Record<string, unknown>;
+    next: string[];
+    config: Config;
+    metadata: Metadata;
+    created_at: Optional<string>;
+    parent_config: Optional<Config>;
+}
+export interface Run {
+    run_id: string;
+    thread_id: string;
+    assistant_id: string;
+    created_at: string;
+    updated_at: string;
+    status: "pending" | "running" | "error" | "success" | "timeout" | "interrupted";
+    metadata: Metadata;
+}
+export interface RunEvent {
+    event_id: string;
+    run_id: string;
+    received_at: string;
+    span_id: string;
+    event: string;
+    name: string;
+    data: Record<string, unknown>;
+    metadata: Record<string, unknown>;
+    tags: string[];
+}
+export {};

package/dist/schema.js

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

package/dist/utils/async_caller.d.mts

@@ -0,0 +1,41 @@
+type ResponseCallback = (response?: Response) => Promise<boolean>;
+export interface AsyncCallerParams {
+    /**
+     * The maximum number of concurrent calls that can be made.
+     * Defaults to `Infinity`, which means no limit.
+     */
+    maxConcurrency?: number;
+    /**
+     * The maximum number of retries that can be made for a single call,
+     * with an exponential backoff between each attempt. Defaults to 6.
+     */
+    maxRetries?: number;
+    onFailedResponseHook?: ResponseCallback;
+}
+export interface AsyncCallerCallOptions {
+    signal?: AbortSignal;
+}
+/**
+ * A class that can be used to make async calls with concurrency and retry logic.
+ *
+ * This is useful for making calls to any kind of "expensive" external resource,
+ * be it because it's rate-limited, subject to network issues, etc.
+ *
+ * Concurrent calls are limited by the `maxConcurrency` parameter, which defaults
+ * to `Infinity`. This means that by default, all calls will be made in parallel.
+ *
+ * Retries are limited by the `maxRetries` parameter, which defaults to 6. This
+ * means that by default, each call will be retried up to 6 times, with an
+ * exponential backoff between each attempt.
+ */
+export declare class AsyncCaller {
+    protected maxConcurrency: AsyncCallerParams["maxConcurrency"];
+    protected maxRetries: AsyncCallerParams["maxRetries"];
+    private queue;
+    private onFailedResponseHook?;
+    constructor(params: AsyncCallerParams);
+    call<A extends any[], T extends (...args: A) => Promise<any>>(callable: T, ...args: Parameters<T>): Promise<Awaited<ReturnType<T>>>;
+    callWithOptions<A extends any[], T extends (...args: A) => Promise<any>>(options: AsyncCallerCallOptions, callable: T, ...args: Parameters<T>): Promise<Awaited<ReturnType<T>>>;
+    fetch(...args: Parameters<typeof fetch>): ReturnType<typeof fetch>;
+}
+export {};

package/dist/utils/async_caller.mjs

@@ -0,0 +1,136 @@
+import pRetry from "p-retry";
+import PQueueMod from "p-queue";
+const STATUS_NO_RETRY = [
+    400, // Bad Request
+    401, // Unauthorized
+    403, // Forbidden
+    404, // Not Found
+    405, // Method Not Allowed
+    406, // Not Acceptable
+    407, // Proxy Authentication Required
+    408, // Request Timeout
+];
+const STATUS_IGNORE = [
+    409, // Conflict
+];
+/**
+ * A class that can be used to make async calls with concurrency and retry logic.
+ *
+ * This is useful for making calls to any kind of "expensive" external resource,
+ * be it because it's rate-limited, subject to network issues, etc.
+ *
+ * Concurrent calls are limited by the `maxConcurrency` parameter, which defaults
+ * to `Infinity`. This means that by default, all calls will be made in parallel.
+ *
+ * Retries are limited by the `maxRetries` parameter, which defaults to 6. This
+ * means that by default, each call will be retried up to 6 times, with an
+ * exponential backoff between each attempt.
+ */
+export class AsyncCaller {
+    constructor(params) {
+        Object.defineProperty(this, "maxConcurrency", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "maxRetries", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "queue", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "onFailedResponseHook", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.maxConcurrency = params.maxConcurrency ?? Infinity;
+        this.maxRetries = params.maxRetries ?? 6;
+        if ("default" in PQueueMod) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            this.queue = new PQueueMod.default({
+                concurrency: this.maxConcurrency,
+            });
+        }
+        else {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            this.queue = new PQueueMod({ concurrency: this.maxConcurrency });
+        }
+        this.onFailedResponseHook = params?.onFailedResponseHook;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    call(callable, ...args) {
+        const onFailedResponseHook = this.onFailedResponseHook;
+        return this.queue.add(() => pRetry(() => callable(...args).catch((error) => {
+            // eslint-disable-next-line no-instanceof/no-instanceof
+            console.error;
+            if (error instanceof Error) {
+                throw error;
+            }
+            else if (error instanceof Response) {
+                // TODO: try to parse the response body and throw a more informative error
+                throw new Error(`HTTP ${error.status}: ${error.statusText}`);
+            }
+            else {
+                throw new Error(error);
+            }
+        }), {
+            async onFailedAttempt(error) {
+                if (error.message.startsWith("Cancel") ||
+                    error.message.startsWith("TimeoutError") ||
+                    error.message.startsWith("AbortError")) {
+                    throw error;
+                }
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                if (error?.code === "ECONNABORTED") {
+                    throw error;
+                }
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const response = error?.response;
+                const status = response?.status;
+                if (status) {
+                    if (STATUS_NO_RETRY.includes(+status)) {
+                        throw error;
+                    }
+                    else if (STATUS_IGNORE.includes(+status)) {
+                        return;
+                    }
+                    if (onFailedResponseHook) {
+                        await onFailedResponseHook(response);
+                    }
+                }
+            },
+            // If needed we can change some of the defaults here,
+            // but they're quite sensible.
+            retries: this.maxRetries,
+            randomize: true,
+        }), { throwOnTimeout: true });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    callWithOptions(options, callable, ...args) {
+        // Note this doesn't cancel the underlying request,
+        // when available prefer to use the signal option of the underlying call
+        if (options.signal) {
+            return Promise.race([
+                this.call(callable, ...args),
+                new Promise((_, reject) => {
+                    options.signal?.addEventListener("abort", () => {
+                        reject(new Error("AbortError"));
+                    });
+                }),
+            ]);
+        }
+        return this.call(callable, ...args);
+    }
+    fetch(...args) {
+        return this.call(() => fetch(...args).then((res) => (res.ok ? res : Promise.reject(res))));
+    }
+}

package/dist/utils/stream.d.mts

@@ -0,0 +1,11 @@
+export type IterableReadableStreamInterface<T> = ReadableStream<T> & AsyncIterable<T>;
+export declare class IterableReadableStream<T> extends ReadableStream<T> implements IterableReadableStreamInterface<T> {
+    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>;
+}

package/dist/utils/stream.mjs

@@ -0,0 +1,106 @@
+/*
+ * 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 {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "reader", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+    }
+    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;
+    }
+    [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/index.cjs

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

package/index.d.cts

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

package/index.d.ts

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

package/index.js

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

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@langchain/langgraph-sdk",
+  "version": "0.0.1-rc.0",
+  "description": "Client library for interacting with the LangGraph API",
+  "type": "module",
+  "packageManager": "yarn@1.22.19",
+  "scripts": {
+    "clean": "rm -rf dist/ && node scripts/create-entrypoints.js clean",
+    "build": "yarn clean && yarn build:esm && yarn build:cjs && node scripts/create-entrypoints.js",
+    "build:esm": "rm -f src/package.json && tsc --outDir dist/ && rm -rf dist/tests dist/**/tests",
+    "build:cjs": "echo '{}' > src/package.json && tsc --outDir dist-cjs/ -p tsconfig.cjs.json && node scripts/move-cjs-to-dist.js && rm -r dist-cjs src/package.json",
+    "prepublish": "yarn run build"
+  },
+  "main": "index.js",
+  "license": "MIT",
+  "dependencies": {
+    "eventsource-parser": "^1.1.2",
+    "p-queue": "^6.6.2",
+    "p-retry": "4",
+    "uuid": "^9.0.0"
+  },
+  "devDependencies": {
+    "@tsconfig/recommended": "^1.0.2",
+    "@types/node": "^20.12.12",
+    "@types/uuid": "^9.0.1",
+    "typescript": "^5.4.5"
+  },
+  "exports": {
+    ".": {
+      "types": {
+        "import": "./index.d.ts",
+        "require": "./index.d.cts",
+        "default": "./index.d.ts"
+      },
+      "import": "./index.js",
+      "require": "./index.cjs"
+    },
+    "./client": {
+      "types": {
+        "import": "./client.d.ts",
+        "require": "./client.d.cts",
+        "default": "./client.d.ts"
+      },
+      "import": "./client.js",
+      "require": "./client.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist/",
+    "client.cjs",
+    "client.js",
+    "client.d.ts",
+    "client.d.cts",
+    "index.cjs",
+    "index.js",
+    "index.d.ts",
+    "index.d.cts"
+  ]
+}