@langchain/langgraph-sdk 0.0.41 → 0.0.43

package/dist/utils/async_caller.d.ts

@@ -0,0 +1,48 @@
+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;
+    /**
+     * Specify a custom fetch implementation.
+     *
+     * By default we expect the `fetch` is available in the global scope.
+     */
+    fetch?: typeof fetch | ((...args: any[]) => any);
+}
+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 5. This
+ * means that by default, each call will be retried up to 5 times, with an
+ * exponential backoff between each attempt.
+ */
+export declare class AsyncCaller {
+    protected maxConcurrency: AsyncCallerParams["maxConcurrency"];
+    protected maxRetries: AsyncCallerParams["maxRetries"];
+    private queue;
+    private onFailedResponseHook?;
+    private customFetch?;
+    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/env.d.ts

@@ -0,0 +1 @@
+export declare function getEnvironmentVariable(name: string): string | undefined;

package/dist/utils/env.js

@@ -0,0 +1,12 @@
+export function getEnvironmentVariable(name) {
+    // Certain setups (Deno, frontend) will throw an error if you try to access environment variables
+    try {
+        return typeof process !== "undefined"
+            ? // eslint-disable-next-line no-process-env
+                process.env?.[name]
+            : undefined;
+    }
+    catch (e) {
+        return undefined;
+    }
+}

package/dist/utils/signals.js

@@ -0,0 +1,18 @@
+export function mergeSignals(...signals) {
+    const nonZeroSignals = signals.filter((signal) => signal != null);
+    if (nonZeroSignals.length === 0)
+        return undefined;
+    if (nonZeroSignals.length === 1)
+        return nonZeroSignals[0];
+    const controller = new AbortController();
+    for (const signal of signals) {
+        if (signal?.aborted) {
+            controller.abort(signal.reason);
+            return controller.signal;
+        }
+        signal?.addEventListener("abort", () => controller.abort(signal.reason), {
+            once: true,
+        });
+    }
+    return controller.signal;
+}

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/dist/utils/stream.d.ts

@@ -0,0 +1,13 @@
+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.asyncDispose](): Promise<void>;
+    [Symbol.asyncIterator](): this;
+    static fromReadableStream<T>(stream: ReadableStream<T>): IterableReadableStream<T>;
+    static fromAsyncGenerator<T>(generator: AsyncGenerator<T>): IterableReadableStream<T>;
+}
+export {};

package/dist/utils/stream.js

@@ -0,0 +1,111 @@
+/*
+ * 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;
+    }
+    // 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph-sdk",
-  "version": "0.0.41",
+  "version": "0.0.43",
   "description": "Client library for interacting with the LangGraph API",
   "type": "module",
   "packageManager": "yarn@1.22.19",
@@ -43,6 +43,14 @@
     "react": "^18 || ^19",
     "@langchain/core": ">=0.2.31 <0.4.0"
   },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "@langchain/core": {
+      "optional": true
+    }
+  },
   "exports": {
     ".": {
       "types": {