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

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

@@ -1,6 +1,6 @@
 import { Assistant, AssistantGraph, Config, DefaultValues, GraphSchema, Metadata, Run, Thread, ThreadState, Cron } from "./schema.js";
-import { AsyncCaller, AsyncCallerParams } from "./utils/async_caller.mjs";
-import { RunsCreatePayload, RunsStreamPayload, RunsWaitPayload, StreamEvent, CronsCreatePayload, OnConflictBehavior } from "./types.mjs";
+import { AsyncCaller, AsyncCallerParams } from "./utils/async_caller.js";
+import { RunsCreatePayload, RunsStreamPayload, RunsWaitPayload, StreamEvent, CronsCreatePayload, OnConflictBehavior } from "./types.js";
 interface ClientConfig {
     apiUrl?: string;
     apiKey?: string;
@@ -85,6 +85,8 @@ export declare class AssistantsClient extends BaseClient {
         graphId: string;
         config?: Config;
         metadata?: Metadata;
+        assistantId?: string;
+        ifExists?: OnConflictBehavior;
     }): Promise<Assistant>;
     /**
      * Update an assistant.
@@ -93,7 +95,7 @@ export declare class AssistantsClient extends BaseClient {
      * @returns The updated assistant.
      */
     update(assistantId: string, payload: {
-        graphId: string;
+        graphId?: string;
         config?: Config;
         metadata?: Metadata;
     }): Promise<Assistant>;
