langgraph-ui-components 0.0.1 → 0.0.2

package/dist/index.es64.js

@@ -0,0 +1,1403 @@
+import { Serializable } from "./index.es55.js";
+import { _isToolCall, ToolInputParsingException } from "./index.es61.js";
+import { AsyncLocalStorageProviderSingleton } from "./index.es76.js";
+import "./index.es77.js";
+import { patchConfig, DEFAULT_RECURSION_LIMIT, pickRunnableConfigKeys, ensureConfig, getCallbackManagerForConfig, mergeConfigs } from "./index.es78.js";
+import { raceWithSignal, getAbortSignalError } from "./index.es79.js";
+import { AsyncGeneratorWithSetup, IterableReadableStream, concat, pipeGeneratorWithSetup, atee } from "./index.es80.js";
+import { isLogStreamHandler, LogStreamCallbackHandler, RunLog, RunLogPatch } from "./index.es81.js";
+import { isStreamEventsHandler, EventStreamCallbackHandler } from "./index.es82.js";
+import { pRetry } from "./index.es83.js";
+import { AsyncCaller } from "./index.es84.js";
+import { RootListenersTracer } from "./index.es85.js";
+import { _RootEventFilter, isRunnableInterface } from "./index.es86.js";
+import { getSchemaDescription, isSimpleStringZodSchema, interopParseAsync } from "./index.es87.js";
+import { Graph } from "./index.es88.js";
+import { convertToHttpEventStream } from "./index.es89.js";
+import { isAsyncIterable, consumeAsyncIterableInContext, isIterableIterator, consumeIteratorInContext, isIterator } from "./index.es90.js";
+import { v4 } from "uuid";
+import { isTraceableFunction } from "./index.es91.js";
+import { any as anyType, object as objectType, string as stringType } from "./index.es92.js";
+function _coerceToDict(value, defaultKey) {
+  return value && !Array.isArray(value) && !(value instanceof Date) && typeof value === "object" ? value : { [defaultKey]: value };
+}
+var Runnable = class extends Serializable {
+  lc_runnable = true;
+  name;
+  getName(suffix) {
+    const name = this.name ?? this.constructor.lc_name() ?? this.constructor.name;
+    return suffix ? `${name}${suffix}` : name;
+  }
+  /**
+  * Add retry logic to an existing runnable.
+  * @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) {
+    return new RunnableRetry({
+      bound: this,
+      kwargs: {},
+      config: {},
+      maxAttemptNumber: fields?.stopAfterAttempt,
+      ...fields
+    });
+  }
+  /**
+  * Bind config to a Runnable, returning a new Runnable.
+  * @param config New configuration parameters to attach to the new runnable.
+  * @returns A new RunnableBinding with a config matching what's passed.
+  */
+  withConfig(config) {
+    return new RunnableBinding({
+      bound: this,
+      config,
+      kwargs: {}
+    });
+  }
+  /**
+  * Create a new runnable from the current one that will try invoking
+  * other passed fallback runnables if the initial invocation fails.
+  * @param fields.fallbacks Other runnables to call if the runnable errors.
+  * @returns A new RunnableWithFallbacks.
+  */
+  withFallbacks(fields) {
+    const fallbacks = Array.isArray(fields) ? fields : fields.fallbacks;
+    return new RunnableWithFallbacks({
+      runnable: this,
+      fallbacks
+    });
+  }
+  _getOptionsList(options, length = 0) {
+    if (Array.isArray(options) && options.length !== length) throw new Error(`Passed "options" must be an array with the same length as the inputs, but got ${options.length} options for ${length} inputs`);
+    if (Array.isArray(options)) return options.map(ensureConfig);
+    if (length > 1 && !Array.isArray(options) && options.runId) {
+      console.warn("Provided runId will be used only for the first element of the batch.");
+      const subsequent = Object.fromEntries(Object.entries(options).filter(([key]) => key !== "runId"));
+      return Array.from({ length }, (_, i) => ensureConfig(i === 0 ? options : subsequent));
+    }
+    return Array.from({ length }, () => ensureConfig(options));
+  }
+  async batch(inputs, options, batchOptions) {
+    const configList = this._getOptionsList(options ?? {}, inputs.length);
+    const maxConcurrency = configList[0]?.maxConcurrency ?? batchOptions?.maxConcurrency;
+    const caller = new AsyncCaller({
+      maxConcurrency,
+      onFailedAttempt: (e) => {
+        throw e;
+      }
+    });
+    const batchCalls = inputs.map((input, i) => caller.call(async () => {
+      try {
+        const result = await this.invoke(input, configList[i]);
+        return result;
+      } catch (e) {
+        if (batchOptions?.returnExceptions) return e;
+        throw e;
+      }
+    }));
+    return Promise.all(batchCalls);
+  }
+  /**
+  * Default streaming implementation.
+  * Subclasses should override this method if they support streaming output.
+  * @param input
+  * @param options
+  */
+  async *_streamIterator(input, options) {
+    yield this.invoke(input, options);
+  }
+  /**
+  * Stream output in chunks.
+  * @param input
+  * @param options
+  * @returns A readable stream that is also an iterable.
+  */
+  async stream(input, options) {
+    const config = ensureConfig(options);
+    const wrappedGenerator = new AsyncGeneratorWithSetup({
+      generator: this._streamIterator(input, config),
+      config
+    });
+    await wrappedGenerator.setup;
+    return IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
+  }
+  _separateRunnableConfigFromCallOptions(options) {
+    let runnableConfig;
+    if (options === void 0) runnableConfig = ensureConfig(options);
+    else runnableConfig = ensureConfig({
+      callbacks: options.callbacks,
+      tags: options.tags,
+      metadata: options.metadata,
+      runName: options.runName,
+      configurable: options.configurable,
+      recursionLimit: options.recursionLimit,
+      maxConcurrency: options.maxConcurrency,
+      runId: options.runId,
+      timeout: options.timeout,
+      signal: options.signal
+    });
+    const callOptions = { ...options };
+    delete callOptions.callbacks;
+    delete callOptions.tags;
+    delete callOptions.metadata;
+    delete callOptions.runName;
+    delete callOptions.configurable;
+    delete callOptions.recursionLimit;
+    delete callOptions.maxConcurrency;
+    delete callOptions.runId;
+    delete callOptions.timeout;
+    delete callOptions.signal;
+    return [runnableConfig, callOptions];
+  }
+  async _callWithConfig(func, input, options) {
+    const config = ensureConfig(options);
+    const callbackManager_ = await getCallbackManagerForConfig(config);
+    const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), config.runId, config?.runType, void 0, void 0, config?.runName ?? this.getName());
+    delete config.runId;
+    let output;
+    try {
+      const promise = func.call(this, input, config, runManager);
+      output = await raceWithSignal(promise, options?.signal);
+    } catch (e) {
+      await runManager?.handleChainError(e);
+      throw e;
+    }
+    await runManager?.handleChainEnd(_coerceToDict(output, "output"));
+    return output;
+  }
+  /**
+  * Internal method that handles batching and configuration for a runnable
+  * It takes a function, input values, and optional configuration, and
+  * returns a promise that resolves to the output values.
+  * @param func The function to be executed for each input value.
+  * @param input The input values to be processed.
+  * @param config Optional configuration for the function execution.
+  * @returns A promise that resolves to the output values.
+  */
+  async _batchWithConfig(func, inputs, options, batchOptions) {
+    const optionsList = this._getOptionsList(options ?? {}, inputs.length);
+    const callbackManagers = await Promise.all(optionsList.map(getCallbackManagerForConfig));
+    const runManagers = await Promise.all(callbackManagers.map(async (callbackManager, i) => {
+      const handleStartRes = await callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"), optionsList[i].runId, optionsList[i].runType, void 0, void 0, optionsList[i].runName ?? this.getName());
+      delete optionsList[i].runId;
+      return handleStartRes;
+    }));
+    let outputs;
+    try {
+      const promise = func.call(this, inputs, optionsList, runManagers, batchOptions);
+      outputs = await raceWithSignal(promise, optionsList?.[0]?.signal);
+    } catch (e) {
+      await Promise.all(runManagers.map((runManager) => runManager?.handleChainError(e)));
+      throw e;
+    }
+    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.
+  * Use this to implement `stream()` or `transform()` in Runnable subclasses.
+  */
+  async *_transformStreamWithConfig(inputGenerator, transformer, options) {
+    let finalInput;
+    let finalInputSupported = true;
+    let finalOutput;
+    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) if (finalInput === void 0) finalInput = chunk;
+        else try {
+          finalInput = outerThis._concatOutputChunks(finalInput, chunk);
+        } catch {
+          finalInput = void 0;
+          finalInputSupported = false;
+        }
+        yield chunk;
+      }
+    }
+    let runManager;
+    try {
+      const pipe = await pipeGeneratorWithSetup(transformer.bind(this), wrapInputForTracing(), async () => callbackManager_?.handleChainStart(this.toJSON(), { input: "" }, config.runId, config.runType, void 0, void 0, config.runName ?? this.getName(), void 0, { lc_defers_inputs: true }), options?.signal, config);
+      delete config.runId;
+      runManager = pipe.setup;
+      const streamEventsHandler = runManager?.handlers.find(isStreamEventsHandler);
+      let iterator = pipe.output;
+      if (streamEventsHandler !== void 0 && runManager !== void 0) iterator = streamEventsHandler.tapOutputIterable(runManager.runId, iterator);
+      const streamLogHandler = runManager?.handlers.find(isLogStreamHandler);
+      if (streamLogHandler !== void 0 && runManager !== void 0) iterator = streamLogHandler.tapOutputIterable(runManager.runId, iterator);
+      for await (const chunk of iterator) {
+        yield chunk;
+        if (finalOutputSupported) if (finalOutput === void 0) finalOutput = chunk;
+        else try {
+          finalOutput = this._concatOutputChunks(finalOutput, chunk);
+        } catch {
+          finalOutput = void 0;
+          finalOutputSupported = false;
+        }
+      }
+    } catch (e) {
+      await runManager?.handleChainError(e, void 0, void 0, void 0, { inputs: _coerceToDict(finalInput, "input") });
+      throw e;
+    }
+    await runManager?.handleChainEnd(finalOutput ?? {}, void 0, void 0, void 0, { inputs: _coerceToDict(finalInput, "input") });
+  }
+  getGraph(_) {
+    const graph = new Graph();
+    const inputNode = graph.addNode({
+      name: `${this.getName()}Input`,
+      schema: anyType()
+    });
+    const runnableNode = graph.addNode(this);
+    const outputNode = graph.addNode({
+      name: `${this.getName()}Output`,
+      schema: anyType()
+    });
+    graph.addEdge(inputNode, runnableNode);
+    graph.addEdge(runnableNode, outputNode);
+    return graph;
+  }
+  /**
+  * Create a new runnable sequence that runs each individual runnable in series,
+  * piping the output of one runnable into another runnable or runnable-like.
+  * @param coerceable A runnable, function, or object whose values are functions or runnables.
+  * @returns A new runnable sequence.
+  */
+  pipe(coerceable) {
+    return new RunnableSequence({
+      first: this,
+      last: _coerceToRunnable(coerceable)
+    });
+  }
+  /**
+  * Pick keys from the dict output of this runnable. Returns a new runnable.
+  */
+  pick(keys) {
+    return this.pipe(new RunnablePick(keys));
+  }
+  /**
+  * Assigns new fields to the dict output of this runnable. Returns a new runnable.
+  */
+  assign(mapping) {
+    return this.pipe(new RunnableAssign(new RunnableMap({ steps: mapping })));
+  }
+  /**
+  * Default implementation of transform, which buffers input and then calls stream.
+  * Subclasses should override this method if they can start producing output while
+  * input is still being generated.
+  * @param generator
+  * @param options
+  */
+  async *transform(generator, options) {
+    let finalChunk;
+    for await (const chunk of generator) if (finalChunk === void 0) finalChunk = chunk;
+    else finalChunk = this._concatOutputChunks(finalChunk, chunk);
+    yield* this._streamIterator(finalChunk, ensureConfig(options));
+  }
+  /**
+  * Stream all output from a runnable, as reported to the callback system.
+  * This includes all inner runs of LLMs, Retrievers, Tools, etc.
+  * Output is streamed as Log objects, which include a list of
+  * jsonpatch ops that describe how the state of the run has changed in each
+  * step, and the final state of the run.
+  * The jsonpatch ops can be applied in order to construct state.
+  * @param input
+  * @param options
+  * @param streamOptions
+  */
+  async *streamLog(input, options, streamOptions) {
+    const logStreamCallbackHandler = new LogStreamCallbackHandler({
+      ...streamOptions,
+      autoClose: false,
+      _schemaFormat: "original"
+    });
+    const config = ensureConfig(options);
+    yield* this._streamLog(input, logStreamCallbackHandler, config);
+  }
+  async *_streamLog(input, logStreamCallbackHandler, config) {
+    const { callbacks } = config;
+    if (callbacks === void 0) config.callbacks = [logStreamCallbackHandler];
+    else if (Array.isArray(callbacks)) config.callbacks = callbacks.concat([logStreamCallbackHandler]);
+    else {
+      const copiedCallbacks = callbacks.copy();
+      copiedCallbacks.addHandler(logStreamCallbackHandler, true);
+      config.callbacks = copiedCallbacks;
+    }
+    const runnableStreamPromise = this.stream(input, config);
+    async function consumeRunnableStream() {
+      try {
+        const runnableStream = await runnableStreamPromise;
+        for await (const chunk of runnableStream) {
+          const patch = new RunLogPatch({ ops: [{
+            op: "add",
+            path: "/streamed_output/-",
+            value: chunk
+          }] });
+          await logStreamCallbackHandler.writer.write(patch);
+        }
+      } finally {
+        await logStreamCallbackHandler.writer.close();
+      }
+    }
+    const runnableStreamConsumePromise = consumeRunnableStream();
+    try {
+      for await (const log of logStreamCallbackHandler) yield log;
+    } finally {
+      await runnableStreamConsumePromise;
+    }
+  }
+  streamEvents(input, options, streamOptions) {
+    let stream;
+    if (options.version === "v1") stream = this._streamEventsV1(input, options, streamOptions);
+    else if (options.version === "v2") stream = this._streamEventsV2(input, options, streamOptions);
+    else throw new Error(`Only versions "v1" and "v2" of the schema are currently supported.`);
+    if (options.encoding === "text/event-stream") return convertToHttpEventStream(stream);
+    else return IterableReadableStream.fromAsyncGenerator(stream);
+  }
+  async *_streamEventsV2(input, options, streamOptions) {
+    const eventStreamer = new EventStreamCallbackHandler({
+      ...streamOptions,
+      autoClose: false
+    });
+    const config = ensureConfig(options);
+    const runId = config.runId ?? v4();
+    config.runId = runId;
+    const callbacks = config.callbacks;
+    if (callbacks === void 0) config.callbacks = [eventStreamer];
+    else if (Array.isArray(callbacks)) config.callbacks = callbacks.concat(eventStreamer);
+    else {
+      const copiedCallbacks = callbacks.copy();
+      copiedCallbacks.addHandler(eventStreamer, true);
+      config.callbacks = copiedCallbacks;
+    }
+    const abortController = new AbortController();
+    const outerThis = this;
+    async function consumeRunnableStream() {
+      let signal;
+      let listener = null;
+      try {
+        if (options?.signal) if ("any" in AbortSignal) signal = AbortSignal.any([abortController.signal, options.signal]);
+        else {
+          signal = options.signal;
+          listener = () => {
+            abortController.abort();
+          };
+          options.signal.addEventListener("abort", listener, { once: true });
+        }
+        else signal = abortController.signal;
+        const runnableStream = await outerThis.stream(input, {
+          ...config,
+          signal
+        });
+        const tappedStream = eventStreamer.tapOutputIterable(runId, runnableStream);
+        for await (const _ of tappedStream) if (abortController.signal.aborted) break;
+      } finally {
+        await eventStreamer.finish();
+        if (signal && listener) signal.removeEventListener("abort", listener);
+      }
+    }
+    const runnableStreamConsumePromise = consumeRunnableStream();
+    let firstEventSent = false;
+    let firstEventRunId;
+    try {
+      for await (const event of eventStreamer) {
+        if (!firstEventSent) {
+          event.data.input = input;
+          firstEventSent = true;
+          firstEventRunId = event.run_id;
+          yield event;
+          continue;
+        }
+        if (event.run_id === firstEventRunId && event.event.endsWith("_end")) {
+          if (event.data?.input) delete event.data.input;
+        }
+        yield event;
+      }
+    } finally {
+      abortController.abort();
+      await runnableStreamConsumePromise;
+    }
+  }
+  async *_streamEventsV1(input, options, streamOptions) {
+    let runLog;
+    let hasEncounteredStartEvent = false;
+    const config = ensureConfig(options);
+    const rootTags = config.tags ?? [];
+    const rootMetadata = config.metadata ?? {};
+    const rootName = config.runName ?? this.getName();
+    const logStreamCallbackHandler = new LogStreamCallbackHandler({
+      ...streamOptions,
+      autoClose: false,
+      _schemaFormat: "streaming_events"
+    });
+    const rootEventFilter = new _RootEventFilter({ ...streamOptions });
+    const logStream = this._streamLog(input, logStreamCallbackHandler, config);
+    for await (const log of logStream) {
+      if (!runLog) runLog = RunLog.fromRunLogPatch(log);
+      else runLog = runLog.concat(log);
+      if (runLog.state === void 0) throw new Error(`Internal error: "streamEvents" state is missing. Please open a bug report.`);
+      if (!hasEncounteredStartEvent) {
+        hasEncounteredStartEvent = true;
+        const state$2 = { ...runLog.state };
+        const event = {
+          run_id: state$2.id,
+          event: `on_${state$2.type}_start`,
+          name: rootName,
+          tags: rootTags,
+          metadata: rootMetadata,
+          data: { input }
+        };
+        if (rootEventFilter.includeEvent(event, state$2.type)) yield event;
+      }
+      const paths = log.ops.filter((op) => op.path.startsWith("/logs/")).map((op) => op.path.split("/")[2]);
+      const dedupedPaths = [...new Set(paths)];
+      for (const path of dedupedPaths) {
+        let eventType;
+        let data = {};
+        const logEntry = runLog.state.logs[path];
+        if (logEntry.end_time === void 0) if (logEntry.streamed_output.length > 0) eventType = "stream";
+        else eventType = "start";
+        else eventType = "end";
+        if (eventType === "start") {
+          if (logEntry.inputs !== void 0) data.input = logEntry.inputs;
+        } else if (eventType === "end") {
+          if (logEntry.inputs !== void 0) data.input = logEntry.inputs;
+          data.output = logEntry.final_output;
+        } else if (eventType === "stream") {
+          const chunkCount = logEntry.streamed_output.length;
+          if (chunkCount !== 1) throw new Error(`Expected exactly one chunk of streamed output, got ${chunkCount} instead. Encountered in: "${logEntry.name}"`);
+          data = { chunk: logEntry.streamed_output[0] };
+          logEntry.streamed_output = [];
+        }
+        yield {
+          event: `on_${logEntry.type}_${eventType}`,
+          name: logEntry.name,
+          run_id: logEntry.id,
+          tags: logEntry.tags,
+          metadata: logEntry.metadata,
+          data
+        };
+      }
+      const { state: state$1 } = runLog;
+      if (state$1.streamed_output.length > 0) {
+        const chunkCount = state$1.streamed_output.length;
+        if (chunkCount !== 1) throw new Error(`Expected exactly one chunk of streamed output, got ${chunkCount} instead. Encountered in: "${state$1.name}"`);
+        const data = { chunk: state$1.streamed_output[0] };
+        state$1.streamed_output = [];
+        const event = {
+          event: `on_${state$1.type}_stream`,
+          run_id: state$1.id,
+          tags: rootTags,
+          metadata: rootMetadata,
+          name: rootName,
+          data
+        };
+        if (rootEventFilter.includeEvent(event, state$1.type)) yield event;
+      }
+    }
+    const state = runLog?.state;
+    if (state !== void 0) {
+      const event = {
+        event: `on_${state.type}_end`,
+        name: rootName,
+        run_id: state.id,
+        tags: rootTags,
+        metadata: rootMetadata,
+        data: { output: state.final_output }
+      };
+      if (rootEventFilter.includeEvent(event, state.type)) yield event;
+    }
+  }
+  static isRunnable(thing) {
+    return isRunnableInterface(thing);
+  }
+  /**
+  * Bind lifecycle listeners to a Runnable, returning a new Runnable.
+  * The Run object contains information about the run, including its id,
+  * type, input, output, error, startTime, endTime, and any tags or metadata
+  * added to the run.
+  *
+  * @param {Object} params - The object containing the callback functions.
+  * @param {(run: Run) => void} params.onStart - Called before the runnable starts running, with the Run object.
+  * @param {(run: Run) => void} params.onEnd - Called after the runnable finishes running, with the Run object.
+  * @param {(run: Run) => void} params.onError - Called if the runnable throws an error, with the Run object.
+  */
+  withListeners({ onStart, onEnd, onError }) {
+    return new RunnableBinding({
+      bound: this,
+      config: {},
+      configFactories: [(config) => ({ callbacks: [new RootListenersTracer({
+        config,
+        onStart,
+        onEnd,
+        onError
+      })] })]
+    });
+  }
+  /**
+  * Convert a runnable to a tool. Return a new instance of `RunnableToolLike`
+  * which contains the runnable, name, description and schema.
+  *
+  * @template {T extends RunInput = RunInput} RunInput - The input type of the runnable. Should be the same as the `RunInput` type of the runnable.
+  *
+  * @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<T>} [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<T>, RunOutput>} An instance of `RunnableToolLike` which is a runnable that can be used as a tool.
+  */
+  asTool(fields) {
+    return convertRunnableToTool(this, fields);
+  }
+};
+var RunnableBinding = class RunnableBinding2 extends Runnable {
+  static lc_name() {
+    return "RunnableBinding";
+  }
+  lc_namespace = ["langchain_core", "runnables"];
+  lc_serializable = true;
+  bound;
+  config;
+  kwargs;
+  configFactories;
+  constructor(fields) {
+    super(fields);
+    this.bound = fields.bound;
+    this.kwargs = fields.kwargs;
+    this.config = fields.config;
+    this.configFactories = fields.configFactories;
+  }
+  getName(suffix) {
+    return this.bound.getName(suffix);
+  }
+  async _mergeConfig(...options) {
+    const config = mergeConfigs(this.config, ...options);
+    return mergeConfigs(config, ...this.configFactories ? await Promise.all(this.configFactories.map(async (configFactory) => await configFactory(config))) : []);
+  }
+  withConfig(config) {
+    return new this.constructor({
+      bound: this.bound,
+      kwargs: this.kwargs,
+      config: {
+        ...this.config,
+        ...config
+      }
+    });
+  }
+  withRetry(fields) {
+    return new RunnableRetry({
+      bound: this.bound,
+      kwargs: this.kwargs,
+      config: this.config,
+      maxAttemptNumber: fields?.stopAfterAttempt,
+      ...fields
+    });
+  }
+  async invoke(input, options) {
+    return this.bound.invoke(input, await this._mergeConfig(options, this.kwargs));
+  }
+  async batch(inputs, options, batchOptions) {
+    const mergedOptions = Array.isArray(options) ? await Promise.all(options.map(async (individualOption) => this._mergeConfig(ensureConfig(individualOption), this.kwargs))) : 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));
+  }
+  async stream(input, options) {
+    return this.bound.stream(input, await this._mergeConfig(ensureConfig(options), this.kwargs));
+  }
+  async *transform(generator, options) {
+    yield* this.bound.transform(generator, await this._mergeConfig(ensureConfig(options), this.kwargs));
+  }
+  streamEvents(input, options, streamOptions) {
+    const outerThis = this;
+    const generator = async function* () {
+      yield* outerThis.bound.streamEvents(input, {
+        ...await outerThis._mergeConfig(ensureConfig(options), outerThis.kwargs),
+        version: options.version
+      }, streamOptions);
+    };
+    return IterableReadableStream.fromAsyncGenerator(generator());
+  }
+  static isRunnableBinding(thing) {
+    return thing.bound && Runnable.isRunnable(thing.bound);
+  }
+  /**
+  * Bind lifecycle listeners to a Runnable, returning a new Runnable.
+  * The Run object contains information about the run, including its id,
+  * type, input, output, error, startTime, endTime, and any tags or metadata
+  * added to the run.
+  *
+  * @param {Object} params - The object containing the callback functions.
+  * @param {(run: Run) => void} params.onStart - Called before the runnable starts running, with the Run object.
+  * @param {(run: Run) => void} params.onEnd - Called after the runnable finishes running, with the Run object.
+  * @param {(run: Run) => void} params.onError - Called if the runnable throws an error, with the Run object.
+  */
+  withListeners({ onStart, onEnd, onError }) {
+    return new RunnableBinding2({
+      bound: this.bound,
+      kwargs: this.kwargs,
+      config: this.config,
+      configFactories: [(config) => ({ callbacks: [new RootListenersTracer({
+        config,
+        onStart,
+        onEnd,
+        onError
+      })] })]
+    });
+  }
+};
+var RunnableRetry = class extends RunnableBinding {
+  static lc_name() {
+    return "RunnableRetry";
+  }
+  lc_namespace = ["langchain_core", "runnables"];
+  maxAttemptNumber = 3;
+  onFailedAttempt = () => {
+  };
+  constructor(fields) {
+    super(fields);
+    this.maxAttemptNumber = fields.maxAttemptNumber ?? this.maxAttemptNumber;
+    this.onFailedAttempt = fields.onFailedAttempt ?? this.onFailedAttempt;
+  }
+  _patchConfigForRetry(attempt, config, runManager) {
+    const tag = attempt > 1 ? `retry:attempt:${attempt}` : void 0;
+    return patchConfig(config, { callbacks: runManager?.getChild(tag) });
+  }
+  async _invoke(input, config, runManager) {
+    return pRetry((attemptNumber) => super.invoke(input, this._patchConfigForRetry(attemptNumber, config, runManager)), {
+      onFailedAttempt: ({ error }) => this.onFailedAttempt(error, input),
+      retries: Math.max(this.maxAttemptNumber - 1, 0),
+      randomize: true
+    });
+  }
+  /**
+  * Method that invokes the runnable with the specified input, run manager,
+  * and config. It handles the retry logic by catching any errors and
+  * recursively invoking itself with the updated config for the next retry
+  * attempt.
+  * @param input The input for the runnable.
+  * @param runManager The run manager for the runnable.
+  * @param config The config for the runnable.
+  * @returns A promise that resolves to the output of the runnable.
+  */
+  async invoke(input, config) {
+    return this._callWithConfig(this._invoke.bind(this), input, config);
+  }
+  async _batch(inputs, configs, runManagers, batchOptions) {
+    const resultsMap = {};
+    try {
+      await pRetry(async (attemptNumber) => {
+        const remainingIndexes = inputs.map((_, i) => i).filter((i) => resultsMap[i.toString()] === void 0 || resultsMap[i.toString()] instanceof Error);
+        const remainingInputs = remainingIndexes.map((i) => inputs[i]);
+        const patchedConfigs = remainingIndexes.map((i) => this._patchConfigForRetry(attemptNumber, configs?.[i], runManagers?.[i]));
+        const results = await super.batch(remainingInputs, patchedConfigs, {
+          ...batchOptions,
+          returnExceptions: true
+        });
+        let firstException;
+        for (let i = 0; i < results.length; i += 1) {
+          const result = results[i];
+          const resultMapIndex = remainingIndexes[i];
+          if (result instanceof Error) {
+            if (firstException === void 0) {
+              firstException = result;
+              firstException.input = remainingInputs[i];
+            }
+          }
+          resultsMap[resultMapIndex.toString()] = result;
+        }
+        if (firstException) throw firstException;
+        return results;
+      }, {
+        onFailedAttempt: ({ error }) => this.onFailedAttempt(error, error.input),
+        retries: Math.max(this.maxAttemptNumber - 1, 0),
+        randomize: true
+      });
+    } catch (e) {
+      if (batchOptions?.returnExceptions !== true) throw e;
+    }
+    return Object.keys(resultsMap).sort((a, b) => parseInt(a, 10) - parseInt(b, 10)).map((key) => resultsMap[parseInt(key, 10)]);
+  }
+  async batch(inputs, options, batchOptions) {
+    return this._batchWithConfig(this._batch.bind(this), inputs, options, batchOptions);
+  }
+};
+var RunnableSequence = class RunnableSequence2 extends Runnable {
+  static lc_name() {
+    return "RunnableSequence";
+  }
+  first;
+  middle = [];
+  last;
+  omitSequenceTags = false;
+  lc_serializable = true;
+  lc_namespace = ["langchain_core", "runnables"];
+  constructor(fields) {
+    super(fields);
+    this.first = fields.first;
+    this.middle = fields.middle ?? this.middle;
+    this.last = fields.last;
+    this.name = fields.name;
+    this.omitSequenceTags = fields.omitSequenceTags ?? this.omitSequenceTags;
+  }
+  get steps() {
+    return [
+      this.first,
+      ...this.middle,
+      this.last
+    ];
+  }
+  async invoke(input, options) {
+    const config = ensureConfig(options);
+    const callbackManager_ = await getCallbackManagerForConfig(config);
+    const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), config.runId, void 0, void 0, void 0, config?.runName);
+    delete config.runId;
+    let nextStepInput = input;
+    let finalOutput;
+    try {
+      const initialSteps = [this.first, ...this.middle];
+      for (let i = 0; i < initialSteps.length; i += 1) {
+        const step = initialSteps[i];
+        const promise = step.invoke(nextStepInput, patchConfig(config, { callbacks: runManager?.getChild(this.omitSequenceTags ? void 0 : `seq:step:${i + 1}`) }));
+        nextStepInput = await raceWithSignal(promise, options?.signal);
+      }
+      if (options?.signal?.aborted) throw getAbortSignalError(options.signal);
+      finalOutput = await this.last.invoke(nextStepInput, patchConfig(config, { callbacks: runManager?.getChild(this.omitSequenceTags ? void 0 : `seq:step:${this.steps.length}`) }));
+    } catch (e) {
+      await runManager?.handleChainError(e);
+      throw e;
+    }
+    await runManager?.handleChainEnd(_coerceToDict(finalOutput, "output"));
+    return finalOutput;
+  }
+  async batch(inputs, options, batchOptions) {
+    const configList = this._getOptionsList(options ?? {}, inputs.length);
+    const callbackManagers = await Promise.all(configList.map(getCallbackManagerForConfig));
+    const runManagers = await Promise.all(callbackManagers.map(async (callbackManager, i) => {
+      const handleStartRes = await callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"), configList[i].runId, void 0, void 0, void 0, configList[i].runName);
+      delete configList[i].runId;
+      return handleStartRes;
+    }));
+    let nextStepInputs = inputs;
+    try {
+      for (let i = 0; i < this.steps.length; i += 1) {
+        const step = this.steps[i];
+        const promise = step.batch(nextStepInputs, runManagers.map((runManager, j) => {
+          const childRunManager = runManager?.getChild(this.omitSequenceTags ? void 0 : `seq:step:${i + 1}`);
+          return patchConfig(configList[j], { callbacks: childRunManager });
+        }), batchOptions);
+        nextStepInputs = await raceWithSignal(promise, configList[0]?.signal);
+      }
+    } catch (e) {
+      await Promise.all(runManagers.map((runManager) => runManager?.handleChainError(e)));
+      throw e;
+    }
+    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 ?? {};
+    const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), runId, void 0, void 0, void 0, otherOptions?.runName);
+    const steps = [
+      this.first,
+      ...this.middle,
+      this.last
+    ];
+    let concatSupported = true;
+    let finalOutput;
+    async function* inputGenerator() {
+      yield input;
+    }
+    try {
+      let finalGenerator = steps[0].transform(inputGenerator(), patchConfig(otherOptions, { callbacks: runManager?.getChild(this.omitSequenceTags ? void 0 : `seq:step:1`) }));
+      for (let i = 1; i < steps.length; i += 1) {
+        const step = steps[i];
+        finalGenerator = await step.transform(finalGenerator, patchConfig(otherOptions, { callbacks: runManager?.getChild(this.omitSequenceTags ? void 0 : `seq:step:${i + 1}`) }));
+      }
+      for await (const chunk of finalGenerator) {
+        options?.signal?.throwIfAborted();
+        yield chunk;
+        if (concatSupported) if (finalOutput === void 0) finalOutput = chunk;
+        else try {
+          finalOutput = this._concatOutputChunks(finalOutput, chunk);
+        } catch {
+          finalOutput = void 0;
+          concatSupported = false;
+        }
+      }
+    } catch (e) {
+      await runManager?.handleChainError(e);
+      throw e;
+    }
+    await runManager?.handleChainEnd(_coerceToDict(finalOutput, "output"));
+  }
+  getGraph(config) {
+    const graph = new Graph();
+    let currentLastNode = null;
+    this.steps.forEach((step, index) => {
+      const stepGraph = step.getGraph(config);
+      if (index !== 0) stepGraph.trimFirstNode();
+      if (index !== this.steps.length - 1) stepGraph.trimLastNode();
+      graph.extend(stepGraph);
+      const stepFirstNode = stepGraph.firstNode();
+      if (!stepFirstNode) throw new Error(`Runnable ${step} has no first node`);
+      if (currentLastNode) graph.addEdge(currentLastNode, stepFirstNode);
+      currentLastNode = stepGraph.lastNode();
+    });
+    return graph;
+  }
+  pipe(coerceable) {
+    if (RunnableSequence2.isRunnableSequence(coerceable)) return new RunnableSequence2({
+      first: this.first,
+      middle: this.middle.concat([
+        this.last,
+        coerceable.first,
+        ...coerceable.middle
+      ]),
+      last: coerceable.last,
+      name: this.name ?? coerceable.name
+    });
+    else return new RunnableSequence2({
+      first: this.first,
+      middle: [...this.middle, this.last],
+      last: _coerceToRunnable(coerceable),
+      name: this.name
+    });
+  }
+  static isRunnableSequence(thing) {
+    return Array.isArray(thing.middle) && Runnable.isRunnable(thing);
+  }
+  static from([first, ...runnables], nameOrFields) {
+    let extra = {};
+    if (typeof nameOrFields === "string") extra.name = nameOrFields;
+    else if (nameOrFields !== void 0) extra = nameOrFields;
+    return new RunnableSequence2({
+      ...extra,
+      first: _coerceToRunnable(first),
+      middle: runnables.slice(0, -1).map(_coerceToRunnable),
+      last: _coerceToRunnable(runnables[runnables.length - 1])
+    });
+  }
+};
+var RunnableMap = class RunnableMap2 extends Runnable {
+  static lc_name() {
+    return "RunnableMap";
+  }
+  lc_namespace = ["langchain_core", "runnables"];
+  lc_serializable = true;
+  steps;
+  getStepsKeys() {
+    return Object.keys(this.steps);
+  }
+  constructor(fields) {
+    super(fields);
+    this.steps = {};
+    for (const [key, value] of Object.entries(fields.steps)) this.steps[key] = _coerceToRunnable(value);
+  }
+  static from(steps) {
+    return new RunnableMap2({ steps });
+  }
+  async invoke(input, options) {
+    const config = ensureConfig(options);
+    const callbackManager_ = await getCallbackManagerForConfig(config);
+    const runManager = await callbackManager_?.handleChainStart(this.toJSON(), { input }, config.runId, void 0, void 0, void 0, config?.runName);
+    delete config.runId;
+    const output = {};
+    try {
+      const promises = Object.entries(this.steps).map(async ([key, runnable]) => {
+        output[key] = await runnable.invoke(input, patchConfig(config, { callbacks: runManager?.getChild(`map:key:${key}`) }));
+      });
+      await raceWithSignal(Promise.all(promises), options?.signal);
+    } catch (e) {
+      await runManager?.handleChainError(e);
+      throw e;
+    }
+    await runManager?.handleChainEnd(output);
+    return output;
+  }
+  async *_transform(generator, runManager, options) {
+    const steps = { ...this.steps };
+    const inputCopies = atee(generator, Object.keys(steps).length);
+    const tasks = new Map(Object.entries(steps).map(([key, runnable], i) => {
+      const gen = runnable.transform(inputCopies[i], patchConfig(options, { callbacks: runManager?.getChild(`map:key:${key}`) }));
+      return [key, gen.next().then((result) => ({
+        key,
+        gen,
+        result
+      }))];
+    }));
+    while (tasks.size) {
+      const promise = Promise.race(tasks.values());
+      const { key, result, gen } = await raceWithSignal(promise, options?.signal);
+      tasks.delete(key);
+      if (!result.done) {
+        yield { [key]: result.value };
+        tasks.set(key, gen.next().then((result$1) => ({
+          key,
+          gen,
+          result: result$1
+        })));
+      }
+    }
+  }
+  transform(generator, options) {
+    return this._transformStreamWithConfig(generator, this._transform.bind(this), options);
+  }
+  async stream(input, options) {
+    async function* generator() {
+      yield input;
+    }
+    const config = ensureConfig(options);
+    const wrappedGenerator = new AsyncGeneratorWithSetup({
+      generator: this.transform(generator(), config),
+      config
+    });
+    await wrappedGenerator.setup;
+    return IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
+  }
+};
+var RunnableTraceable = class RunnableTraceable2 extends Runnable {
+  lc_serializable = false;
+  lc_namespace = ["langchain_core", "runnables"];
+  func;
+  constructor(fields) {
+    super(fields);
+    if (!isTraceableFunction(fields.func)) throw new Error("RunnableTraceable requires a function that is wrapped in traceable higher-order function");
+    this.func = fields.func;
+  }
+  async invoke(input, options) {
+    const [config] = this._getOptionsList(options ?? {}, 1);
+    const callbacks = await getCallbackManagerForConfig(config);
+    const promise = this.func(patchConfig(config, { callbacks }), input);
+    return raceWithSignal(promise, config?.signal);
+  }
+  async *_streamIterator(input, options) {
+    const [config] = this._getOptionsList(options ?? {}, 1);
+    const result = await this.invoke(input, options);
+    if (isAsyncIterable(result)) {
+      for await (const item of result) {
+        config?.signal?.throwIfAborted();
+        yield item;
+      }
+      return;
+    }
+    if (isIterator(result)) {
+      while (true) {
+        config?.signal?.throwIfAborted();
+        const state = result.next();
+        if (state.done) break;
+        yield state.value;
+      }
+      return;
+    }
+    yield result;
+  }
+  static from(func) {
+    return new RunnableTraceable2({ func });
+  }
+};
+function assertNonTraceableFunction(func) {
+  if (isTraceableFunction(func)) throw new Error("RunnableLambda requires a function that is not wrapped in traceable higher-order function. This shouldn't happen.");
+}
+var RunnableLambda = class RunnableLambda2 extends Runnable {
+  static lc_name() {
+    return "RunnableLambda";
+  }
+  lc_namespace = ["langchain_core", "runnables"];
+  func;
+  constructor(fields) {
+    if (isTraceableFunction(fields.func)) return RunnableTraceable.from(fields.func);
+    super(fields);
+    assertNonTraceableFunction(fields.func);
+    this.func = fields.func;
+  }
+  static from(func) {
+    return new RunnableLambda2({ func });
+  }
+  async _invoke(input, config, runManager) {
+    return new Promise((resolve, reject) => {
+      const childConfig = patchConfig(config, {
+        callbacks: runManager?.getChild(),
+        recursionLimit: (config?.recursionLimit ?? DEFAULT_RECURSION_LIMIT) - 1
+      });
+      AsyncLocalStorageProviderSingleton.runWithConfig(pickRunnableConfigKeys(childConfig), async () => {
+        try {
+          let output = await this.func(input, { ...childConfig });
+          if (output && Runnable.isRunnable(output)) {
+            if (config?.recursionLimit === 0) throw new Error("Recursion limit reached.");
+            output = await output.invoke(input, {
+              ...childConfig,
+              recursionLimit: (childConfig.recursionLimit ?? DEFAULT_RECURSION_LIMIT) - 1
+            });
+          } else if (isAsyncIterable(output)) {
+            let finalOutput;
+            for await (const chunk of consumeAsyncIterableInContext(childConfig, output)) {
+              config?.signal?.throwIfAborted();
+              if (finalOutput === void 0) finalOutput = chunk;
+              else try {
+                finalOutput = this._concatOutputChunks(finalOutput, chunk);
+              } catch {
+                finalOutput = chunk;
+              }
+            }
+            output = finalOutput;
+          } else if (isIterableIterator(output)) {
+            let finalOutput;
+            for (const chunk of consumeIteratorInContext(childConfig, output)) {
+              config?.signal?.throwIfAborted();
+              if (finalOutput === void 0) finalOutput = chunk;
+              else try {
+                finalOutput = this._concatOutputChunks(finalOutput, chunk);
+              } catch {
+                finalOutput = chunk;
+              }
+            }
+            output = finalOutput;
+          }
+          resolve(output);
+        } catch (e) {
+          reject(e);
+        }
+      });
+    });
+  }
+  async invoke(input, options) {
+    return this._callWithConfig(this._invoke.bind(this), input, options);
+  }
+  async *_transform(generator, runManager, config) {
+    let finalChunk;
+    for await (const chunk of generator) if (finalChunk === void 0) finalChunk = chunk;
+    else try {
+      finalChunk = this._concatOutputChunks(finalChunk, chunk);
+    } catch {
+      finalChunk = chunk;
+    }
+    const childConfig = patchConfig(config, {
+      callbacks: runManager?.getChild(),
+      recursionLimit: (config?.recursionLimit ?? DEFAULT_RECURSION_LIMIT) - 1
+    });
+    const output = await new Promise((resolve, reject) => {
+      AsyncLocalStorageProviderSingleton.runWithConfig(pickRunnableConfigKeys(childConfig), async () => {
+        try {
+          const res = await this.func(finalChunk, {
+            ...childConfig,
+            config: childConfig
+          });
+          resolve(res);
+        } catch (e) {
+          reject(e);
+        }
+      });
+    });
+    if (output && Runnable.isRunnable(output)) {
+      if (config?.recursionLimit === 0) throw new Error("Recursion limit reached.");
+      const stream = await output.stream(finalChunk, childConfig);
+      for await (const chunk of stream) yield chunk;
+    } else if (isAsyncIterable(output)) for await (const chunk of consumeAsyncIterableInContext(childConfig, output)) {
+      config?.signal?.throwIfAborted();
+      yield chunk;
+    }
+    else if (isIterableIterator(output)) for (const chunk of consumeIteratorInContext(childConfig, output)) {
+      config?.signal?.throwIfAborted();
+      yield chunk;
+    }
+    else yield output;
+  }
+  transform(generator, options) {
+    return this._transformStreamWithConfig(generator, this._transform.bind(this), options);
+  }
+  async stream(input, options) {
+    async function* generator() {
+      yield input;
+    }
+    const config = ensureConfig(options);
+    const wrappedGenerator = new AsyncGeneratorWithSetup({
+      generator: this.transform(generator(), config),
+      config
+    });
+    await wrappedGenerator.setup;
+    return IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
+  }
+};
+var RunnableWithFallbacks = class extends Runnable {
+  static lc_name() {
+    return "RunnableWithFallbacks";
+  }
+  lc_namespace = ["langchain_core", "runnables"];
+  lc_serializable = true;
+  runnable;
+  fallbacks;
+  constructor(fields) {
+    super(fields);
+    this.runnable = fields.runnable;
+    this.fallbacks = fields.fallbacks;
+  }
+  *runnables() {
+    yield this.runnable;
+    for (const fallback of this.fallbacks) yield fallback;
+  }
+  async invoke(input, options) {
+    const config = ensureConfig(options);
+    const callbackManager_ = await getCallbackManagerForConfig(config);
+    const { runId, ...otherConfigFields } = config;
+    const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), runId, void 0, void 0, void 0, otherConfigFields?.runName);
+    const childConfig = patchConfig(otherConfigFields, { callbacks: runManager?.getChild() });
+    const res = await AsyncLocalStorageProviderSingleton.runWithConfig(childConfig, async () => {
+      let firstError;
+      for (const runnable of this.runnables()) {
+        config?.signal?.throwIfAborted();
+        try {
+          const output = await runnable.invoke(input, childConfig);
+          await runManager?.handleChainEnd(_coerceToDict(output, "output"));
+          return output;
+        } catch (e) {
+          if (firstError === void 0) firstError = e;
+        }
+      }
+      if (firstError === void 0) throw new Error("No error stored at end of fallback.");
+      await runManager?.handleChainError(firstError);
+      throw firstError;
+    });
+    return res;
+  }
+  async *_streamIterator(input, options) {
+    const config = ensureConfig(options);
+    const callbackManager_ = await getCallbackManagerForConfig(config);
+    const { runId, ...otherConfigFields } = config;
+    const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), runId, void 0, void 0, void 0, otherConfigFields?.runName);
+    let firstError;
+    let stream;
+    for (const runnable of this.runnables()) {
+      config?.signal?.throwIfAborted();
+      const childConfig = patchConfig(otherConfigFields, { callbacks: runManager?.getChild() });
+      try {
+        const originalStream = await runnable.stream(input, childConfig);
+        stream = consumeAsyncIterableInContext(childConfig, originalStream);
+        break;
+      } catch (e) {
+        if (firstError === void 0) firstError = e;
+      }
+    }
+    if (stream === void 0) {
+      const error = firstError ?? /* @__PURE__ */ 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 === void 0 ? output : this._concatOutputChunks(output, chunk);
+        } catch {
+          output = void 0;
+        }
+      }
+    } 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.");
+    const configList = this._getOptionsList(options ?? {}, inputs.length);
+    const callbackManagers = await Promise.all(configList.map((config) => getCallbackManagerForConfig(config)));
+    const runManagers = await Promise.all(callbackManagers.map(async (callbackManager, i) => {
+      const handleStartRes = await callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"), configList[i].runId, void 0, void 0, void 0, configList[i].runName);
+      delete configList[i].runId;
+      return handleStartRes;
+    }));
+    let firstError;
+    for (const runnable of this.runnables()) {
+      configList[0].signal?.throwIfAborted();
+      try {
+        const outputs = await runnable.batch(inputs, runManagers.map((runManager, j) => patchConfig(configList[j], { callbacks: runManager?.getChild() })), batchOptions);
+        await Promise.all(runManagers.map((runManager, i) => runManager?.handleChainEnd(_coerceToDict(outputs[i], "output"))));
+        return outputs;
+      } catch (e) {
+        if (firstError === void 0) firstError = e;
+      }
+    }
+    if (!firstError) throw new Error("No error stored at end of fallbacks.");
+    await Promise.all(runManagers.map((runManager) => runManager?.handleChainError(firstError)));
+    throw firstError;
+  }
+};
+function _coerceToRunnable(coerceable) {
+  if (typeof coerceable === "function") return new RunnableLambda({ func: coerceable });
+  else if (Runnable.isRunnable(coerceable)) return coerceable;
+  else if (!Array.isArray(coerceable) && typeof coerceable === "object") {
+    const runnables = {};
+    for (const [key, value] of Object.entries(coerceable)) runnables[key] = _coerceToRunnable(value);
+    return new RunnableMap({ steps: runnables });
+  } else throw new Error(`Expected a Runnable, function or object.
+Instead got an unsupported type.`);
+}
+var RunnableAssign = class extends Runnable {
+  static lc_name() {
+    return "RunnableAssign";
+  }
+  lc_namespace = ["langchain_core", "runnables"];
+  lc_serializable = true;
+  mapper;
+  constructor(fields) {
+    if (fields instanceof RunnableMap) fields = { mapper: fields };
+    super(fields);
+    this.mapper = fields.mapper;
+  }
+  async invoke(input, options) {
+    const mapperResult = await this.mapper.invoke(input, options);
+    return {
+      ...input,
+      ...mapperResult
+    };
+  }
+  async *_transform(generator, runManager, options) {
+    const mapperKeys = this.mapper.getStepsKeys();
+    const [forPassthrough, forMapper] = atee(generator);
+    const mapperOutput = this.mapper.transform(forMapper, patchConfig(options, { callbacks: runManager?.getChild() }));
+    const firstMapperChunkPromise = mapperOutput.next();
+    for await (const chunk of forPassthrough) {
+      if (typeof chunk !== "object" || Array.isArray(chunk)) throw new Error(`RunnableAssign can only be used with objects as input, got ${typeof chunk}`);
+      const filtered = Object.fromEntries(Object.entries(chunk).filter(([key]) => !mapperKeys.includes(key)));
+      if (Object.keys(filtered).length > 0) yield filtered;
+    }
+    yield (await firstMapperChunkPromise).value;
+    for await (const chunk of mapperOutput) yield chunk;
+  }
+  transform(generator, options) {
+    return this._transformStreamWithConfig(generator, this._transform.bind(this), options);
+  }
+  async stream(input, options) {
+    async function* generator() {
+      yield input;
+    }
+    const config = ensureConfig(options);
+    const wrappedGenerator = new AsyncGeneratorWithSetup({
+      generator: this.transform(generator(), config),
+      config
+    });
+    await wrappedGenerator.setup;
+    return IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
+  }
+};
+var RunnablePick = class extends Runnable {
+  static lc_name() {
+    return "RunnablePick";
+  }
+  lc_namespace = ["langchain_core", "runnables"];
+  lc_serializable = true;
+  keys;
+  constructor(fields) {
+    if (typeof fields === "string" || Array.isArray(fields)) fields = { keys: fields };
+    super(fields);
+    this.keys = fields.keys;
+  }
+  async _pick(input) {
+    if (typeof this.keys === "string") return input[this.keys];
+    else {
+      const picked = this.keys.map((key) => [key, input[key]]).filter((v) => v[1] !== void 0);
+      return picked.length === 0 ? void 0 : Object.fromEntries(picked);
+    }
+  }
+  async invoke(input, options) {
+    return this._callWithConfig(this._pick.bind(this), input, options);
+  }
+  async *_transform(generator) {
+    for await (const chunk of generator) {
+      const picked = await this._pick(chunk);
+      if (picked !== void 0) yield picked;
+    }
+  }
+  transform(generator, options) {
+    return this._transformStreamWithConfig(generator, this._transform.bind(this), options);
+  }
+  async stream(input, options) {
+    async function* generator() {
+      yield input;
+    }
+    const config = ensureConfig(options);
+    const wrappedGenerator = new AsyncGeneratorWithSetup({
+      generator: this.transform(generator(), config),
+      config
+    });
+    await wrappedGenerator.setup;
+    return IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
+  }
+};
+var RunnableToolLike = class extends RunnableBinding {
+  name;
+  description;
+  schema;
+  constructor(fields) {
+    const sequence = RunnableSequence.from([RunnableLambda.from(async (input) => {
+      let toolInput;
+      if (_isToolCall(input)) try {
+        toolInput = await interopParseAsync(this.schema, input.args);
+      } catch {
+        throw new ToolInputParsingException(`Received tool input did not match expected schema`, JSON.stringify(input.args));
+      }
+      else toolInput = input;
+      return toolInput;
+    }).withConfig({ runName: `${fields.name}:parse_input` }), fields.bound]).withConfig({ runName: fields.name });
+    super({
+      bound: sequence,
+      config: fields.config ?? {}
+    });
+    this.name = fields.name;
+    this.description = fields.description;
+    this.schema = fields.schema;
+  }
+  static lc_name() {
+    return "RunnableToolLike";
+  }
+};
+function convertRunnableToTool(runnable, fields) {
+  const name = fields.name ?? runnable.getName();
+  const description = fields.description ?? getSchemaDescription(fields.schema);
+  if (isSimpleStringZodSchema(fields.schema)) return new RunnableToolLike({
+    name,
+    description,
+    schema: objectType({ input: stringType() }).transform((input) => input.input),
+    bound: runnable
+  });
+  return new RunnableToolLike({
+    name,
+    description,
+    schema: fields.schema,
+    bound: runnable
+  });
+}
+export {
+  Runnable,
+  RunnableAssign,
+  RunnableBinding,
+  RunnableLambda,
+  RunnableMap,
+  RunnablePick,
+  RunnableRetry,
+  RunnableSequence,
+  RunnableToolLike,
+  RunnableWithFallbacks,
+  _coerceToDict,
+  _coerceToRunnable
+};
+//# sourceMappingURL=index.es64.js.map