@nocobase/plugin-ai 1.9.32 → 1.9.34

package/dist/node_modules/@langchain/core/dist/runnables/base.js

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from "zod/v3";
 import pRetry from "p-retry";
 import { v4 as uuidv4 } from "uuid";
 import { isTraceableFunction, } from "langsmith/singletons/traceable";
@@ -16,6 +16,7 @@ import { Graph } from "./graph.js";
 import { convertToHttpEventStream } from "./wrappers.js";
 import { consumeAsyncIterableInContext, consumeIteratorInContext, isAsyncIterable, isIterableIterator, isIterator, } from "./iter.js";
 import { _isToolCall, ToolInputParsingException } from "../tools/utils.js";
+import { getSchemaDescription, interopParseAsync, isSimpleStringZodSchema, } from "../utils/types/zod.js";
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function _coerceToDict(value, defaultKey) {
     return value &&
@@ -56,6 +57,8 @@ export class Runnable extends Serializable {
      * Bind arguments to a Runnable, returning a new Runnable.
      * @param kwargs
      * @returns A new RunnableBinding that, when invoked, will apply the bound args.
+     *
+     * @deprecated Use {@link withConfig} instead. This will be removed in the next breaking release.
      */
     bind(kwargs) {
         // eslint-disable-next-line @typescript-eslint/no-use-before-define
@@ -64,6 +67,8 @@ export class Runnable extends Serializable {
     /**
      * Return a new Runnable that maps a list of inputs to a list of outputs,
      * by calling invoke() with each input.
+     *
+     * @deprecated This will be removed in the next breaking release.
      */
     map() {
         // eslint-disable-next-line @typescript-eslint/no-use-before-define
@@ -71,7 +76,8 @@ export class Runnable extends Serializable {
     }
     /**
      * Add retry logic to an existing runnable.
-     * @param kwargs
+     * @param fields.stopAfterAttempt The number of attempts to retry.
+     * @param fields.onFailedAttempt A function that is called when a retry fails.
      * @returns A new RunnableRetry that, when invoked, will retry according to the parameters.
      */
     withRetry(fields) {
@@ -252,6 +258,10 @@ export class Runnable extends Serializable {
         await Promise.all(runManagers.map((runManager) => runManager?.handleChainEnd(_coerceToDict(outputs, "output"))));
         return outputs;
     }
+    /** @internal */
+    _concatOutputChunks(first, second) {
+        return concat(first, second);
+    }
     /**
      * Helper method to transform an Iterator of Input values into an Iterator of
      * Output values, with callbacks.
@@ -264,6 +274,7 @@ export class Runnable extends Serializable {
         let finalOutputSupported = true;
         const config = ensureConfig(options);
         const callbackManager_ = await getCallbackManagerForConfig(config);
+        const outerThis = this;
         async function* wrapInputForTracing() {
             for await (const chunk of inputGenerator) {
                 if (finalInputSupported) {
@@ -272,8 +283,9 @@ export class Runnable extends Serializable {
                     }
                     else {
                         try {
+                            finalInput = outerThis._concatOutputChunks(finalInput, 
                             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                            finalInput = concat(finalInput, chunk);
+                            chunk);
                         }
                         catch {
                             finalInput = undefined;
@@ -306,8 +318,9 @@ export class Runnable extends Serializable {
                     }
                     else {
                         try {
+                            finalOutput = this._concatOutputChunks(finalOutput, 
                             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                            finalOutput = concat(finalOutput, chunk);
+                            chunk);
                         }
                         catch {
                             finalOutput = undefined;
@@ -389,7 +402,7 @@ export class Runnable extends Serializable {
                 // Make a best effort to gather, for any type that supports concat.
                 // This method should throw an error if gathering fails.
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                finalChunk = concat(finalChunk, chunk);
+                finalChunk = this._concatOutputChunks(finalChunk, chunk);
             }
         }
         yield* this._streamIterator(finalChunk, ensureConfig(options));
@@ -505,8 +518,9 @@ export class Runnable extends Serializable {
         // add each chunk to the output stream
         const outerThis = this;
         async function consumeRunnableStream() {
+            let signal;
+            let listener = null;
             try {
-                let signal;
                 if (options?.signal) {
                     if ("any" in AbortSignal) {
                         // Use native AbortSignal.any() if available (Node 19+)
@@ -520,9 +534,10 @@ export class Runnable extends Serializable {
                         // Fallback for Node 18 and below - just use the provided signal
                         signal = options.signal;
                         // Ensure we still abort our controller when the parent signal aborts
-                        options.signal.addEventListener("abort", () => {
+                        listener = () => {
                             abortController.abort();
-                        }, { once: true });
+                        };
+                        options.signal.addEventListener("abort", listener, { once: true });
                     }
                 }
                 else {
@@ -542,6 +557,9 @@ export class Runnable extends Serializable {
             }
             finally {
                 await eventStreamer.finish();
+                if (signal && listener) {
+                    signal.removeEventListener("abort", listener);
+                }
             }
         }
         const runnableStreamConsumePromise = consumeRunnableStream();
@@ -766,7 +784,8 @@ export class Runnable extends Serializable {
     }
 }
 /**
- * A runnable that delegates calls to another runnable with a set of kwargs.
+ * Wraps a runnable and applies partial config upon invocation.
+ *
  * @example
  * ```typescript
  * import {
@@ -861,8 +880,14 @@ export class RunnableBinding extends Runnable {
             ? await Promise.all(this.configFactories.map(async (configFactory) => await configFactory(config)))
             : []));
     }
+    /**
+     * Binds the runnable with the specified arguments.
+     * @param kwargs The arguments to bind the runnable with.
+     * @returns A new instance of the `RunnableBinding` class that is bound with the specified arguments.
+     *
+     * @deprecated Use {@link withConfig} instead. This will be removed in the next breaking release.
+     */
     bind(kwargs) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return new this.constructor({
             bound: this.bound,
             kwargs: { ...this.kwargs, ...kwargs },
@@ -870,7 +895,6 @@ export class RunnableBinding extends Runnable {
         });
     }
     withConfig(config) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return new this.constructor({
             bound: this.bound,
             kwargs: this.kwargs,
@@ -878,11 +902,13 @@ export class RunnableBinding extends Runnable {
         });
     }
     withRetry(fields) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        return new this.constructor({
-            bound: this.bound.withRetry(fields),
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        return new RunnableRetry({
+            bound: this.bound,
             kwargs: this.kwargs,
             config: this.config,
+            maxAttemptNumber: fields?.stopAfterAttempt,
+            ...fields,
         });
     }
     async invoke(input, options) {
@@ -894,6 +920,10 @@ export class RunnableBinding extends Runnable {
             : await this._mergeConfig(ensureConfig(options), this.kwargs);
         return this.bound.batch(inputs, mergedOptions, batchOptions);
     }
+    /** @internal */
+    _concatOutputChunks(first, second) {
+        return this.bound._concatOutputChunks(first, second);
+    }
     async *_streamIterator(input, options) {
         yield* this.bound._streamIterator(input, await this._mergeConfig(ensureConfig(options), this.kwargs));
     }
@@ -973,6 +1003,8 @@ export class RunnableBinding extends Runnable {
  *
  * // ["Hello, ALICE!", "Hello, BOB!", "Hello, CAROL!"]
  * ```
+ *
+ * @deprecated This will be removed in the next breaking release.
  */
 export class RunnableEach extends Runnable {
     static lc_name() {
@@ -1004,6 +1036,8 @@ export class RunnableEach extends Runnable {
      * Binds the runnable with the specified arguments.
      * @param kwargs The arguments to bind the runnable with.
      * @returns A new instance of the `RunnableEach` class that is bound with the specified arguments.
+     *
+     * @deprecated Use {@link withConfig} instead. This will be removed in the next breaking release.
      */
     bind(kwargs) {
         return new RunnableEach({
@@ -1201,7 +1235,7 @@ export class RunnableRetry extends RunnableBinding {
  * const promptTemplate = PromptTemplate.fromTemplate(
  *   "Tell me a joke about {topic}",
  * );
- * const chain = RunnableSequence.from([promptTemplate, new ChatOpenAI({})]);
+ * const chain = RunnableSequence.from([promptTemplate, new ChatOpenAI({ model: "gpt-4o-mini" })]);
  * const result = await chain.invoke({ topic: "bears" });
  * ```
  */
@@ -1315,6 +1349,10 @@ export class RunnableSequence extends Runnable {
         await Promise.all(runManagers.map((runManager) => runManager?.handleChainEnd(_coerceToDict(nextStepInputs, "output"))));
         return nextStepInputs;
     }
+    /** @internal */
+    _concatOutputChunks(first, second) {
+        return this.last._concatOutputChunks(first, second);
+    }
     async *_streamIterator(input, options) {
         const callbackManager_ = await getCallbackManagerForConfig(options);
         const { runId, ...otherOptions } = options ?? {};
@@ -1345,7 +1383,7 @@ export class RunnableSequence extends Runnable {
                     else {
                         try {
                             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                            finalOutput = concat(finalOutput, chunk);
+                            finalOutput = this._concatOutputChunks(finalOutput, chunk);
                         }
                         catch (e) {
                             finalOutput = undefined;
@@ -1696,8 +1734,9 @@ export class RunnableLambda extends Runnable {
                             else {
                                 // Make a best effort to gather, for any type that supports concat.
                                 try {
+                                    finalOutput = this._concatOutputChunks(finalOutput, 
                                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                                    finalOutput = concat(finalOutput, chunk);
+                                    chunk);
                                 }
                                 catch (e) {
                                     finalOutput = chunk;
@@ -1716,8 +1755,9 @@ export class RunnableLambda extends Runnable {
                             else {
                                 // Make a best effort to gather, for any type that supports concat.
                                 try {
+                                    finalOutput = this._concatOutputChunks(finalOutput, 
                                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                                    finalOutput = concat(finalOutput, chunk);
+                                    chunk);
                                 }
                                 catch (e) {
                                     finalOutput = chunk;
@@ -1747,7 +1787,7 @@ export class RunnableLambda extends Runnable {
                 // Make a best effort to gather, for any type that supports concat.
                 try {
                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    finalChunk = concat(finalChunk, chunk);
+                    finalChunk = this._concatOutputChunks(finalChunk, chunk);
                 }
                 catch (e) {
                     finalChunk = chunk;
@@ -1841,9 +1881,9 @@ export class RunnableLambda extends Runnable {
  * );
  *
  * // Invoke the sequence with a single age input
- * const res = sequence.invoke(25);
+ * const res = await sequence.invoke(25);
  *
- * // { years_to_fifty: 25, years_to_hundred: 75 }
+ * // { years_to_fifty: 20, years_to_hundred: 70 }
  * ```
  */
 export class RunnableParallel extends RunnableMap {
@@ -2019,7 +2059,10 @@ export class RunnableWithFallbacks extends Runnable {
             for await (const chunk of stream) {
                 yield chunk;
                 try {
-                    output = output === undefined ? output : concat(output, chunk);
+                    output =
+                        output === undefined
+                            ? output
+                            : this._concatOutputChunks(output, chunk);
                 }
                 catch (e) {
                     output = undefined;
@@ -2260,7 +2303,9 @@ export class RunnablePick extends Runnable {
             const picked = this.keys
                 .map((key) => [key, input[key]])
                 .filter((v) => v[1] !== undefined);
-            return picked.length === 0 ? undefined : Object.fromEntries(picked);
+            return picked.length === 0
+                ? undefined
+                : Object.fromEntries(picked);
         }
     }
     async invoke(input, options) {
@@ -2297,7 +2342,7 @@ export class RunnableToolLike extends RunnableBinding {
                 let toolInput;
                 if (_isToolCall(input)) {
                     try {
-                        toolInput = await this.schema.parseAsync(input.args);
+                        toolInput = await interopParseAsync(this.schema, input.args);
                     }
                     catch (e) {
                         throw new ToolInputParsingException(`Received tool input did not match expected schema`, JSON.stringify(input.args));
@@ -2350,20 +2395,18 @@ export class RunnableToolLike extends RunnableBinding {
  * @param fields
  * @param {string | undefined} [fields.name] The name of the tool. If not provided, it will default to the name of the runnable.
  * @param {string | undefined} [fields.description] The description of the tool. Falls back to the description on the Zod schema if not provided, or undefined if neither are provided.
- * @param {z.ZodType<RunInput>} [fields.schema] The Zod schema for the input of the tool. Infers the Zod type from the input type of the runnable.
- * @returns {RunnableToolLike<z.ZodType<RunInput>, RunOutput>} An instance of `RunnableToolLike` which is a runnable that can be used as a tool.
+ * @param {InteropZodType<RunInput>} [fields.schema] The Zod schema for the input of the tool. Infers the Zod type from the input type of the runnable.
+ * @returns {RunnableToolLike<InteropZodType<RunInput>, RunOutput>} An instance of `RunnableToolLike` which is a runnable that can be used as a tool.
  */
 export function convertRunnableToTool(runnable, fields) {
     const name = fields.name ?? runnable.getName();
-    const description = fields.description ?? fields.schema?.description;
-    if (fields.schema.constructor === z.ZodString) {
+    const description = fields.description ?? getSchemaDescription(fields.schema);
+    if (isSimpleStringZodSchema(fields.schema)) {
         return new RunnableToolLike({
             name,
             description,
             schema: z
-                .object({
-                input: z.string(),
-            })
+                .object({ input: z.string() })
                 .transform((input) => input.input),
             bound: runnable,
         });

package/dist/node_modules/@langchain/core/dist/runnables/config.cjs

@@ -1,13 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.pickRunnableConfigKeys = exports.patchConfig = exports.ensureConfig = exports.mergeConfigs = exports.getCallbackManagerForConfig = exports.DEFAULT_RECURSION_LIMIT = void 0;
+exports.DEFAULT_RECURSION_LIMIT = void 0;
+exports.getCallbackManagerForConfig = getCallbackManagerForConfig;
+exports.mergeConfigs = mergeConfigs;
+exports.ensureConfig = ensureConfig;
+exports.patchConfig = patchConfig;
+exports.pickRunnableConfigKeys = pickRunnableConfigKeys;
 const manager_js_1 = require("../callbacks/manager.cjs");
 const index_js_1 = require("../singletons/index.cjs");
 exports.DEFAULT_RECURSION_LIMIT = 25;
 async function getCallbackManagerForConfig(config) {
     return manager_js_1.CallbackManager._configureSync(config?.callbacks, undefined, config?.tags, undefined, config?.metadata);
 }
-exports.getCallbackManagerForConfig = getCallbackManagerForConfig;
 function mergeConfigs(...configs) {
     // We do not want to call ensureConfig on the empty state here as this may cause
     // double loading of callbacks if async local storage is being used.
@@ -105,7 +109,6 @@ function mergeConfigs(...configs) {
     }
     return copy;
 }
-exports.mergeConfigs = mergeConfigs;
 const PRIMITIVES = new Set(["string", "number", "boolean"]);
 /**
  * Ensure that a passed config is an object with all required keys present.
@@ -173,7 +176,6 @@ function ensureConfig(config) {
     }
     return empty;
 }
-exports.ensureConfig = ensureConfig;
 /**
  * Helper function that patches runnable configs with updated properties.
  */
@@ -204,7 +206,6 @@ function patchConfig(config = {}, { callbacks, maxConcurrency, recursionLimit, r
     }
     return newConfig;
 }
-exports.patchConfig = patchConfig;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function pickRunnableConfigKeys(config) {
     return config
@@ -220,4 +221,3 @@ function pickRunnableConfigKeys(config) {
         }
         : undefined;
 }
-exports.pickRunnableConfigKeys = pickRunnableConfigKeys;

package/dist/node_modules/@langchain/core/dist/runnables/graph.cjs

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Graph = void 0;
-const zod_to_json_schema_1 = require("zod-to-json-schema");
 const uuid_1 = require("uuid");
 const utils_js_1 = require("./utils.cjs");
 const graph_mermaid_js_1 = require("./graph_mermaid.cjs");
+const json_schema_js_1 = require("../utils/json_schema.cjs");
 function nodeDataStr(id, data) {
     if (id !== undefined && !(0, uuid_1.validate)(id)) {
         return id;
@@ -39,7 +39,7 @@ function nodeDataJson(node) {
     else {
         return {
             type: "schema",
-            data: { ...(0, zod_to_json_schema_1.zodToJsonSchema)(node.data.schema), title: node.data.name },
+            data: { ...(0, json_schema_js_1.toJsonSchema)(node.data.schema), title: node.data.name },
         };
     }
 }

package/dist/node_modules/@langchain/core/dist/runnables/graph.js

@@ -1,7 +1,7 @@
-import { zodToJsonSchema } from "zod-to-json-schema";
 import { v4 as uuidv4, validate as isUuid } from "uuid";
 import { isRunnableInterface } from "./utils.js";
 import { drawMermaid, drawMermaidPng } from "./graph_mermaid.js";
+import { toJsonSchema } from "../utils/json_schema.js";
 function nodeDataStr(id, data) {
     if (id !== undefined && !isUuid(id)) {
         return id;
@@ -36,7 +36,7 @@ function nodeDataJson(node) {
     else {
         return {
             type: "schema",
-            data: { ...zodToJsonSchema(node.data.schema), title: node.data.name },
+            data: { ...toJsonSchema(node.data.schema), title: node.data.name },
         };
     }
 }

package/dist/node_modules/@langchain/core/dist/runnables/graph_mermaid.cjs

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.drawMermaidPng = exports.drawMermaid = void 0;
+exports.drawMermaid = drawMermaid;
+exports.drawMermaidPng = drawMermaidPng;
+exports.drawMermaidImage = drawMermaidImage;
 function _escapeNodeLabel(nodeLabel) {
     // Escapes the node label for Mermaid syntax.
     return nodeLabel.replace(/[^a-zA-Z-_0-9]/g, "_");
@@ -122,12 +124,34 @@ function drawMermaid(nodes, edges, config) {
     }
     return mermaidGraph;
 }
-exports.drawMermaid = drawMermaid;
 /**
- * Renders Mermaid graph using the Mermaid.INK API.
+ * @deprecated Use `drawMermaidImage` instead.
  */
 async function drawMermaidPng(mermaidSyntax, config) {
-    let { backgroundColor = "white" } = config ?? {};
+    return drawMermaidImage(mermaidSyntax, {
+        ...config,
+        imageType: "png",
+    });
+}
+/**
+ * Renders Mermaid graph using the Mermaid.INK API.
+ *
+ * @example
+ * ```javascript
+ * const image = await drawMermaidImage(mermaidSyntax, {
+ *   backgroundColor: "white",
+ *   imageType: "png",
+ * });
+ * fs.writeFileSync("image.png", image);
+ * ```
+ *
+ * @param mermaidSyntax - The Mermaid syntax to render.
+ * @param config - The configuration for the image.
+ * @returns The image as a Blob.
+ */
+async function drawMermaidImage(mermaidSyntax, config) {
+    let backgroundColor = config?.backgroundColor ?? "white";
+    const imageType = config?.imageType ?? "png";
     // Use btoa for compatibility, assume ASCII
     const mermaidSyntaxEncoded = btoa(mermaidSyntax);
     // Check if the background color is a hexadecimal color code using regex
@@ -137,7 +161,7 @@ async function drawMermaidPng(mermaidSyntax, config) {
             backgroundColor = `!${backgroundColor}`;
         }
     }
-    const imageUrl = `https://mermaid.ink/img/${mermaidSyntaxEncoded}?bgColor=${backgroundColor}`;
+    const imageUrl = `https://mermaid.ink/img/${mermaidSyntaxEncoded}?bgColor=${backgroundColor}&type=${imageType}`;
     const res = await fetch(imageUrl);
     if (!res.ok) {
         throw new Error([
@@ -149,4 +173,3 @@ async function drawMermaidPng(mermaidSyntax, config) {
     const content = await res.blob();
     return content;
 }
-exports.drawMermaidPng = drawMermaidPng;

package/dist/node_modules/@langchain/core/dist/runnables/graph_mermaid.d.ts

@@ -11,8 +11,32 @@ export declare function drawMermaid(nodes: Record<string, Node>, edges: Edge[],
     wrapLabelNWords?: number;
 }): string;
 /**
- * Renders Mermaid graph using the Mermaid.INK API.
+ * @deprecated Use `drawMermaidImage` instead.
  */
 export declare function drawMermaidPng(mermaidSyntax: string, config?: {
     backgroundColor?: string;
 }): Promise<Blob>;
+/**
+ * Renders Mermaid graph using the Mermaid.INK API.
+ *
+ * @example
+ * ```javascript
+ * const image = await drawMermaidImage(mermaidSyntax, {
+ *   backgroundColor: "white",
+ *   imageType: "png",
+ * });
+ * fs.writeFileSync("image.png", image);
+ * ```
+ *
+ * @param mermaidSyntax - The Mermaid syntax to render.
+ * @param config - The configuration for the image.
+ * @returns The image as a Blob.
+ */
+export declare function drawMermaidImage(mermaidSyntax: string, config?: {
+    /**
+     * The type of image to render.
+     * @default "png"
+     */
+    imageType?: "png" | "jpeg" | "webp";
+    backgroundColor?: string;
+}): Promise<Blob>;

package/dist/node_modules/@langchain/core/dist/runnables/graph_mermaid.js

@@ -120,10 +120,33 @@ export function drawMermaid(nodes, edges, config) {
     return mermaidGraph;
 }
 /**
- * Renders Mermaid graph using the Mermaid.INK API.
+ * @deprecated Use `drawMermaidImage` instead.
  */
 export async function drawMermaidPng(mermaidSyntax, config) {
-    let { backgroundColor = "white" } = config ?? {};
+    return drawMermaidImage(mermaidSyntax, {
+        ...config,
+        imageType: "png",
+    });
+}
+/**
+ * Renders Mermaid graph using the Mermaid.INK API.
+ *
+ * @example
+ * ```javascript
+ * const image = await drawMermaidImage(mermaidSyntax, {
+ *   backgroundColor: "white",
+ *   imageType: "png",
+ * });
+ * fs.writeFileSync("image.png", image);
+ * ```
+ *
+ * @param mermaidSyntax - The Mermaid syntax to render.
+ * @param config - The configuration for the image.
+ * @returns The image as a Blob.
+ */
+export async function drawMermaidImage(mermaidSyntax, config) {
+    let backgroundColor = config?.backgroundColor ?? "white";
+    const imageType = config?.imageType ?? "png";
     // Use btoa for compatibility, assume ASCII
     const mermaidSyntaxEncoded = btoa(mermaidSyntax);
     // Check if the background color is a hexadecimal color code using regex
@@ -133,7 +156,7 @@ export async function drawMermaidPng(mermaidSyntax, config) {
             backgroundColor = `!${backgroundColor}`;
         }
     }
-    const imageUrl = `https://mermaid.ink/img/${mermaidSyntaxEncoded}?bgColor=${backgroundColor}`;
+    const imageUrl = `https://mermaid.ink/img/${mermaidSyntaxEncoded}?bgColor=${backgroundColor}&type=${imageType}`;
     const res = await fetch(imageUrl);
     if (!res.ok) {
         throw new Error([

package/dist/node_modules/@langchain/core/dist/runnables/iter.cjs

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.consumeAsyncIterableInContext = exports.consumeIteratorInContext = exports.isAsyncIterable = exports.isIterator = exports.isIterableIterator = void 0;
+exports.isIterator = void 0;
+exports.isIterableIterator = isIterableIterator;
+exports.isAsyncIterable = isAsyncIterable;
+exports.consumeIteratorInContext = consumeIteratorInContext;
+exports.consumeAsyncIterableInContext = consumeAsyncIterableInContext;
 const index_js_1 = require("../singletons/index.cjs");
 const config_js_1 = require("./config.cjs");
 function isIterableIterator(thing) {
@@ -10,7 +14,6 @@ function isIterableIterator(thing) {
         // avoid detecting array/set as iterator
         typeof thing.next === "function");
 }
-exports.isIterableIterator = isIterableIterator;
 const isIterator = (x) => x != null &&
     typeof x === "object" &&
     "next" in x &&
@@ -22,7 +25,6 @@ function isAsyncIterable(thing) {
         typeof thing[Symbol.asyncIterator] ===
             "function");
 }
-exports.isAsyncIterable = isAsyncIterable;
 function* consumeIteratorInContext(context, iter) {
     while (true) {
         const { value, done } = index_js_1.AsyncLocalStorageProviderSingleton.runWithConfig((0, config_js_1.pickRunnableConfigKeys)(context), iter.next.bind(iter), true);
@@ -34,7 +36,6 @@ function* consumeIteratorInContext(context, iter) {
         }
     }
 }
-exports.consumeIteratorInContext = consumeIteratorInContext;
 async function* consumeAsyncIterableInContext(context, iter) {
     const iterator = iter[Symbol.asyncIterator]();
     while (true) {
@@ -47,4 +48,3 @@ async function* consumeAsyncIterableInContext(context, iter) {
         }
     }
 }
-exports.consumeAsyncIterableInContext = consumeAsyncIterableInContext;

package/dist/node_modules/@langchain/core/dist/runnables/iter.d.ts

@@ -1,6 +1,6 @@
 import type { RunnableConfig } from "../runnables/types.js";
 export declare function isIterableIterator(thing: unknown): thing is IterableIterator<unknown>;
-export declare const isIterator: (x: unknown) => x is Iterator<unknown, any, undefined>;
+export declare const isIterator: (x: unknown) => x is Iterator<unknown>;
 export declare function isAsyncIterable(thing: unknown): thing is AsyncIterable<unknown>;
 export declare function consumeIteratorInContext<T>(context: Partial<RunnableConfig> | undefined, iter: IterableIterator<T>): IterableIterator<T>;
 export declare function consumeAsyncIterableInContext<T>(context: Partial<RunnableConfig> | undefined, iter: AsyncIterable<T>): AsyncIterableIterator<T>;

package/dist/node_modules/@langchain/core/dist/runnables/passthrough.cjs

@@ -112,7 +112,7 @@ class RunnablePassthrough extends base_js_1.Runnable {
      *     schema: async () => db.getTableInfo(),
      *   }),
      *   prompt,
-     *   new ChatOpenAI({}).bind({ stop: ["\nSQLResult:"] }),
+     *   new ChatOpenAI({ model: "gpt-4o-mini" }).withConfig({ stop: ["\nSQLResult:"] }),
      *   new StringOutputParser(),
      * ]);
      * const result = await sqlQueryGeneratorChain.invoke({

package/dist/node_modules/@langchain/core/dist/runnables/passthrough.d.ts

@@ -57,7 +57,7 @@ export declare class RunnablePassthrough<RunInput = any> extends Runnable<RunInp
      *     schema: async () => db.getTableInfo(),
      *   }),
      *   prompt,
-     *   new ChatOpenAI({}).bind({ stop: ["\nSQLResult:"] }),
+     *   new ChatOpenAI({ model: "gpt-4o-mini" }).withConfig({ stop: ["\nSQLResult:"] }),
      *   new StringOutputParser(),
      * ]);
      * const result = await sqlQueryGeneratorChain.invoke({

package/dist/node_modules/@langchain/core/dist/runnables/passthrough.js

@@ -109,7 +109,7 @@ export class RunnablePassthrough extends Runnable {
      *     schema: async () => db.getTableInfo(),
      *   }),
      *   prompt,
-     *   new ChatOpenAI({}).bind({ stop: ["\nSQLResult:"] }),
+     *   new ChatOpenAI({ model: "gpt-4o-mini" }).withConfig({ stop: ["\nSQLResult:"] }),
      *   new StringOutputParser(),
      * ]);
      * const result = await sqlQueryGeneratorChain.invoke({

package/dist/node_modules/@langchain/core/dist/runnables/remote.cjs

@@ -239,6 +239,8 @@ function serialize(input) {
  * `.invoke()`, `.stream()`, `.streamEvents()`, etc. methods that
  * other runnables support.
  *
+ * @deprecated LangServe is no longer actively developed - please consider using LangGraph Platform.
+ *
  * @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.

package/dist/node_modules/@langchain/core/dist/runnables/remote.d.ts

@@ -15,6 +15,8 @@ type RemoteRunnableOptions = {
  * `.invoke()`, `.stream()`, `.streamEvents()`, etc. methods that
  * other runnables support.
  *
+ * @deprecated LangServe is no longer actively developed - please consider using LangGraph Platform.
+ *
  * @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.

package/dist/node_modules/@langchain/core/dist/runnables/remote.js

@@ -236,6 +236,8 @@ function serialize(input) {
  * `.invoke()`, `.stream()`, `.streamEvents()`, etc. methods that
  * other runnables support.
  *
+ * @deprecated LangServe is no longer actively developed - please consider using LangGraph Platform.
+ *
  * @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.