@@ -222,7 +224,7 @@ export declare class ThreadsClient extends BaseClient {
     }): Promise<ThreadState<ValuesType>[]>;
 }
 export declare class RunsClient extends BaseClient {
-    stream(threadId: null, assistantId: string, payload?: Omit<RunsStreamPayload, "multitaskStrategy">): AsyncGenerator<{
+    stream(threadId: null, assistantId: string, payload?: Omit<RunsStreamPayload, "multitaskStrategy" | "onCompletion">): AsyncGenerator<{
         event: StreamEvent;
         data: any;
     }>;
@@ -239,7 +241,16 @@ export declare class RunsClient extends BaseClient {
      * @returns The created run.
      */
     create(threadId: string, assistantId: string, payload?: RunsCreatePayload): Promise<Run>;
-    wait(threadId: null, assistantId: string, payload?: Omit<RunsWaitPayload, "multitaskStrategy">): Promise<ThreadState["values"]>;
+    /**
+     * Create a batch of stateless background runs.
+     *
+     * @param payloads An array of payloads for creating runs.
+     * @returns An array of created runs.
+     */
+    createBatch(payloads: (RunsCreatePayload & {
+        assistantId: string;
+    })[]): Promise<Run[]>;
+    wait(threadId: null, assistantId: string, payload?: Omit<RunsWaitPayload, "multitaskStrategy" | "onCompletion">): Promise<ThreadState["values"]>;
     wait(threadId: string, assistantId: string, payload?: RunsWaitPayload): Promise<ThreadState["values"]>;
     /**
      * List all runs for a thread.
@@ -285,6 +296,20 @@ export declare class RunsClient extends BaseClient {
      * @returns
      */
     join(threadId: string, runId: string): Promise<void>;
+    /**
+     * Stream output from a run in real-time, until the run is done.
+     * Output is not buffered, so any output produced before this call will
+     * not be received here.
+     *
+     * @param threadId The ID of the thread.
+     * @param runId The ID of the run.
+     * @param signal An optional abort signal.
+     * @returns An async generator yielding stream parts.
+     */
+    joinStream(threadId: string, runId: string, signal?: AbortSignal): AsyncGenerator<{
+        event: StreamEvent;
+        data: any;
+    }>;
     /**
      * Delete a run.
      *

package/dist/{client.mjs → client.js}

@@ -1,6 +1,6 @@
-import { AsyncCaller } from "./utils/async_caller.mjs";
-import { createParser } from "eventsource-parser";
-import { IterableReadableStream } from "./utils/stream.mjs";
+import { AsyncCaller } from "./utils/async_caller.js";
+import { createParser, } from "./utils/eventsource-parser/index.js";
+import { IterableReadableStream } from "./utils/stream.js";
 class BaseClient {
     constructor(config) {
         Object.defineProperty(this, "asyncCaller", {
@@ -92,6 +92,7 @@ export class CronsClient extends BaseClient {
             interrupt_before: payload?.interruptBefore,
             interrupt_after: payload?.interruptAfter,
             webhook: payload?.webhook,
+            multitask_strategy: payload?.multitaskStrategy,
         };
         return this.fetch(`/threads/${threadId}/runs/crons`, {
             method: "POST",
@@ -114,6 +115,7 @@ export class CronsClient extends BaseClient {
             interrupt_before: payload?.interruptBefore,
             interrupt_after: payload?.interruptAfter,
             webhook: payload?.webhook,
+            multitask_strategy: payload?.multitaskStrategy,
         };
         return this.fetch(`/runs/crons`, {
             method: "POST",
@@ -184,6 +186,8 @@ export class AssistantsClient extends BaseClient {
                 graph_id: payload.graphId,
                 config: payload.config,
                 metadata: payload.metadata,
+                assistant_id: payload.assistantId,
+                if_exists: payload.ifExists,
             },
         });
     }
@@ -391,10 +395,11 @@ export class RunsClient extends BaseClient {
             interrupt_before: payload?.interruptBefore,
             interrupt_after: payload?.interruptAfter,
             checkpoint_id: payload?.checkpointId,
+            webhook: payload?.webhook,
+            multitask_strategy: payload?.multitaskStrategy,
+            on_completion: payload?.onCompletion,
+            on_disconnect: payload?.onDisconnect,
         };
-        if (payload?.multitaskStrategy != null) {
-            json["multitask_strategy"] = payload?.multitaskStrategy;
-        }
         const endpoint = threadId == null ? `/runs/stream` : `/threads/${threadId}/runs/stream`;
         const response = await this.asyncCaller.fetch(...this.prepareFetchOptions(endpoint, {
             method: "POST",
@@ -452,16 +457,31 @@ export class RunsClient extends BaseClient {
             interrupt_after: payload?.interruptAfter,
             webhook: payload?.webhook,
             checkpoint_id: payload?.checkpointId,
+            multitask_strategy: payload?.multitaskStrategy,
         };
-        if (payload?.multitaskStrategy != null) {
-            json["multitask_strategy"] = payload?.multitaskStrategy;
-        }
         return this.fetch(`/threads/${threadId}/runs`, {
             method: "POST",
             json,
             signal: payload?.signal,
         });
     }
+    /**
+     * Create a batch of stateless background runs.
+     *
+     * @param payloads An array of payloads for creating runs.
+     * @returns An array of created runs.
+     */
+    async createBatch(payloads) {
+        const filteredPayloads = payloads
+            .map((payload) => ({ ...payload, assistant_id: payload.assistantId }))
+            .map((payload) => {
+            return Object.fromEntries(Object.entries(payload).filter(([_, v]) => v !== undefined));
+        });
+        return this.fetch("/runs/batch", {
+            method: "POST",
+            json: filteredPayloads,
+        });
+    }
     /**
      * Create a run and wait for it to complete.
      *
@@ -479,10 +499,11 @@ export class RunsClient extends BaseClient {
             interrupt_before: payload?.interruptBefore,
             interrupt_after: payload?.interruptAfter,
             checkpoint_id: payload?.checkpointId,
+            webhook: payload?.webhook,
+            multitask_strategy: payload?.multitaskStrategy,
+            on_completion: payload?.onCompletion,
+            on_disconnect: payload?.onDisconnect,
         };
-        if (payload?.multitaskStrategy != null) {
-            json["multitask_strategy"] = payload?.multitaskStrategy;
-        }
         const endpoint = threadId == null ? `/runs/wait` : `/threads/${threadId}/runs/wait`;
         return this.fetch(endpoint, {
             method: "POST",
@@ -541,6 +562,54 @@ export class RunsClient extends BaseClient {
     async join(threadId, runId) {
         return this.fetch(`/threads/${threadId}/runs/${runId}/join`);
     }
+    /**
+     * Stream output from a run in real-time, until the run is done.
+     * Output is not buffered, so any output produced before this call will
+     * not be received here.
+     *
+     * @param threadId The ID of the thread.
+     * @param runId The ID of the run.
+     * @param signal An optional abort signal.
+     * @returns An async generator yielding stream parts.
+     */
+    async *joinStream(threadId, runId, signal) {
+        const response = await this.asyncCaller.fetch(...this.prepareFetchOptions(`/threads/${threadId}/runs/${runId}/stream`, {
+            method: "GET",
+            signal,
+        }));
+        let parser;
+        let onEndEvent;
+        const textDecoder = new TextDecoder();
+        const stream = (response.body || new ReadableStream({ start: (ctrl) => ctrl.close() })).pipeThrough(new TransformStream({
+            async start(ctrl) {
+                parser = createParser((event) => {
+                    if ((signal && signal.aborted) ||
+                        (event.type === "event" && event.data === "[DONE]")) {
+                        ctrl.terminate();
+                        return;
+                    }
+                    if ("data" in event) {
+                        ctrl.enqueue({
+                            event: event.event ?? "message",
+                            data: JSON.parse(event.data),
+                        });
+                    }
+                });
+                onEndEvent = () => {
+                    ctrl.enqueue({ event: "end", data: undefined });
+                };
+            },
+            async transform(chunk) {
+                const payload = textDecoder.decode(chunk);
+                parser.feed(payload);
+                // eventsource-parser will ignore events
+                // that are not terminated by a newline
+                if (payload.trim() === "event: end")
+                    onEndEvent();
+            },
+        }));
+        yield* IterableReadableStream.fromReadableStream(stream);
+    }
     /**
      * Delete a run.
      *

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/{types.d.mts → types.d.ts}

@@ -2,6 +2,8 @@ import { Config, Metadata } from "./schema.js";
 export type StreamMode = "values" | "messages" | "updates" | "events" | "debug";
 export type MultitaskStrategy = "reject" | "interrupt" | "rollback" | "enqueue";
 export type OnConflictBehavior = "raise" | "do_nothing";
+export type OnCompletionBehavior = "complete" | "continue";
+export type DisconnectMode = "cancel" | "continue";
 export type StreamEvent = "events" | "metadata" | "debug" | "updates" | "values" | "messages/partial" | "messages/metadata" | "messages/complete" | (string & {});
 interface RunsInvokePayload {
     /**
@@ -43,6 +45,24 @@ interface RunsInvokePayload {
      * Abort controller signal to cancel the run.
      */
     signal?: AbortController["signal"];
+    /**
+     * Behavior to handle run completion. Only relevant if
+     * there is a pending/inflight run on the same thread. One of:
+     * - "complete": Complete the run.
+     * - "continue": Continue the run.
+     */
+    onCompletion?: OnCompletionBehavior;
+    /**
+     * Webhook to call when the run is complete.
+     */
+    webhook?: string;
+    /**
+     * Behavior to handle disconnection. Only relevant if
+     * there is a pending/inflight run on the same thread. One of:
+     * - "cancel": Cancel the run.
+     * - "continue": Continue the run.
+     */
+    onDisconnect?: DisconnectMode;
 }
 export interface RunsStreamPayload extends RunsInvokePayload {
     /**
@@ -62,10 +82,6 @@ export interface RunsStreamPayload extends RunsInvokePayload {
     feedbackKeys?: string[];
 }
 export interface RunsCreatePayload extends RunsInvokePayload {
-    /**
-     * Webhook to call when the run is complete.
-     */
-    webhook?: string;
 }
 export interface CronsCreatePayload extends RunsCreatePayload {
     /**

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/{async_caller.d.mts → async_caller.d.ts}

@@ -16,7 +16,7 @@ export interface AsyncCallerParams {
      *
      * By default we expect the `fetch` is available in the global scope.
      */
-    fetch?: typeof fetch;
+    fetch?: typeof fetch | ((...args: any[]) => any);
 }
 export interface AsyncCallerCallOptions {
     signal?: AbortSignal;

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;