langgraph-ui-components 0.0.24 → 0.0.25

package/dist/node_modules/.pnpm/@langchain_core@1.1.13_openai@6.16.0_zod@4.3.5_/node_modules/@langchain/core/dist/runnables/base.es.js

@@ -1,1237 +0,0 @@
-import { Serializable as rt } from "../load/serializable.es.js";
-import { _isToolCall as st, ToolInputParsingException as it } from "../tools/utils.es.js";
-import { AsyncLocalStorageProviderSingleton as M } from "../singletons/async_local_storage/index.es.js";
-import "../singletons/index.es.js";
-import { patchConfig as b, DEFAULT_RECURSION_LIMIT as T, pickRunnableConfigKeys as W, ensureConfig as f, getCallbackManagerForConfig as C, mergeConfigs as G } from "./config.es.js";
-import { raceWithSignal as I, getAbortSignalError as ot } from "../utils/signal.es.js";
-import { AsyncGeneratorWithSetup as x, IterableReadableStream as A, concat as ct, pipeGeneratorWithSetup as lt, atee as K } from "../utils/stream.es.js";
-import { isLogStreamHandler as ut, LogStreamCallbackHandler as j, RunLog as ht, RunLogPatch as dt } from "../tracers/log_stream.es.js";
-import { isStreamEventsHandler as mt, EventStreamCallbackHandler as ft } from "../tracers/event_stream.es.js";
-import { pRetry as z } from "../utils/p-retry/index.es.js";
-import { AsyncCaller as pt } from "../utils/async_caller.es.js";
-import { RootListenersTracer as V } from "../tracers/root_listener.es.js";
-import { _RootEventFilter as gt, isRunnableInterface as bt } from "./utils.es.js";
-import { getSchemaDescription as wt, isSimpleStringZodSchema as yt, interopParseAsync as vt } from "../utils/types/zod.es.js";
-import { Graph as U } from "./graph.es.js";
-import { convertToHttpEventStream as kt } from "./wrappers.es.js";
-import { isAsyncIterable as P, consumeAsyncIterableInContext as F, isIterableIterator as J, consumeIteratorInContext as H, isIterator as _t } from "./iter.es.js";
-import { isTraceableFunction as $ } from "../../../../../../langsmith@0.4.6_openai@6.16.0_zod@4.3.5_/node_modules/langsmith/dist/singletons/traceable.es.js";
-import Ct from "../../../../../../uuid@10.0.0/node_modules/uuid/dist/esm-browser/v4.es.js";
-import { any as B, object as Et, string as St } from "../../../../../../zod@4.3.5/node_modules/zod/v3/types.es.js";
-function p(n, t) {
-  return n && !Array.isArray(n) && !(n instanceof Date) && typeof n == "object" ? n : { [t]: n };
-}
-var y = class extends rt {
-  lc_runnable = !0;
-  name;
-  getName(n) {
-    const t = this.name ?? this.constructor.lc_name() ?? this.constructor.name;
-    return n ? `${t}${n}` : t;
-  }
-  /**
-  * 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(n) {
-    return new X({
-      bound: this,
-      kwargs: {},
-      config: {},
-      maxAttemptNumber: n?.stopAfterAttempt,
-      ...n
-    });
-  }
-  /**
-  * 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(n) {
-    return new O({
-      bound: this,
-      config: n,
-      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(n) {
-    const t = Array.isArray(n) ? n : n.fallbacks;
-    return new Rt({
-      runnable: this,
-      fallbacks: t
-    });
-  }
-  _getOptionsList(n, t = 0) {
-    if (Array.isArray(n) && n.length !== t) throw new Error(`Passed "options" must be an array with the same length as the inputs, but got ${n.length} options for ${t} inputs`);
-    if (Array.isArray(n)) return n.map(f);
-    if (t > 1 && !Array.isArray(n) && n.runId) {
-      console.warn("Provided runId will be used only for the first element of the batch.");
-      const e = Object.fromEntries(Object.entries(n).filter(([a]) => a !== "runId"));
-      return Array.from({ length: t }, (a, s) => f(s === 0 ? n : e));
-    }
-    return Array.from({ length: t }, () => f(n));
-  }
-  async batch(n, t, e) {
-    const a = this._getOptionsList(t ?? {}, n.length), s = a[0]?.maxConcurrency ?? e?.maxConcurrency, i = new pt({
-      maxConcurrency: s,
-      onFailedAttempt: (r) => {
-        throw r;
-      }
-    }), c = n.map((r, o) => i.call(async () => {
-      try {
-        return await this.invoke(r, a[o]);
-      } catch (l) {
-        if (e?.returnExceptions) return l;
-        throw l;
-      }
-    }));
-    return Promise.all(c);
-  }
-  /**
-  * Default streaming implementation.
-  * Subclasses should override this method if they support streaming output.
-  * @param input
-  * @param options
-  */
-  async *_streamIterator(n, t) {
-    yield this.invoke(n, t);
-  }
-  /**
-  * Stream output in chunks.
-  * @param input
-  * @param options
-  * @returns A readable stream that is also an iterable.
-  */
-  async stream(n, t) {
-    const e = f(t), a = new x({
-      generator: this._streamIterator(n, e),
-      config: e
-    });
-    return await a.setup, A.fromAsyncGenerator(a);
-  }
-  _separateRunnableConfigFromCallOptions(n) {
-    let t;
-    n === void 0 ? t = f(n) : t = f({
-      callbacks: n.callbacks,
-      tags: n.tags,
-      metadata: n.metadata,
-      runName: n.runName,
-      configurable: n.configurable,
-      recursionLimit: n.recursionLimit,
-      maxConcurrency: n.maxConcurrency,
-      runId: n.runId,
-      timeout: n.timeout,
-      signal: n.signal
-    });
-    const e = { ...n };
-    return delete e.callbacks, delete e.tags, delete e.metadata, delete e.runName, delete e.configurable, delete e.recursionLimit, delete e.maxConcurrency, delete e.runId, delete e.timeout, delete e.signal, [t, e];
-  }
-  async _callWithConfig(n, t, e) {
-    const a = f(e), i = await (await C(a))?.handleChainStart(this.toJSON(), p(t, "input"), a.runId, a?.runType, void 0, void 0, a?.runName ?? this.getName());
-    delete a.runId;
-    let c;
-    try {
-      const r = n.call(this, t, a, i);
-      c = await I(r, e?.signal);
-    } catch (r) {
-      throw await i?.handleChainError(r), r;
-    }
-    return await i?.handleChainEnd(p(c, "output")), c;
-  }
-  /**
-  * 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(n, t, e, a) {
-    const s = this._getOptionsList(e ?? {}, t.length), i = await Promise.all(s.map(C)), c = await Promise.all(i.map(async (o, l) => {
-      const h = await o?.handleChainStart(this.toJSON(), p(t[l], "input"), s[l].runId, s[l].runType, void 0, void 0, s[l].runName ?? this.getName());
-      return delete s[l].runId, h;
-    }));
-    let r;
-    try {
-      const o = n.call(this, t, s, c, a);
-      r = await I(o, s?.[0]?.signal);
-    } catch (o) {
-      throw await Promise.all(c.map((l) => l?.handleChainError(o))), o;
-    }
-    return await Promise.all(c.map((o) => o?.handleChainEnd(p(r, "output")))), r;
-  }
-  /** @internal */
-  _concatOutputChunks(n, t) {
-    return ct(n, t);
-  }
-  /**
-  * 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(n, t, e) {
-    let a, s = !0, i, c = !0;
-    const r = f(e), o = await C(r), l = this;
-    async function* h() {
-      for await (const d of n) {
-        if (s) if (a === void 0) a = d;
-        else try {
-          a = l._concatOutputChunks(a, d);
-        } catch {
-          a = void 0, s = !1;
-        }
-        yield d;
-      }
-    }
-    let u;
-    try {
-      const d = await lt(t.bind(this), h(), async () => o?.handleChainStart(this.toJSON(), { input: "" }, r.runId, r.runType, void 0, void 0, r.runName ?? this.getName(), void 0, { lc_defers_inputs: !0 }), e?.signal, r);
-      delete r.runId, u = d.setup;
-      const m = u?.handlers.find(mt);
-      let k = d.output;
-      m !== void 0 && u !== void 0 && (k = m.tapOutputIterable(u.runId, k));
-      const R = u?.handlers.find(ut);
-      R !== void 0 && u !== void 0 && (k = R.tapOutputIterable(u.runId, k));
-      for await (const w of k)
-        if (yield w, c) if (i === void 0) i = w;
-        else try {
-          i = this._concatOutputChunks(i, w);
-        } catch {
-          i = void 0, c = !1;
-        }
-    } catch (d) {
-      throw await u?.handleChainError(d, void 0, void 0, void 0, { inputs: p(a, "input") }), d;
-    }
-    await u?.handleChainEnd(i ?? {}, void 0, void 0, void 0, { inputs: p(a, "input") });
-  }
-  getGraph(n) {
-    const t = new U(), e = t.addNode({
-      name: `${this.getName()}Input`,
-      schema: B()
-    }), a = t.addNode(this), s = t.addNode({
-      name: `${this.getName()}Output`,
-      schema: B()
-    });
-    return t.addEdge(e, a), t.addEdge(a, s), t;
-  }
-  /**
-  * 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(n) {
-    return new Y({
-      first: this,
-      last: S(n)
-    });
-  }
-  /**
-  * Pick keys from the dict output of this runnable. Returns a new runnable.
-  */
-  pick(n) {
-    return this.pipe(new xt(n));
-  }
-  /**
-  * Assigns new fields to the dict output of this runnable. Returns a new runnable.
-  */
-  assign(n) {
-    return this.pipe(new Nt(new L({ steps: n })));
-  }
-  /**
-  * 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(n, t) {
-    let e;
-    for await (const a of n) e === void 0 ? e = a : e = this._concatOutputChunks(e, a);
-    yield* this._streamIterator(e, f(t));
-  }
-  /**
-  * 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(n, t, e) {
-    const a = new j({
-      ...e,
-      autoClose: !1,
-      _schemaFormat: "original"
-    }), s = f(t);
-    yield* this._streamLog(n, a, s);
-  }
-  async *_streamLog(n, t, e) {
-    const { callbacks: a } = e;
-    if (a === void 0) e.callbacks = [t];
-    else if (Array.isArray(a)) e.callbacks = a.concat([t]);
-    else {
-      const r = a.copy();
-      r.addHandler(t, !0), e.callbacks = r;
-    }
-    const s = this.stream(n, e);
-    async function i() {
-      try {
-        const r = await s;
-        for await (const o of r) {
-          const l = new dt({ ops: [{
-            op: "add",
-            path: "/streamed_output/-",
-            value: o
-          }] });
-          await t.writer.write(l);
-        }
-      } finally {
-        await t.writer.close();
-      }
-    }
-    const c = i();
-    try {
-      for await (const r of t) yield r;
-    } finally {
-      await c;
-    }
-  }
-  streamEvents(n, t, e) {
-    let a;
-    if (t.version === "v1") a = this._streamEventsV1(n, t, e);
-    else if (t.version === "v2") a = this._streamEventsV2(n, t, e);
-    else throw new Error('Only versions "v1" and "v2" of the schema are currently supported.');
-    return t.encoding === "text/event-stream" ? kt(a) : A.fromAsyncGenerator(a);
-  }
-  async *_streamEventsV2(n, t, e) {
-    const a = new ft({
-      ...e,
-      autoClose: !1
-    }), s = f(t), i = s.runId ?? Ct();
-    s.runId = i;
-    const c = s.callbacks;
-    if (c === void 0) s.callbacks = [a];
-    else if (Array.isArray(c)) s.callbacks = c.concat(a);
-    else {
-      const m = c.copy();
-      m.addHandler(a, !0), s.callbacks = m;
-    }
-    const r = new AbortController(), o = this;
-    async function l() {
-      let m, k = null;
-      try {
-        t?.signal ? "any" in AbortSignal ? m = AbortSignal.any([r.signal, t.signal]) : (m = t.signal, k = () => {
-          r.abort();
-        }, t.signal.addEventListener("abort", k, { once: !0 })) : m = r.signal;
-        const R = await o.stream(n, {
-          ...s,
-          signal: m
-        }), w = a.tapOutputIterable(i, R);
-        for await (const v of w) if (r.signal.aborted) break;
-      } finally {
-        await a.finish(), m && k && m.removeEventListener("abort", k);
-      }
-    }
-    const h = l();
-    let u = !1, d;
-    try {
-      for await (const m of a) {
-        if (!u) {
-          m.data.input = n, u = !0, d = m.run_id, yield m;
-          continue;
-        }
-        m.run_id === d && m.event.endsWith("_end") && m.data?.input && delete m.data.input, yield m;
-      }
-    } finally {
-      r.abort(), await h;
-    }
-  }
-  async *_streamEventsV1(n, t, e) {
-    let a, s = !1;
-    const i = f(t), c = i.tags ?? [], r = i.metadata ?? {}, o = i.runName ?? this.getName(), l = new j({
-      ...e,
-      autoClose: !1,
-      _schemaFormat: "streaming_events"
-    }), h = new gt({ ...e }), u = this._streamLog(n, l, i);
-    for await (const m of u) {
-      if (a ? a = a.concat(m) : a = ht.fromRunLogPatch(m), a.state === void 0) throw new Error('Internal error: "streamEvents" state is missing. Please open a bug report.');
-      if (!s) {
-        s = !0;
-        const v = { ...a.state }, _ = {
-          run_id: v.id,
-          event: `on_${v.type}_start`,
-          name: o,
-          tags: c,
-          metadata: r,
-          data: { input: n }
-        };
-        h.includeEvent(_, v.type) && (yield _);
-      }
-      const k = m.ops.filter((v) => v.path.startsWith("/logs/")).map((v) => v.path.split("/")[2]), R = [...new Set(k)];
-      for (const v of R) {
-        let _, E = {};
-        const g = a.state.logs[v];
-        if (g.end_time === void 0 ? g.streamed_output.length > 0 ? _ = "stream" : _ = "start" : _ = "end", _ === "start")
-          g.inputs !== void 0 && (E.input = g.inputs);
-        else if (_ === "end")
-          g.inputs !== void 0 && (E.input = g.inputs), E.output = g.final_output;
-        else if (_ === "stream") {
-          const q = g.streamed_output.length;
-          if (q !== 1) throw new Error(`Expected exactly one chunk of streamed output, got ${q} instead. Encountered in: "${g.name}"`);
-          E = { chunk: g.streamed_output[0] }, g.streamed_output = [];
-        }
-        yield {
-          event: `on_${g.type}_${_}`,
-          name: g.name,
-          run_id: g.id,
-          tags: g.tags,
-          metadata: g.metadata,
-          data: E
-        };
-      }
-      const { state: w } = a;
-      if (w.streamed_output.length > 0) {
-        const v = w.streamed_output.length;
-        if (v !== 1) throw new Error(`Expected exactly one chunk of streamed output, got ${v} instead. Encountered in: "${w.name}"`);
-        const _ = { chunk: w.streamed_output[0] };
-        w.streamed_output = [];
-        const E = {
-          event: `on_${w.type}_stream`,
-          run_id: w.id,
-          tags: c,
-          metadata: r,
-          name: o,
-          data: _
-        };
-        h.includeEvent(E, w.type) && (yield E);
-      }
-    }
-    const d = a?.state;
-    if (d !== void 0) {
-      const m = {
-        event: `on_${d.type}_end`,
-        name: o,
-        run_id: d.id,
-        tags: c,
-        metadata: r,
-        data: { output: d.final_output }
-      };
-      h.includeEvent(m, d.type) && (yield m);
-    }
-  }
-  static isRunnable(n) {
-    return bt(n);
-  }
-  /**
-  * 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: n, onEnd: t, onError: e }) {
-    return new O({
-      bound: this,
-      config: {},
-      configFactories: [(a) => ({ callbacks: [new V({
-        config: a,
-        onStart: n,
-        onEnd: t,
-        onError: e
-      })] })]
-    });
-  }
-  /**
-  * 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(n) {
-    return Ot(this, n);
-  }
-}, O = class Z extends y {
-  static lc_name() {
-    return "RunnableBinding";
-  }
-  lc_namespace = ["langchain_core", "runnables"];
-  lc_serializable = !0;
-  bound;
-  config;
-  kwargs;
-  configFactories;
-  constructor(t) {
-    super(t), this.bound = t.bound, this.kwargs = t.kwargs, this.config = t.config, this.configFactories = t.configFactories;
-  }
-  getName(t) {
-    return this.bound.getName(t);
-  }
-  async _mergeConfig(...t) {
-    const e = G(this.config, ...t);
-    return G(e, ...this.configFactories ? await Promise.all(this.configFactories.map(async (a) => await a(e))) : []);
-  }
-  withConfig(t) {
-    return new this.constructor({
-      bound: this.bound,
-      kwargs: this.kwargs,
-      config: {
-        ...this.config,
-        ...t
-      }
-    });
-  }
-  withRetry(t) {
-    return new X({
-      bound: this.bound,
-      kwargs: this.kwargs,
-      config: this.config,
-      maxAttemptNumber: t?.stopAfterAttempt,
-      ...t
-    });
-  }
-  async invoke(t, e) {
-    return this.bound.invoke(t, await this._mergeConfig(e, this.kwargs));
-  }
-  async batch(t, e, a) {
-    const s = Array.isArray(e) ? await Promise.all(e.map(async (i) => this._mergeConfig(f(i), this.kwargs))) : await this._mergeConfig(f(e), this.kwargs);
-    return this.bound.batch(t, s, a);
-  }
-  /** @internal */
-  _concatOutputChunks(t, e) {
-    return this.bound._concatOutputChunks(t, e);
-  }
-  async *_streamIterator(t, e) {
-    yield* this.bound._streamIterator(t, await this._mergeConfig(f(e), this.kwargs));
-  }
-  async stream(t, e) {
-    return this.bound.stream(t, await this._mergeConfig(f(e), this.kwargs));
-  }
-  async *transform(t, e) {
-    yield* this.bound.transform(t, await this._mergeConfig(f(e), this.kwargs));
-  }
-  streamEvents(t, e, a) {
-    const s = this, i = async function* () {
-      yield* s.bound.streamEvents(t, {
-        ...await s._mergeConfig(f(e), s.kwargs),
-        version: e.version
-      }, a);
-    };
-    return A.fromAsyncGenerator(i());
-  }
-  static isRunnableBinding(t) {
-    return t.bound && y.isRunnable(t.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: t, onEnd: e, onError: a }) {
-    return new Z({
-      bound: this.bound,
-      kwargs: this.kwargs,
-      config: this.config,
-      configFactories: [(s) => ({ callbacks: [new V({
-        config: s,
-        onStart: t,
-        onEnd: e,
-        onError: a
-      })] })]
-    });
-  }
-}, Xt = class Q extends y {
-  static lc_name() {
-    return "RunnableEach";
-  }
-  lc_serializable = !0;
-  lc_namespace = ["langchain_core", "runnables"];
-  bound;
-  constructor(t) {
-    super(t), this.bound = t.bound;
-  }
-  /**
-  * Invokes the runnable with the specified input and configuration.
-  * @param input The input to invoke the runnable with.
-  * @param config The configuration to invoke the runnable with.
-  * @returns A promise that resolves to the output of the runnable.
-  */
-  async invoke(t, e) {
-    return this._callWithConfig(this._invoke.bind(this), t, e);
-  }
-  /**
-  * A helper method that is used to invoke the runnable with the specified input and configuration.
-  * @param input The input to invoke the runnable with.
-  * @param config The configuration to invoke the runnable with.
-  * @returns A promise that resolves to the output of the runnable.
-  */
-  async _invoke(t, e, a) {
-    return this.bound.batch(t, b(e, { callbacks: a?.getChild() }));
-  }
-  /**
-  * 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: t, onEnd: e, onError: a }) {
-    return new Q({ bound: this.bound.withListeners({
-      onStart: t,
-      onEnd: e,
-      onError: a
-    }) });
-  }
-}, X = class extends O {
-  static lc_name() {
-    return "RunnableRetry";
-  }
-  lc_namespace = ["langchain_core", "runnables"];
-  maxAttemptNumber = 3;
-  onFailedAttempt = () => {
-  };
-  constructor(n) {
-    super(n), this.maxAttemptNumber = n.maxAttemptNumber ?? this.maxAttemptNumber, this.onFailedAttempt = n.onFailedAttempt ?? this.onFailedAttempt;
-  }
-  _patchConfigForRetry(n, t, e) {
-    const a = n > 1 ? `retry:attempt:${n}` : void 0;
-    return b(t, { callbacks: e?.getChild(a) });
-  }
-  async _invoke(n, t, e) {
-    return z((a) => super.invoke(n, this._patchConfigForRetry(a, t, e)), {
-      onFailedAttempt: ({ error: a }) => this.onFailedAttempt(a, n),
-      retries: Math.max(this.maxAttemptNumber - 1, 0),
-      randomize: !0
-    });
-  }
-  /**
-  * 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(n, t) {
-    return this._callWithConfig(this._invoke.bind(this), n, t);
-  }
-  async _batch(n, t, e, a) {
-    const s = {};
-    try {
-      await z(async (i) => {
-        const c = n.map((u, d) => d).filter((u) => s[u.toString()] === void 0 || s[u.toString()] instanceof Error), r = c.map((u) => n[u]), o = c.map((u) => this._patchConfigForRetry(i, t?.[u], e?.[u])), l = await super.batch(r, o, {
-          ...a,
-          returnExceptions: !0
-        });
-        let h;
-        for (let u = 0; u < l.length; u += 1) {
-          const d = l[u], m = c[u];
-          d instanceof Error && h === void 0 && (h = d, h.input = r[u]), s[m.toString()] = d;
-        }
-        if (h) throw h;
-        return l;
-      }, {
-        onFailedAttempt: ({ error: i }) => this.onFailedAttempt(i, i.input),
-        retries: Math.max(this.maxAttemptNumber - 1, 0),
-        randomize: !0
-      });
-    } catch (i) {
-      if (a?.returnExceptions !== !0) throw i;
-    }
-    return Object.keys(s).sort((i, c) => parseInt(i, 10) - parseInt(c, 10)).map((i) => s[parseInt(i, 10)]);
-  }
-  async batch(n, t, e) {
-    return this._batchWithConfig(this._batch.bind(this), n, t, e);
-  }
-}, Y = class N extends y {
-  static lc_name() {
-    return "RunnableSequence";
-  }
-  first;
-  middle = [];
-  last;
-  omitSequenceTags = !1;
-  lc_serializable = !0;
-  lc_namespace = ["langchain_core", "runnables"];
-  constructor(t) {
-    super(t), this.first = t.first, this.middle = t.middle ?? this.middle, this.last = t.last, this.name = t.name, this.omitSequenceTags = t.omitSequenceTags ?? this.omitSequenceTags;
-  }
-  get steps() {
-    return [
-      this.first,
-      ...this.middle,
-      this.last
-    ];
-  }
-  async invoke(t, e) {
-    const a = f(e), i = await (await C(a))?.handleChainStart(this.toJSON(), p(t, "input"), a.runId, void 0, void 0, void 0, a?.runName);
-    delete a.runId;
-    let c = t, r;
-    try {
-      const o = [this.first, ...this.middle];
-      for (let l = 0; l < o.length; l += 1) {
-        const u = o[l].invoke(c, b(a, { callbacks: i?.getChild(this.omitSequenceTags ? void 0 : `seq:step:${l + 1}`) }));
-        c = await I(u, e?.signal);
-      }
-      if (e?.signal?.aborted) throw ot(e.signal);
-      r = await this.last.invoke(c, b(a, { callbacks: i?.getChild(this.omitSequenceTags ? void 0 : `seq:step:${this.steps.length}`) }));
-    } catch (o) {
-      throw await i?.handleChainError(o), o;
-    }
-    return await i?.handleChainEnd(p(r, "output")), r;
-  }
-  async batch(t, e, a) {
-    const s = this._getOptionsList(e ?? {}, t.length), i = await Promise.all(s.map(C)), c = await Promise.all(i.map(async (o, l) => {
-      const h = await o?.handleChainStart(this.toJSON(), p(t[l], "input"), s[l].runId, void 0, void 0, void 0, s[l].runName);
-      return delete s[l].runId, h;
-    }));
-    let r = t;
-    try {
-      for (let o = 0; o < this.steps.length; o += 1) {
-        const h = this.steps[o].batch(r, c.map((u, d) => {
-          const m = u?.getChild(this.omitSequenceTags ? void 0 : `seq:step:${o + 1}`);
-          return b(s[d], { callbacks: m });
-        }), a);
-        r = await I(h, s[0]?.signal);
-      }
-    } catch (o) {
-      throw await Promise.all(c.map((l) => l?.handleChainError(o))), o;
-    }
-    return await Promise.all(c.map((o) => o?.handleChainEnd(p(r, "output")))), r;
-  }
-  /** @internal */
-  _concatOutputChunks(t, e) {
-    return this.last._concatOutputChunks(t, e);
-  }
-  async *_streamIterator(t, e) {
-    const a = await C(e), { runId: s, ...i } = e ?? {}, c = await a?.handleChainStart(this.toJSON(), p(t, "input"), s, void 0, void 0, void 0, i?.runName), r = [
-      this.first,
-      ...this.middle,
-      this.last
-    ];
-    let o = !0, l;
-    async function* h() {
-      yield t;
-    }
-    try {
-      let u = r[0].transform(h(), b(i, { callbacks: c?.getChild(this.omitSequenceTags ? void 0 : "seq:step:1") }));
-      for (let d = 1; d < r.length; d += 1)
-        u = await r[d].transform(u, b(i, { callbacks: c?.getChild(this.omitSequenceTags ? void 0 : `seq:step:${d + 1}`) }));
-      for await (const d of u)
-        if (e?.signal?.throwIfAborted(), yield d, o) if (l === void 0) l = d;
-        else try {
-          l = this._concatOutputChunks(l, d);
-        } catch {
-          l = void 0, o = !1;
-        }
-    } catch (u) {
-      throw await c?.handleChainError(u), u;
-    }
-    await c?.handleChainEnd(p(l, "output"));
-  }
-  getGraph(t) {
-    const e = new U();
-    let a = null;
-    return this.steps.forEach((s, i) => {
-      const c = s.getGraph(t);
-      i !== 0 && c.trimFirstNode(), i !== this.steps.length - 1 && c.trimLastNode(), e.extend(c);
-      const r = c.firstNode();
-      if (!r) throw new Error(`Runnable ${s} has no first node`);
-      a && e.addEdge(a, r), a = c.lastNode();
-    }), e;
-  }
-  pipe(t) {
-    return N.isRunnableSequence(t) ? new N({
-      first: this.first,
-      middle: this.middle.concat([
-        this.last,
-        t.first,
-        ...t.middle
-      ]),
-      last: t.last,
-      name: this.name ?? t.name
-    }) : new N({
-      first: this.first,
-      middle: [...this.middle, this.last],
-      last: S(t),
-      name: this.name
-    });
-  }
-  static isRunnableSequence(t) {
-    return Array.isArray(t.middle) && y.isRunnable(t);
-  }
-  static from([t, ...e], a) {
-    let s = {};
-    return typeof a == "string" ? s.name = a : a !== void 0 && (s = a), new N({
-      ...s,
-      first: S(t),
-      middle: e.slice(0, -1).map(S),
-      last: S(e[e.length - 1])
-    });
-  }
-}, L = class tt extends y {
-  static lc_name() {
-    return "RunnableMap";
-  }
-  lc_namespace = ["langchain_core", "runnables"];
-  lc_serializable = !0;
-  steps;
-  getStepsKeys() {
-    return Object.keys(this.steps);
-  }
-  constructor(t) {
-    super(t), this.steps = {};
-    for (const [e, a] of Object.entries(t.steps)) this.steps[e] = S(a);
-  }
-  static from(t) {
-    return new tt({ steps: t });
-  }
-  async invoke(t, e) {
-    const a = f(e), i = await (await C(a))?.handleChainStart(this.toJSON(), { input: t }, a.runId, void 0, void 0, void 0, a?.runName);
-    delete a.runId;
-    const c = {};
-    try {
-      const r = Object.entries(this.steps).map(async ([o, l]) => {
-        c[o] = await l.invoke(t, b(a, { callbacks: i?.getChild(`map:key:${o}`) }));
-      });
-      await I(Promise.all(r), e?.signal);
-    } catch (r) {
-      throw await i?.handleChainError(r), r;
-    }
-    return await i?.handleChainEnd(c), c;
-  }
-  async *_transform(t, e, a) {
-    const s = { ...this.steps }, i = K(t, Object.keys(s).length), c = new Map(Object.entries(s).map(([r, o], l) => {
-      const h = o.transform(i[l], b(a, { callbacks: e?.getChild(`map:key:${r}`) }));
-      return [r, h.next().then((u) => ({
-        key: r,
-        gen: h,
-        result: u
-      }))];
-    }));
-    for (; c.size; ) {
-      const r = Promise.race(c.values()), { key: o, result: l, gen: h } = await I(r, a?.signal);
-      c.delete(o), l.done || (yield { [o]: l.value }, c.set(o, h.next().then((u) => ({
-        key: o,
-        gen: h,
-        result: u
-      }))));
-    }
-  }
-  transform(t, e) {
-    return this._transformStreamWithConfig(t, this._transform.bind(this), e);
-  }
-  async stream(t, e) {
-    async function* a() {
-      yield t;
-    }
-    const s = f(e), i = new x({
-      generator: this.transform(a(), s),
-      config: s
-    });
-    return await i.setup, A.fromAsyncGenerator(i);
-  }
-}, It = class et extends y {
-  lc_serializable = !1;
-  lc_namespace = ["langchain_core", "runnables"];
-  func;
-  constructor(t) {
-    if (super(t), !$(t.func)) throw new Error("RunnableTraceable requires a function that is wrapped in traceable higher-order function");
-    this.func = t.func;
-  }
-  async invoke(t, e) {
-    const [a] = this._getOptionsList(e ?? {}, 1), s = await C(a), i = this.func(b(a, { callbacks: s }), t);
-    return I(i, a?.signal);
-  }
-  async *_streamIterator(t, e) {
-    const [a] = this._getOptionsList(e ?? {}, 1), s = await this.invoke(t, e);
-    if (P(s)) {
-      for await (const i of s)
-        a?.signal?.throwIfAborted(), yield i;
-      return;
-    }
-    if (_t(s)) {
-      for (; ; ) {
-        a?.signal?.throwIfAborted();
-        const i = s.next();
-        if (i.done) break;
-        yield i.value;
-      }
-      return;
-    }
-    yield s;
-  }
-  static from(t) {
-    return new et({ func: t });
-  }
-};
-function At(n) {
-  if ($(n)) throw new Error("RunnableLambda requires a function that is not wrapped in traceable higher-order function. This shouldn't happen.");
-}
-var nt = class at extends y {
-  static lc_name() {
-    return "RunnableLambda";
-  }
-  lc_namespace = ["langchain_core", "runnables"];
-  func;
-  constructor(t) {
-    if ($(t.func)) return It.from(t.func);
-    super(t), At(t.func), this.func = t.func;
-  }
-  static from(t) {
-    return new at({ func: t });
-  }
-  async _invoke(t, e, a) {
-    return new Promise((s, i) => {
-      const c = b(e, {
-        callbacks: a?.getChild(),
-        recursionLimit: (e?.recursionLimit ?? T) - 1
-      });
-      M.runWithConfig(W(c), async () => {
-        try {
-          let r = await this.func(t, { ...c });
-          if (r && y.isRunnable(r)) {
-            if (e?.recursionLimit === 0) throw new Error("Recursion limit reached.");
-            r = await r.invoke(t, {
-              ...c,
-              recursionLimit: (c.recursionLimit ?? T) - 1
-            });
-          } else if (P(r)) {
-            let o;
-            for await (const l of F(c, r))
-              if (e?.signal?.throwIfAborted(), o === void 0) o = l;
-              else try {
-                o = this._concatOutputChunks(o, l);
-              } catch {
-                o = l;
-              }
-            r = o;
-          } else if (J(r)) {
-            let o;
-            for (const l of H(c, r))
-              if (e?.signal?.throwIfAborted(), o === void 0) o = l;
-              else try {
-                o = this._concatOutputChunks(o, l);
-              } catch {
-                o = l;
-              }
-            r = o;
-          }
-          s(r);
-        } catch (r) {
-          i(r);
-        }
-      });
-    });
-  }
-  async invoke(t, e) {
-    return this._callWithConfig(this._invoke.bind(this), t, e);
-  }
-  async *_transform(t, e, a) {
-    let s;
-    for await (const r of t) if (s === void 0) s = r;
-    else try {
-      s = this._concatOutputChunks(s, r);
-    } catch {
-      s = r;
-    }
-    const i = b(a, {
-      callbacks: e?.getChild(),
-      recursionLimit: (a?.recursionLimit ?? T) - 1
-    }), c = await new Promise((r, o) => {
-      M.runWithConfig(W(i), async () => {
-        try {
-          const l = await this.func(s, {
-            ...i,
-            config: i
-          });
-          r(l);
-        } catch (l) {
-          o(l);
-        }
-      });
-    });
-    if (c && y.isRunnable(c)) {
-      if (a?.recursionLimit === 0) throw new Error("Recursion limit reached.");
-      const r = await c.stream(s, i);
-      for await (const o of r) yield o;
-    } else if (P(c)) for await (const r of F(i, c))
-      a?.signal?.throwIfAborted(), yield r;
-    else if (J(c)) for (const r of H(i, c))
-      a?.signal?.throwIfAborted(), yield r;
-    else yield c;
-  }
-  transform(t, e) {
-    return this._transformStreamWithConfig(t, this._transform.bind(this), e);
-  }
-  async stream(t, e) {
-    async function* a() {
-      yield t;
-    }
-    const s = f(e), i = new x({
-      generator: this.transform(a(), s),
-      config: s
-    });
-    return await i.setup, A.fromAsyncGenerator(i);
-  }
-}, Yt = class extends L {
-}, Rt = class extends y {
-  static lc_name() {
-    return "RunnableWithFallbacks";
-  }
-  lc_namespace = ["langchain_core", "runnables"];
-  lc_serializable = !0;
-  runnable;
-  fallbacks;
-  constructor(n) {
-    super(n), this.runnable = n.runnable, this.fallbacks = n.fallbacks;
-  }
-  *runnables() {
-    yield this.runnable;
-    for (const n of this.fallbacks) yield n;
-  }
-  async invoke(n, t) {
-    const e = f(t), a = await C(e), { runId: s, ...i } = e, c = await a?.handleChainStart(this.toJSON(), p(n, "input"), s, void 0, void 0, void 0, i?.runName), r = b(i, { callbacks: c?.getChild() });
-    return await M.runWithConfig(r, async () => {
-      let l;
-      for (const h of this.runnables()) {
-        e?.signal?.throwIfAborted();
-        try {
-          const u = await h.invoke(n, r);
-          return await c?.handleChainEnd(p(u, "output")), u;
-        } catch (u) {
-          l === void 0 && (l = u);
-        }
-      }
-      throw l === void 0 ? new Error("No error stored at end of fallback.") : (await c?.handleChainError(l), l);
-    });
-  }
-  async *_streamIterator(n, t) {
-    const e = f(t), a = await C(e), { runId: s, ...i } = e, c = await a?.handleChainStart(this.toJSON(), p(n, "input"), s, void 0, void 0, void 0, i?.runName);
-    let r, o;
-    for (const h of this.runnables()) {
-      e?.signal?.throwIfAborted();
-      const u = b(i, { callbacks: c?.getChild() });
-      try {
-        const d = await h.stream(n, u);
-        o = F(u, d);
-        break;
-      } catch (d) {
-        r === void 0 && (r = d);
-      }
-    }
-    if (o === void 0) {
-      const h = r ?? /* @__PURE__ */ new Error("No error stored at end of fallback.");
-      throw await c?.handleChainError(h), h;
-    }
-    let l;
-    try {
-      for await (const h of o) {
-        yield h;
-        try {
-          l = l === void 0 ? l : this._concatOutputChunks(l, h);
-        } catch {
-          l = void 0;
-        }
-      }
-    } catch (h) {
-      throw await c?.handleChainError(h), h;
-    }
-    await c?.handleChainEnd(p(l, "output"));
-  }
-  async batch(n, t, e) {
-    if (e?.returnExceptions) throw new Error("Not implemented.");
-    const a = this._getOptionsList(t ?? {}, n.length), s = await Promise.all(a.map((r) => C(r))), i = await Promise.all(s.map(async (r, o) => {
-      const l = await r?.handleChainStart(this.toJSON(), p(n[o], "input"), a[o].runId, void 0, void 0, void 0, a[o].runName);
-      return delete a[o].runId, l;
-    }));
-    let c;
-    for (const r of this.runnables()) {
-      a[0].signal?.throwIfAborted();
-      try {
-        const o = await r.batch(n, i.map((l, h) => b(a[h], { callbacks: l?.getChild() })), e);
-        return await Promise.all(i.map((l, h) => l?.handleChainEnd(p(o[h], "output")))), o;
-      } catch (o) {
-        c === void 0 && (c = o);
-      }
-    }
-    throw c ? (await Promise.all(i.map((r) => r?.handleChainError(c))), c) : new Error("No error stored at end of fallbacks.");
-  }
-};
-function S(n) {
-  if (typeof n == "function") return new nt({ func: n });
-  if (y.isRunnable(n)) return n;
-  if (!Array.isArray(n) && typeof n == "object") {
-    const t = {};
-    for (const [e, a] of Object.entries(n)) t[e] = S(a);
-    return new L({ steps: t });
-  } else throw new Error(`Expected a Runnable, function or object.
-Instead got an unsupported type.`);
-}
-var Nt = class extends y {
-  static lc_name() {
-    return "RunnableAssign";
-  }
-  lc_namespace = ["langchain_core", "runnables"];
-  lc_serializable = !0;
-  mapper;
-  constructor(n) {
-    n instanceof L && (n = { mapper: n }), super(n), this.mapper = n.mapper;
-  }
-  async invoke(n, t) {
-    const e = await this.mapper.invoke(n, t);
-    return {
-      ...n,
-      ...e
-    };
-  }
-  async *_transform(n, t, e) {
-    const a = this.mapper.getStepsKeys(), [s, i] = K(n), c = this.mapper.transform(i, b(e, { callbacks: t?.getChild() })), r = c.next();
-    for await (const o of s) {
-      if (typeof o != "object" || Array.isArray(o)) throw new Error(`RunnableAssign can only be used with objects as input, got ${typeof o}`);
-      const l = Object.fromEntries(Object.entries(o).filter(([h]) => !a.includes(h)));
-      Object.keys(l).length > 0 && (yield l);
-    }
-    yield (await r).value;
-    for await (const o of c) yield o;
-  }
-  transform(n, t) {
-    return this._transformStreamWithConfig(n, this._transform.bind(this), t);
-  }
-  async stream(n, t) {
-    async function* e() {
-      yield n;
-    }
-    const a = f(t), s = new x({
-      generator: this.transform(e(), a),
-      config: a
-    });
-    return await s.setup, A.fromAsyncGenerator(s);
-  }
-}, xt = class extends y {
-  static lc_name() {
-    return "RunnablePick";
-  }
-  lc_namespace = ["langchain_core", "runnables"];
-  lc_serializable = !0;
-  keys;
-  constructor(n) {
-    (typeof n == "string" || Array.isArray(n)) && (n = { keys: n }), super(n), this.keys = n.keys;
-  }
-  async _pick(n) {
-    if (typeof this.keys == "string") return n[this.keys];
-    {
-      const t = this.keys.map((e) => [e, n[e]]).filter((e) => e[1] !== void 0);
-      return t.length === 0 ? void 0 : Object.fromEntries(t);
-    }
-  }
-  async invoke(n, t) {
-    return this._callWithConfig(this._pick.bind(this), n, t);
-  }
-  async *_transform(n) {
-    for await (const t of n) {
-      const e = await this._pick(t);
-      e !== void 0 && (yield e);
-    }
-  }
-  transform(n, t) {
-    return this._transformStreamWithConfig(n, this._transform.bind(this), t);
-  }
-  async stream(n, t) {
-    async function* e() {
-      yield n;
-    }
-    const a = f(t), s = new x({
-      generator: this.transform(e(), a),
-      config: a
-    });
-    return await s.setup, A.fromAsyncGenerator(s);
-  }
-}, D = class extends O {
-  name;
-  description;
-  schema;
-  constructor(n) {
-    const t = Y.from([nt.from(async (e) => {
-      let a;
-      if (st(e)) try {
-        a = await vt(this.schema, e.args);
-      } catch {
-        throw new it("Received tool input did not match expected schema", JSON.stringify(e.args));
-      }
-      else a = e;
-      return a;
-    }).withConfig({ runName: `${n.name}:parse_input` }), n.bound]).withConfig({ runName: n.name });
-    super({
-      bound: t,
-      config: n.config ?? {}
-    }), this.name = n.name, this.description = n.description, this.schema = n.schema;
-  }
-  static lc_name() {
-    return "RunnableToolLike";
-  }
-};
-function Ot(n, t) {
-  const e = t.name ?? n.getName(), a = t.description ?? wt(t.schema);
-  return yt(t.schema) ? new D({
-    name: e,
-    description: a,
-    schema: Et({ input: St() }).transform((s) => s.input),
-    bound: n
-  }) : new D({
-    name: e,
-    description: a,
-    schema: t.schema,
-    bound: n
-  });
-}
-export {
-  y as Runnable,
-  Nt as RunnableAssign,
-  O as RunnableBinding,
-  Xt as RunnableEach,
-  nt as RunnableLambda,
-  L as RunnableMap,
-  Yt as RunnableParallel,
-  xt as RunnablePick,
-  X as RunnableRetry,
-  Y as RunnableSequence,
-  D as RunnableToolLike,
-  Rt as RunnableWithFallbacks,
-  p as _coerceToDict,
-  S as _coerceToRunnable
-};
-//# sourceMappingURL=base.es.js.map