@langchain/core 0.2.22 → 0.2.24

package/dist/runnables/base.cjs

@@ -111,10 +111,11 @@ class Runnable extends serializable_js_1.Serializable {
      * @returns A new RunnableWithFallbacks.
      */
     withFallbacks(fields) {
+        const fallbacks = Array.isArray(fields) ? fields : fields.fallbacks;
         // eslint-disable-next-line @typescript-eslint/no-use-before-define
         return new RunnableWithFallbacks({
             runnable: this,
-            fallbacks: fields.fallbacks,
+            fallbacks,
         });
     }
     _getOptionsList(options, length = 0) {
@@ -1673,6 +1674,22 @@ class RunnableParallel extends RunnableMap {
 exports.RunnableParallel = RunnableParallel;
 /**
  * A Runnable that can fallback to other Runnables if it fails.
+ * External APIs (e.g., APIs for a language model) may at times experience
+ * degraded performance or even downtime.
+ *
+ * In these cases, it can be useful to have a fallback Runnable that can be
+ * used in place of the original Runnable (e.g., fallback to another LLM provider).
+ *
+ * Fallbacks can be defined at the level of a single Runnable, or at the level
+ * of a chain of Runnables. Fallbacks are tried in order until one succeeds or
+ * all fail.
+ *
+ * While you can instantiate a `RunnableWithFallbacks` directly, it is usually
+ * more convenient to use the `withFallbacks` method on an existing Runnable.
+ *
+ * When streaming, fallbacks will only be called on failures during the initial
+ * stream creation. Errors that occur after a stream starts will not fallback
+ * to the next Runnable.
  */
 class RunnableWithFallbacks extends Runnable {
     static lc_name() {
@@ -1738,6 +1755,51 @@ class RunnableWithFallbacks extends Runnable {
         await runManager?.handleChainError(firstError);
         throw firstError;
     }
+    async *_streamIterator(input, options) {
+        const config = (0, config_js_1.ensureConfig)(options);
+        const callbackManager_ = await (0, config_js_1.getCallbackManagerForConfig)(options);
+        const { runId, ...otherConfigFields } = config;
+        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), runId, undefined, undefined, undefined, otherConfigFields?.runName);
+        let firstError;
+        let stream;
+        for (const runnable of this.runnables()) {
+            config?.signal?.throwIfAborted();
+            const childConfig = (0, config_js_1.patchConfig)(otherConfigFields, {
+                callbacks: runManager?.getChild(),
+            });
+            try {
+                stream = await runnable.stream(input, childConfig);
+                break;
+            }
+            catch (e) {
+                if (firstError === undefined) {
+                    firstError = e;
+                }
+            }
+        }
+        if (stream === undefined) {
+            const error = firstError ?? new Error("No error stored at end of fallback.");
+            await runManager?.handleChainError(error);
+            throw error;
+        }
+        let output;
+        try {
+            for await (const chunk of stream) {
+                yield chunk;
+                try {
+                    output = output === undefined ? output : (0, stream_js_1.concat)(output, chunk);
+                }
+                catch (e) {
+                    output = undefined;
+                }
+            }
+        }
+        catch (e) {
+            await runManager?.handleChainError(e);
+            throw e;
+        }
+        await runManager?.handleChainEnd(_coerceToDict(output, "output"));
+    }
     async batch(inputs, options, batchOptions) {
         if (batchOptions?.returnExceptions) {
             throw new Error("Not implemented.");

package/dist/runnables/base.d.ts

@@ -67,7 +67,7 @@ export declare abstract class Runnable<RunInput = any, RunOutput = any, CallOpti
      */
     withFallbacks(fields: {
         fallbacks: Runnable<RunInput, RunOutput>[];
-    }): RunnableWithFallbacks<RunInput, RunOutput>;
+    } | Runnable<RunInput, RunOutput>[]): RunnableWithFallbacks<RunInput, RunOutput>;
     protected _getOptionsList<O extends CallOptions & {
         runType?: string;
     }>(options: Partial<O> | Partial<O>[], length?: number): Partial<O>[];
@@ -187,6 +187,7 @@ export declare abstract class Runnable<RunInput = any, RunOutput = any, CallOpti
      *
      * **ATTENTION** This reference table is for the V2 version of the schema.
      *
+     * ```md
      * +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+
      * | event                | name             | chunk                           | input                                         | output                                          |
      * +======================+==================+=================================+===============================================+=================================================+
@@ -220,6 +221,7 @@ export declare abstract class Runnable<RunInput = any, RunOutput = any, CallOpti
      * +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+
      * | on_prompt_end        | [template_name]  |                                 | {"question": "hello"}                         | ChatPromptValue(messages: [SystemMessage, ...]) |
      * +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+
+     * ```
      *
      * The "on_chain_*" events are the default for Runnables that don't fit one of the above categories.
      *
@@ -229,6 +231,7 @@ export declare abstract class Runnable<RunInput = any, RunOutput = any, CallOpti
      *
      * A custom event has following format:
      *
+     * ```md
      * +-----------+------+-----------------------------------------------------------------------------------------------------------+
      * | Attribute | Type | Description                                                                                               |
      * +===========+======+===========================================================================================================+
@@ -236,9 +239,10 @@ export declare abstract class Runnable<RunInput = any, RunOutput = any, CallOpti
      * +-----------+------+-----------------------------------------------------------------------------------------------------------+
      * | data      | Any  | The data associated with the event. This can be anything, though we suggest making it JSON serializable.  |
      * +-----------+------+-----------------------------------------------------------------------------------------------------------+
+     * ```
      *
      * Here's an example:
-     * @example
+     *
      * ```ts
      * import { RunnableLambda } from "@langchain/core/runnables";
      * import { dispatchCustomEvent } from "@langchain/core/callbacks/dispatch";
@@ -568,6 +572,22 @@ export declare class RunnableParallel<RunInput> extends RunnableMap<RunInput> {
 }
 /**
  * A Runnable that can fallback to other Runnables if it fails.
+ * External APIs (e.g., APIs for a language model) may at times experience
+ * degraded performance or even downtime.
+ *
+ * In these cases, it can be useful to have a fallback Runnable that can be
+ * used in place of the original Runnable (e.g., fallback to another LLM provider).
+ *
+ * Fallbacks can be defined at the level of a single Runnable, or at the level
+ * of a chain of Runnables. Fallbacks are tried in order until one succeeds or
+ * all fail.
+ *
+ * While you can instantiate a `RunnableWithFallbacks` directly, it is usually
+ * more convenient to use the `withFallbacks` method on an existing Runnable.
+ *
+ * When streaming, fallbacks will only be called on failures during the initial
+ * stream creation. Errors that occur after a stream starts will not fallback
+ * to the next Runnable.
  */
 export declare class RunnableWithFallbacks<RunInput, RunOutput> extends Runnable<RunInput, RunOutput> {
     static lc_name(): string;
@@ -581,6 +601,7 @@ export declare class RunnableWithFallbacks<RunInput, RunOutput> extends Runnable
     });
     runnables(): Generator<Runnable<RunInput, RunOutput, RunnableConfig>, void, unknown>;
     invoke(input: RunInput, options?: Partial<RunnableConfig>): Promise<RunOutput>;
+    _streamIterator(input: RunInput, options?: Partial<RunnableConfig> | undefined): AsyncGenerator<RunOutput>;
     batch(inputs: RunInput[], options?: Partial<RunnableConfig> | Partial<RunnableConfig>[], batchOptions?: RunnableBatchOptions & {
         returnExceptions?: false;
     }): Promise<RunOutput[]>;

package/dist/runnables/base.js

@@ -104,10 +104,11 @@ export class Runnable extends Serializable {
      * @returns A new RunnableWithFallbacks.
      */
     withFallbacks(fields) {
+        const fallbacks = Array.isArray(fields) ? fields : fields.fallbacks;
         // eslint-disable-next-line @typescript-eslint/no-use-before-define
         return new RunnableWithFallbacks({
             runnable: this,
-            fallbacks: fields.fallbacks,
+            fallbacks,
         });
     }
     _getOptionsList(options, length = 0) {
@@ -1657,6 +1658,22 @@ export class RunnableParallel extends RunnableMap {
 }
 /**
  * A Runnable that can fallback to other Runnables if it fails.
+ * External APIs (e.g., APIs for a language model) may at times experience
+ * degraded performance or even downtime.
+ *
+ * In these cases, it can be useful to have a fallback Runnable that can be
+ * used in place of the original Runnable (e.g., fallback to another LLM provider).
+ *
+ * Fallbacks can be defined at the level of a single Runnable, or at the level
+ * of a chain of Runnables. Fallbacks are tried in order until one succeeds or
+ * all fail.
+ *
+ * While you can instantiate a `RunnableWithFallbacks` directly, it is usually
+ * more convenient to use the `withFallbacks` method on an existing Runnable.
+ *
+ * When streaming, fallbacks will only be called on failures during the initial
+ * stream creation. Errors that occur after a stream starts will not fallback
+ * to the next Runnable.
  */
 export class RunnableWithFallbacks extends Runnable {
     static lc_name() {
@@ -1722,6 +1739,51 @@ export class RunnableWithFallbacks extends Runnable {
         await runManager?.handleChainError(firstError);
         throw firstError;
     }
+    async *_streamIterator(input, options) {
+        const config = ensureConfig(options);
+        const callbackManager_ = await getCallbackManagerForConfig(options);
+        const { runId, ...otherConfigFields } = config;
+        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), runId, undefined, undefined, undefined, otherConfigFields?.runName);
+        let firstError;
+        let stream;
+        for (const runnable of this.runnables()) {
+            config?.signal?.throwIfAborted();
+            const childConfig = patchConfig(otherConfigFields, {
+                callbacks: runManager?.getChild(),
+            });
+            try {
+                stream = await runnable.stream(input, childConfig);
+                break;
+            }
+            catch (e) {
+                if (firstError === undefined) {
+                    firstError = e;
+                }
+            }
+        }
+        if (stream === undefined) {
+            const error = firstError ?? new Error("No error stored at end of fallback.");
+            await runManager?.handleChainError(error);
+            throw error;
+        }
+        let output;
+        try {
+            for await (const chunk of stream) {
+                yield chunk;
+                try {
+                    output = output === undefined ? output : concat(output, chunk);
+                }
+                catch (e) {
+                    output = undefined;
+                }
+            }
+        }
+        catch (e) {
+            await runManager?.handleChainError(e);
+            throw e;
+        }
+        await runManager?.handleChainEnd(_coerceToDict(output, "output"));
+    }
     async batch(inputs, options, batchOptions) {
         if (batchOptions?.returnExceptions) {
             throw new Error("Not implemented.");

package/dist/runnables/remote.cjs

@@ -257,12 +257,17 @@ class RemoteRunnable extends base_js_1.Runnable {
             writable: true,
             value: void 0
         });
+        // Wrap the default fetch call due to issues with illegal invocations
+        // from the browser:
+        // https://stackoverflow.com/questions/69876859/why-does-bind-fix-failed-to-execute-fetch-on-window-illegal-invocation-err
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         Object.defineProperty(this, "fetchImplementation", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: fetch
+            value: (...args) => 
+            // @ts-expect-error Broad typing to support a range of fetch implementations
+            fetch(...args)
         });
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         Object.defineProperty(this, "fetchRequestOptions", {

package/dist/runnables/remote.js

@@ -254,12 +254,17 @@ export class RemoteRunnable extends Runnable {
             writable: true,
             value: void 0
         });
+        // Wrap the default fetch call due to issues with illegal invocations
+        // from the browser:
+        // https://stackoverflow.com/questions/69876859/why-does-bind-fix-failed-to-execute-fetch-on-window-illegal-invocation-err
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         Object.defineProperty(this, "fetchImplementation", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: fetch
+            value: (...args) => 
+            // @ts-expect-error Broad typing to support a range of fetch implementations
+            fetch(...args)
         });
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         Object.defineProperty(this, "fetchRequestOptions", {

package/dist/utils/signal.cjs

@@ -5,6 +5,7 @@ async function raceWithSignal(promise, signal) {
     if (signal === undefined) {
         return promise;
     }
+    let listener;
     return Promise.race([
         promise.catch((err) => {
             if (!signal?.aborted) {
@@ -15,14 +16,15 @@ async function raceWithSignal(promise, signal) {
             }
         }),
         new Promise((_, reject) => {
-            signal.addEventListener("abort", () => {
+            listener = () => {
                 reject(new Error("Aborted"));
-            });
+            };
+            signal.addEventListener("abort", listener);
             // Must be here inside the promise to avoid a race condition
             if (signal.aborted) {
                 reject(new Error("Aborted"));
             }
         }),
-    ]);
+    ]).finally(() => signal.removeEventListener("abort", listener));
 }
 exports.raceWithSignal = raceWithSignal;

package/dist/utils/signal.js

@@ -2,6 +2,7 @@ export async function raceWithSignal(promise, signal) {
     if (signal === undefined) {
         return promise;
     }
+    let listener;
     return Promise.race([
         promise.catch((err) => {
             if (!signal?.aborted) {
@@ -12,13 +13,14 @@ export async function raceWithSignal(promise, signal) {
             }
         }),
         new Promise((_, reject) => {
-            signal.addEventListener("abort", () => {
+            listener = () => {
                 reject(new Error("Aborted"));
-            });
+            };
+            signal.addEventListener("abort", listener);
             // Must be here inside the promise to avoid a race condition
             if (signal.aborted) {
                 reject(new Error("Aborted"));
             }
         }),
-    ]);
+    ]).finally(() => signal.removeEventListener("abort", listener));
 }

package/package.json

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