@langchain/langgraph-sdk 0.0.8 → 0.0.10-rc.0

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 });

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

@@ -0,0 +1,81 @@
+/**
+ * EventSource parser instance.
+ *
+ * Needs to be reset between reconnections/when switching data source, using the `reset()` method.
+ *
+ * @public
+ */
+export interface EventSourceParser {
+    /**
+     * Feeds the parser another chunk. The method _does not_ return a parsed message.
+     * Instead, if the chunk was a complete message (or completed a previously incomplete message),
+     * it will invoke the `onParse` callback used to create the parsers.
+     *
+     * @param chunk - The chunk to parse. Can be a partial, eg in the case of streaming messages.
+     * @public
+     */
+    feed(chunk: string): void;
+    /**
+     * Resets the parser state. This is required when you have a new stream of messages -
+     * for instance in the case of a client being disconnected and reconnecting.
+     *
+     * @public
+     */
+    reset(): void;
+}
+/**
+ * A parsed EventSource event
+ *
+ * @public
+ */
+export interface ParsedEvent {
+    /**
+     * Differentiates the type from reconnection intervals and other types of messages
+     * Not to be confused with `event`.
+     */
+    type: "event";
+    /**
+     * The event type sent from the server. Note that this differs from the browser `EventSource`
+     * implementation in that browsers will default this to `message`, whereas this parser will
+     * leave this as `undefined` if not explicitly declared.
+     */
+    event?: string;
+    /**
+     * ID of the message, if any was provided by the server. Can be used by clients to keep the
+     * last received message ID in sync when reconnecting.
+     */
+    id?: string;
+    /**
+     * The data received for this message
+     */
+    data: string;
+}
+/**
+ * An event emitted from the parser when the server sends a value in the `retry` field,
+ * indicating how many seconds the client should wait before attempting to reconnect.
+ *
+ * @public
+ */
+export interface ReconnectInterval {
+    /**
+     * Differentiates the type from `event` and other types of messages
+     */
+    type: "reconnect-interval";
+    /**
+     * Number of seconds to wait before reconnecting. Note that the parser does not care about
+     * this value at all - it only emits the value for clients to use.
+     */
+    value: number;
+}
+/**
+ * The different types of messages the parsed can emit to the `onParse` callback
+ *
+ * @public
+ */
+export type ParseEvent = ParsedEvent | ReconnectInterval;
+/**
+ * Callback passed as the `onParse` callback to a parser
+ *
+ * @public
+ */
+export type EventSourceParseCallback = (event: ParseEvent) => void;

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

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

package/dist/utils/stream.cjs

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IterableReadableStream = void 0;
+/*
+ * Support async iterator syntax for ReadableStreams in all environments.
+ * Source: https://github.com/MattiasBuelens/web-streams-polyfill/pull/122#issuecomment-1627354490
+ */
+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);
+            },
+        });
+    }
+}
+exports.IterableReadableStream = IterableReadableStream;

package/dist/utils/{stream.d.mts → stream.d.ts}

@@ -5,6 +5,7 @@ export declare class IterableReadableStream<T> extends ReadableStream<T> impleme
     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>;

package/dist/utils/{stream.mjs → stream.js}

@@ -60,6 +60,11 @@ export class IterableReadableStream extends ReadableStream {
         }
         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;
     }

package/index.d.ts

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

package/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph-sdk",
-  "version": "0.0.8",
+  "version": "0.0.10-rc.0",
   "description": "Client library for interacting with the LangGraph API",
   "type": "module",
   "packageManager": "yarn@1.22.19",
@@ -17,7 +17,6 @@
   "license": "MIT",
   "dependencies": {
     "@types/json-schema": "^7.0.15",
-    "eventsource-parser": "^1.1.2",
     "p-queue": "^6.6.2",
     "p-retry": "4",
     "uuid": "^9.0.0"

package/dist/index.mjs

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