@langchain/core 0.2.21 → 0.2.22-rc.1

package/dist/runnables/remote.cjs

@@ -229,6 +229,19 @@ function serialize(input) {
     }
     return input;
 }
+/**
+ * Client for interacting with LangChain runnables
+ * that are hosted as LangServe endpoints.
+ *
+ * Allows you to interact with hosted runnables using the standard
+ * `.invoke()`, `.stream()`, `.streamEvents()`, etc. methods that
+ * other runnables support.
+ *
+ * @param url - The base URL of the LangServe endpoint.
+ * @param options - Optional configuration for the remote runnable, including timeout and headers.
+ * @param fetch - Optional custom fetch implementation.
+ * @param fetchRequestOptions - Optional additional options for fetch requests.
+ */
 class RemoteRunnable extends base_js_1.Runnable {
     constructor(fields) {
         super(fields);
@@ -244,25 +257,43 @@ class RemoteRunnable extends base_js_1.Runnable {
             writable: true,
             value: void 0
         });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        Object.defineProperty(this, "fetchImplementation", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: fetch
+        });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        Object.defineProperty(this, "fetchRequestOptions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "lc_namespace", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: ["langchain", "schema", "runnable", "remote"]
         });
-        const { url, options } = fields;
+        const { url, options, fetch: fetchImplementation, fetchRequestOptions, } = fields;
         this.url = url.replace(/\/$/, ""); // remove trailing slash
         this.options = options;
