@langchain/langgraph-sdk 0.0.9 → 0.0.10

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.9",
+  "version": "0.0.10",
   "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";