@langchain/core 0.2.22-rc.1 → 0.2.23

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>[];
@@ -568,6 +568,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 +597,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/utils/event_source_parse.cjs

@@ -18,6 +18,7 @@ exports.EventStreamContentType = "text/event-stream";
 async function getBytes(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 stream, onChunk) {
+    // TODO: Use Async iteration for both cases?
     // eslint-disable-next-line no-instanceof/no-instanceof
     if (stream instanceof ReadableStream) {
         const reader = stream.getReader();

package/dist/utils/event_source_parse.js

@@ -15,6 +15,7 @@ export const EventStreamContentType = "text/event-stream";
 export async function getBytes(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 stream, onChunk) {
+    // TODO: Use Async iteration for both cases?
     // eslint-disable-next-line no-instanceof/no-instanceof
     if (stream instanceof ReadableStream) {
         const reader = stream.getReader();

package/package.json

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