+        this.fetchImplementation = fetchImplementation ?? this.fetchImplementation;
+        this.fetchRequestOptions = fetchRequestOptions;
     }
     async post(path, body, signal) {
-        return fetch(`${this.url}${path}`, {
+        return this.fetchImplementation(`${this.url}${path}`, {
             method: "POST",
             body: JSON.stringify(serialize(body)),
+            signal: signal ?? AbortSignal.timeout(this.options?.timeout ?? 60000),
+            ...this.fetchRequestOptions,
             headers: {
                 "Content-Type": "application/json",
+                ...this.fetchRequestOptions?.headers,
                 ...this.options?.headers,
             },
-            signal: signal ?? AbortSignal.timeout(this.options?.timeout ?? 60000),
         });
     }
     async _invoke(input, options, _) {

package/dist/runnables/remote.d.ts

@@ -7,13 +7,30 @@ type RemoteRunnableOptions = {
     timeout?: number;
     headers?: Record<string, unknown>;
 };
+/**
+ * Client for interacting with LangChain runnables
+ * that are hosted as LangServe endpoints.
+ *
+ * Allows you to interact with hosted runnables using the standard
+ * `.invoke()`, `.stream()`, `.streamEvents()`, etc. methods that
+ * other runnables support.
+ *
+ * @param url - The base URL of the LangServe endpoint.
+ * @param options - Optional configuration for the remote runnable, including timeout and headers.
+ * @param fetch - Optional custom fetch implementation.
+ * @param fetchRequestOptions - Optional additional options for fetch requests.
+ */
 export declare class RemoteRunnable<RunInput, RunOutput, CallOptions extends RunnableConfig> extends Runnable<RunInput, RunOutput, CallOptions> {
     private url;
     private options?;
+    fetchImplementation: (...args: any[]) => any;
+    fetchRequestOptions?: Record<string, any>;
     lc_namespace: string[];
     constructor(fields: {
         url: string;
         options?: RemoteRunnableOptions;
+        fetch?: (...args: any[]) => any;
+        fetchRequestOptions?: Record<string, any>;
     });
     private post;
     _invoke(input: RunInput, options?: Partial<CallOptions>, _?: CallbackManagerForChainRun): Promise<RunOutput>;

package/dist/runnables/remote.js

@@ -226,6 +226,19 @@ function serialize(input) {
     }
     return input;
 }
+/**
+ * Client for interacting with LangChain runnables
+ * that are hosted as LangServe endpoints.
+ *
+ * Allows you to interact with hosted runnables using the standard
+ * `.invoke()`, `.stream()`, `.streamEvents()`, etc. methods that
+ * other runnables support.
+ *
+ * @param url - The base URL of the LangServe endpoint.
+ * @param options - Optional configuration for the remote runnable, including timeout and headers.
+ * @param fetch - Optional custom fetch implementation.
+ * @param fetchRequestOptions - Optional additional options for fetch requests.
+ */
 export class RemoteRunnable extends Runnable {
     constructor(fields) {
         super(fields);
@@ -241,25 +254,43 @@ export class RemoteRunnable extends Runnable {
             writable: true,
             value: void 0
         });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        Object.defineProperty(this, "fetchImplementation", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: fetch
+        });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        Object.defineProperty(this, "fetchRequestOptions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "lc_namespace", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: ["langchain", "schema", "runnable", "remote"]
         });
-        const { url, options } = fields;
+        const { url, options, fetch: fetchImplementation, fetchRequestOptions, } = fields;
         this.url = url.replace(/\/$/, ""); // remove trailing slash
         this.options = options;
+        this.fetchImplementation = fetchImplementation ?? this.fetchImplementation;
+        this.fetchRequestOptions = fetchRequestOptions;
     }
     async post(path, body, signal) {
-        return fetch(`${this.url}${path}`, {
+        return this.fetchImplementation(`${this.url}${path}`, {
             method: "POST",
             body: JSON.stringify(serialize(body)),
+            signal: signal ?? AbortSignal.timeout(this.options?.timeout ?? 60000),
+            ...this.fetchRequestOptions,
             headers: {
                 "Content-Type": "application/json",
+                ...this.fetchRequestOptions?.headers,
                 ...this.options?.headers,
             },
-            signal: signal ?? AbortSignal.timeout(this.options?.timeout ?? 60000),
         });
     }
     async _invoke(input, options, _) {

package/dist/utils/event_source_parse.cjs

@@ -15,21 +15,43 @@ exports.EventStreamContentType = "text/event-stream";
  * @param onChunk A function that will be called on each new byte chunk in the stream.
  * @returns {Promise<void>} A promise that will be resolved when the stream closes.
  */
-async function getBytes(stream, onChunk) {
-    const reader = stream.getReader();
-    // CHANGED: Introduced a "flush" mechanism to process potential pending messages when the stream ends.
-    //          This change is essential to ensure that we capture every last piece of information from streams,
-    //          such as those from Azure OpenAI, which may not terminate with a blank line. Without this
-    //          mechanism, we risk ignoring a possibly significant last message.
-    //          See https://github.com/langchain-ai/langchainjs/issues/1299 for details.
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-        const result = await reader.read();
-        if (result.done) {
+async function getBytes(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+stream, onChunk) {
+    // eslint-disable-next-line no-instanceof/no-instanceof
+    if (stream instanceof ReadableStream) {
+        const reader = stream.getReader();
+        // CHANGED: Introduced a "flush" mechanism to process potential pending messages when the stream ends.
+        //          This change is essential to ensure that we capture every last piece of information from streams,
+        //          such as those from Azure OpenAI, which may not terminate with a blank line. Without this
+        //          mechanism, we risk ignoring a possibly significant last message.
+        //          See https://github.com/langchain-ai/langchainjs/issues/1299 for details.
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const result = await reader.read();
+            if (result.done) {
+                onChunk(new Uint8Array(), true);
+                break;
+            }
+            onChunk(result.value);
+        }
+    }
+    else {
+        try {
+            // Handle Node.js Readable streams with async iteration
+            for await (const chunk of stream) {
+                onChunk(new Uint8Array(chunk));
+            }
             onChunk(new Uint8Array(), true);
-            break;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        }
+        catch (e) {
+            throw new Error([
+                "Parsing event source stream failed.",
+                "Ensure your implementation of fetch returns a web or Node readable stream.",
+                `Error: ${e.message}`,
+            ].join("\n"));
         }
-        onChunk(result.value);
     }
 }
 exports.getBytes = getBytes;

package/dist/utils/event_source_parse.d.ts

@@ -20,7 +20,7 @@ export interface EventSourceMessage {
  * @param onChunk A function that will be called on each new byte chunk in the stream.
  * @returns {Promise<void>} A promise that will be resolved when the stream closes.
  */
-export declare function getBytes(stream: ReadableStream<Uint8Array>, onChunk: (arr: Uint8Array, flush?: boolean) => void): Promise<void>;
+export declare function getBytes(stream: ReadableStream<Uint8Array> | AsyncIterable<any>, onChunk: (arr: Uint8Array, flush?: boolean) => void): Promise<void>;
 /**
  * Parses arbitary byte chunks into EventSource line buffers.
  * Each line should be of the format "field: value" and ends with \r, \n, or \r\n.

package/dist/utils/event_source_parse.js

@@ -12,21 +12,43 @@ export const EventStreamContentType = "text/event-stream";
  * @param onChunk A function that will be called on each new byte chunk in the stream.
  * @returns {Promise<void>} A promise that will be resolved when the stream closes.
  */
-export async function getBytes(stream, onChunk) {
-    const reader = stream.getReader();
-    // CHANGED: Introduced a "flush" mechanism to process potential pending messages when the stream ends.
-    //          This change is essential to ensure that we capture every last piece of information from streams,
-    //          such as those from Azure OpenAI, which may not terminate with a blank line. Without this
-    //          mechanism, we risk ignoring a possibly significant last message.
-    //          See https://github.com/langchain-ai/langchainjs/issues/1299 for details.
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-        const result = await reader.read();
-        if (result.done) {
+export async function getBytes(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+stream, onChunk) {
+    // eslint-disable-next-line no-instanceof/no-instanceof
+    if (stream instanceof ReadableStream) {
+        const reader = stream.getReader();
+        // CHANGED: Introduced a "flush" mechanism to process potential pending messages when the stream ends.
+        //          This change is essential to ensure that we capture every last piece of information from streams,
+        //          such as those from Azure OpenAI, which may not terminate with a blank line. Without this
+        //          mechanism, we risk ignoring a possibly significant last message.
+        //          See https://github.com/langchain-ai/langchainjs/issues/1299 for details.
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const result = await reader.read();
+            if (result.done) {
+                onChunk(new Uint8Array(), true);
+                break;
+            }
+            onChunk(result.value);
+        }
+    }
+    else {
+        try {
+            // Handle Node.js Readable streams with async iteration
+            for await (const chunk of stream) {
+                onChunk(new Uint8Array(chunk));
+            }
             onChunk(new Uint8Array(), true);
-            break;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        }
+        catch (e) {
+            throw new Error([
+                "Parsing event source stream failed.",
+                "Ensure your implementation of fetch returns a web or Node readable stream.",
+                `Error: ${e.message}`,
+            ].join("\n"));
         }
-        onChunk(result.value);
     }
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/core",
-  "version": "0.2.21",
+  "version": "0.2.22-rc.1",
   "description": "Core LangChain.js abstractions and schemas",
   "type": "module",
   "engines": {