@langchain/langgraph-sdk 0.0.9 → 0.0.10

package/dist/index.cjs

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = void 0;
+var client_js_1 = require("./client.cjs");
+Object.defineProperty(exports, "Client", { enumerable: true, get: function () { return client_js_1.Client; } });

package/dist/{index.d.mts → index.d.ts}

@@ -1,2 +1,2 @@
-export { Client } from "./client.mjs";
+export { Client } from "./client.js";
 export type { Assistant, AssistantGraph, Config, DefaultValues, GraphSchema, Metadata, Run, Thread, ThreadState, Cron, } from "./schema.js";

package/dist/index.js

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

package/dist/types.cjs

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

package/dist/utils/async_caller.cjs

@@ -0,0 +1,195 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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 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
+    422, // Unprocessable Entity
+];
+const STATUS_IGNORE = [
+    409, // Conflict
+];
+/**
+ * Do not rely on globalThis.Response, rather just
+ * do duck typing
+ */
+function isResponse(x) {
+    if (x == null || typeof x !== "object")
+        return false;
+    return "status" in x && "statusText" in x && "text" in x;
+}
+/**
+ * Utility error to properly handle failed requests
+ */
+class HTTPError extends Error {
+    constructor(status, message, response) {
+        super(`HTTP ${status}: ${message}`);
+        Object.defineProperty(this, "status", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "text", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "response", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.status = status;
+        this.text = message;
+        this.response = response;
+    }
+    static async fromResponse(response, options) {
+        try {
+            return new HTTPError(response.status, await response.text(), options?.includeResponse ? response : undefined);
+        }
+        catch {
+            return new HTTPError(response.status, response.statusText, options?.includeResponse ? response : undefined);
+        }
+    }
+}
+/**
+ * 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.
+ */
+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
+        });
+        Object.defineProperty(this, "customFetch", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.maxConcurrency = params.maxConcurrency ?? Infinity;
+        this.maxRetries = params.maxRetries ?? 4;
+        if ("default" in p_queue_1.default) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            this.queue = new p_queue_1.default.default({
+                concurrency: this.maxConcurrency,
+            });
+        }
+        else {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            this.queue = new p_queue_1.default({ concurrency: this.maxConcurrency });
+        }
+        this.onFailedResponseHook = params?.onFailedResponseHook;
+        this.customFetch = params.fetch;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    call(callable, ...args) {
+        const onFailedResponseHook = this.onFailedResponseHook;
+        return this.queue.add(() => (0, p_retry_1.default)(() => callable(...args).catch(async (error) => {
+            // eslint-disable-next-line no-instanceof/no-instanceof
+            if (error instanceof Error) {
+                throw error;
+            }
+            else if (isResponse(error)) {
+                throw await HTTPError.fromResponse(error, {
+                    includeResponse: !!onFailedResponseHook,
+                });
+            }
+            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;
+                }
+                if (error instanceof HTTPError) {
+                    if (STATUS_NO_RETRY.includes(error.status)) {
+                        throw error;
+                    }
+                    else if (STATUS_IGNORE.includes(error.status)) {
+                        return;
+                    }
+                    if (onFailedResponseHook && error.response) {
+                        await onFailedResponseHook(error.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) {
+        const fetchFn = this.customFetch ?? fetch;
+        return this.call(() => fetchFn(...args).then((res) => (res.ok ? res : Promise.reject(res))));
+    }
+}
+exports.AsyncCaller = AsyncCaller;

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

@@ -0,0 +1,7 @@
+"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

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

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

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

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

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createParser = void 0;
+/**
+ * Creates a new EventSource parser.
+ *
+ * @param onParse - Callback to invoke when a new event is parsed, or a new reconnection interval
+ *                  has been sent from the server
+ *
+ * @returns A new EventSource parser, with `parse` and `reset` methods.
+ * @public
+ */
+function createParser(onParse) {
+    // Processing state
+    let isFirstChunk;
+    let buffer;
+    let startingPosition;
+    let startingFieldLength;
+    // Event state
+    let eventId;
+    let eventName;
+    let data;
+    reset();
+    return { feed, reset };
+    function reset() {
+        isFirstChunk = true;
+        buffer = "";
+        startingPosition = 0;
+        startingFieldLength = -1;
+        eventId = undefined;
+        eventName = undefined;
+        data = "";
+    }
+    function feed(chunk) {
+        buffer = buffer ? buffer + chunk : chunk;
+        // Strip any UTF8 byte order mark (BOM) at the start of the stream.
+        // Note that we do not strip any non - UTF8 BOM, as eventsource streams are
+        // always decoded as UTF8 as per the specification.
+        if (isFirstChunk && hasBom(buffer)) {
+            buffer = buffer.slice(BOM.length);
+        }
+        isFirstChunk = false;
+        // Set up chunk-specific processing state
+        const length = buffer.length;
+        let position = 0;
+        let discardTrailingNewline = false;
+        // Read the current buffer byte by byte
+        while (position < length) {
+            // EventSource allows for carriage return + line feed, which means we
+            // need to ignore a linefeed character if the previous character was a
+            // carriage return
+            // @todo refactor to reduce nesting, consider checking previous byte?
+            // @todo but consider multiple chunks etc
+            if (discardTrailingNewline) {
+                if (buffer[position] === "\n") {
+                    ++position;
+                }
+                discardTrailingNewline = false;
+            }
+            let lineLength = -1;
+            let fieldLength = startingFieldLength;
+            let character;
+            for (let index = startingPosition; lineLength < 0 && index < length; ++index) {
+                character = buffer[index];
+                if (character === ":" && fieldLength < 0) {
+                    fieldLength = index - position;
+                }
+                else if (character === "\r") {
+                    discardTrailingNewline = true;
+                    lineLength = index - position;
+                }
+                else if (character === "\n") {
+                    lineLength = index - position;
+                }
+            }
+            if (lineLength < 0) {
+                startingPosition = length - position;
+                startingFieldLength = fieldLength;
+                break;
+            }
+            else {
+                startingPosition = 0;
+                startingFieldLength = -1;
+            }
+            parseEventStreamLine(buffer, position, fieldLength, lineLength);
+            position += lineLength + 1;
+        }
+        if (position === length) {
+            // If we consumed the entire buffer to read the event, reset the buffer
+            buffer = "";
+        }
+        else if (position > 0) {
+            // If there are bytes left to process, set the buffer to the unprocessed
+            // portion of the buffer only
+            buffer = buffer.slice(position);
+        }
+    }
+    function parseEventStreamLine(lineBuffer, index, fieldLength, lineLength) {
+        if (lineLength === 0) {
+            // We reached the last line of this event
+            if (data.length > 0) {
+                onParse({
+                    type: "event",
+                    id: eventId,
+                    event: eventName || undefined,
+                    data: data.slice(0, -1), // remove trailing newline
+                });
+                data = "";
+                eventId = undefined;
+            }
+            eventName = undefined;
+            return;
+        }
+        const noValue = fieldLength < 0;
+        const field = lineBuffer.slice(index, index + (noValue ? lineLength : fieldLength));
+        let step = 0;
+        if (noValue) {
+            step = lineLength;
+        }
+        else if (lineBuffer[index + fieldLength + 1] === " ") {
+            step = fieldLength + 2;
+        }
+        else {
+            step = fieldLength + 1;
+        }
+        const position = index + step;
+        const valueLength = lineLength - step;
+        const value = lineBuffer.slice(position, position + valueLength).toString();
+        if (field === "data") {
+            data += value ? `${value}\n` : "\n";
+        }
+        else if (field === "event") {
+            eventName = value;
+        }
+        else if (field === "id" && !value.includes("\u0000")) {
+            eventId = value;
+        }
+        else if (field === "retry") {
+            const retry = parseInt(value, 10);
+            if (!Number.isNaN(retry)) {
+                onParse({ type: "reconnect-interval", value: retry });
+            }
+        }
+    }
+}
+exports.createParser = createParser;
+const BOM = [239, 187, 191];
+function hasBom(buffer) {
+    return BOM.every((charCode, index) => buffer.charCodeAt(index) === charCode);
+}

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

@@ -0,0 +1,18 @@
+/**
+ * EventSource/Server-Sent Events parser
+ * @see https://html.spec.whatwg.org/multipage/server-sent-events.html
+ *
+ * Based on code from the {@link https://github.com/EventSource/eventsource | EventSource module},
+ * which is licensed under the MIT license. And copyrighted the EventSource GitHub organisation.
+ */
+import type { EventSourceParseCallback, EventSourceParser } from "./types.js";
+/**
+ * Creates a new EventSource parser.
+ *
+ * @param onParse - Callback to invoke when a new event is parsed, or a new reconnection interval
+ *                  has been sent from the server
+ *
+ * @returns A new EventSource parser, with `parse` and `reset` methods.
+ * @public
+ */
+export declare function createParser(onParse: EventSourceParseCallback): EventSourceParser;

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

@@ -0,0 +1,146 @@
+/**
+ * Creates a new EventSource parser.
+ *
+ * @param onParse - Callback to invoke when a new event is parsed, or a new reconnection interval
+ *                  has been sent from the server
+ *
+ * @returns A new EventSource parser, with `parse` and `reset` methods.
+ * @public
+ */
+export function createParser(onParse) {
+    // Processing state
+    let isFirstChunk;
+    let buffer;
+    let startingPosition;
+    let startingFieldLength;
+    // Event state
+    let eventId;
+    let eventName;
+    let data;
+    reset();
+    return { feed, reset };
+    function reset() {
+        isFirstChunk = true;
+        buffer = "";
+        startingPosition = 0;
+        startingFieldLength = -1;
+        eventId = undefined;
+        eventName = undefined;
+        data = "";
+    }
+    function feed(chunk) {
+        buffer = buffer ? buffer + chunk : chunk;
+        // Strip any UTF8 byte order mark (BOM) at the start of the stream.
+        // Note that we do not strip any non - UTF8 BOM, as eventsource streams are
+        // always decoded as UTF8 as per the specification.
+        if (isFirstChunk && hasBom(buffer)) {
+            buffer = buffer.slice(BOM.length);
+        }
+        isFirstChunk = false;
+        // Set up chunk-specific processing state
+        const length = buffer.length;
+        let position = 0;
+        let discardTrailingNewline = false;
+        // Read the current buffer byte by byte
+        while (position < length) {
+            // EventSource allows for carriage return + line feed, which means we
+            // need to ignore a linefeed character if the previous character was a
+            // carriage return
+            // @todo refactor to reduce nesting, consider checking previous byte?
+            // @todo but consider multiple chunks etc
+            if (discardTrailingNewline) {
+                if (buffer[position] === "\n") {
+                    ++position;
+                }
+                discardTrailingNewline = false;
+            }
+            let lineLength = -1;
+            let fieldLength = startingFieldLength;
+            let character;
+            for (let index = startingPosition; lineLength < 0 && index < length; ++index) {
+                character = buffer[index];
+                if (character === ":" && fieldLength < 0) {
+                    fieldLength = index - position;
+                }
+                else if (character === "\r") {
+                    discardTrailingNewline = true;
+                    lineLength = index - position;
+                }
+                else if (character === "\n") {
+                    lineLength = index - position;
+                }
+            }
+            if (lineLength < 0) {
+                startingPosition = length - position;
+                startingFieldLength = fieldLength;
+                break;
+            }
+            else {
+                startingPosition = 0;
+                startingFieldLength = -1;
+            }
+            parseEventStreamLine(buffer, position, fieldLength, lineLength);
+            position += lineLength + 1;
+        }
+        if (position === length) {
+            // If we consumed the entire buffer to read the event, reset the buffer
+            buffer = "";
+        }
+        else if (position > 0) {
+            // If there are bytes left to process, set the buffer to the unprocessed
+            // portion of the buffer only
+            buffer = buffer.slice(position);
+        }
+    }
+    function parseEventStreamLine(lineBuffer, index, fieldLength, lineLength) {
+        if (lineLength === 0) {
+            // We reached the last line of this event
+            if (data.length > 0) {
+                onParse({
+                    type: "event",
+                    id: eventId,
+                    event: eventName || undefined,
+                    data: data.slice(0, -1), // remove trailing newline
+                });
+                data = "";
+                eventId = undefined;
+            }
+            eventName = undefined;
+            return;
+        }
+        const noValue = fieldLength < 0;
+        const field = lineBuffer.slice(index, index + (noValue ? lineLength : fieldLength));
+        let step = 0;
+        if (noValue) {
+            step = lineLength;
+        }
+        else if (lineBuffer[index + fieldLength + 1] === " ") {
+            step = fieldLength + 2;
+        }
+        else {
+            step = fieldLength + 1;
+        }
+        const position = index + step;
+        const valueLength = lineLength - step;
+        const value = lineBuffer.slice(position, position + valueLength).toString();
+        if (field === "data") {
+            data += value ? `${value}\n` : "\n";
+        }
+        else if (field === "event") {
+            eventName = value;
+        }
+        else if (field === "id" && !value.includes("\u0000")) {
+            eventId = value;
+        }
+        else if (field === "retry") {
+            const retry = parseInt(value, 10);
+            if (!Number.isNaN(retry)) {
+                onParse({ type: "reconnect-interval", value: retry });
+            }
+        }
+    }
+}
+const BOM = [239, 187, 191];
+function hasBom(buffer) {
+    return BOM.every((charCode, index) => buffer.charCodeAt(index) === charCode);
+}

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventSourceParserStream = void 0;
+const parse_js_1 = require("./parse.cjs");
+/**
+ * A TransformStream that ingests a stream of strings and produces a stream of ParsedEvents.
+ *
+ * @example
+ * ```
+ * const eventStream =
+ *   response.body
+ *     .pipeThrough(new TextDecoderStream())
+ *     .pipeThrough(new EventSourceParserStream())
+ * ```
+ * @public
+ */
+class EventSourceParserStream extends TransformStream {
+    constructor() {
+        let parser;
+        super({
+            start(controller) {
+                parser = (0, parse_js_1.createParser)((event) => {
+                    if (event.type === "event") {
+                        controller.enqueue(event);
+                    }
+                });
+            },
+            transform(chunk) {
+                parser.feed(chunk);
+            },
+        });
+    }
+}
+exports.EventSourceParserStream = EventSourceParserStream;

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

@@ -0,0 +1,17 @@
+import type { ParsedEvent } from "./types.js";
+/**
+ * A TransformStream that ingests a stream of strings and produces a stream of ParsedEvents.
+ *
+ * @example
+ * ```
+ * const eventStream =
+ *   response.body
+ *     .pipeThrough(new TextDecoderStream())
+ *     .pipeThrough(new EventSourceParserStream())
+ * ```
+ * @public
+ */
+export declare class EventSourceParserStream extends TransformStream<string, ParsedEvent> {
+    constructor();
+}
+export type { ParsedEvent } from "./types.js";

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

@@ -0,0 +1,30 @@
+import { createParser } from "./parse.js";
+/**
+ * A TransformStream that ingests a stream of strings and produces a stream of ParsedEvents.
+ *
+ * @example
+ * ```
+ * const eventStream =
+ *   response.body
+ *     .pipeThrough(new TextDecoderStream())
+ *     .pipeThrough(new EventSourceParserStream())
+ * ```
+ * @public
+ */
+export class EventSourceParserStream extends TransformStream {
+    constructor() {
+        let parser;
+        super({
+            start(controller) {
+                parser = createParser((event) => {
+                    if (event.type === "event") {
+                        controller.enqueue(event);
+                    }
+                });
+            },
+            transform(chunk) {
+                parser.feed(chunk);
+            },
+        });
+    }
+}

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

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