freestyle-sandboxes 0.0.34 → 0.0.36

package/dist/langgraph/index.d.cts

@@ -1,5 +1,2159 @@
 import { F as FreestyleExecuteScriptParamsConfiguration } from '../types.gen-BuhQ5LpB.js';
-import { DynamicStructuredTool } from '@langchain/core/tools';
+import { z } from 'zod';
+
+type AgentAction = {
+    tool: string;
+    toolInput: string | Record<string, any>;
+    log: string;
+};
+type AgentFinish = {
+    returnValues: Record<string, any>;
+    log: string;
+};
+
+type ChainValues = Record<string, any>;
+
+interface SerializedFields {
+    [key: string]: any;
+}
+
+interface BaseSerialized<T extends string> {
+    lc: number;
+    type: T;
+    id: string[];
+    name?: string;
+    graph?: Record<string, any>;
+}
+interface SerializedConstructor extends BaseSerialized<"constructor"> {
+    kwargs: SerializedFields;
+}
+interface SerializedSecret extends BaseSerialized<"secret"> {
+}
+interface SerializedNotImplemented extends BaseSerialized<"not_implemented"> {
+}
+type Serialized = SerializedConstructor | SerializedSecret | SerializedNotImplemented;
+interface SerializableInterface {
+    get lc_id(): string[];
+}
+declare abstract class Serializable implements SerializableInterface {
+    lc_serializable: boolean;
+    lc_kwargs: SerializedFields;
+    /**
+     * A path to the module that contains the class, eg. ["langchain", "llms"]
+     * Usually should be the same as the entrypoint the class is exported from.
+     */
+    abstract lc_namespace: string[];
+    /**
+     * The name of the serializable. Override to provide an alias or
+     * to preserve the serialized module name in minified environments.
+     *
+     * Implemented as a static method to support loading logic.
+     */
+    static lc_name(): string;
+    /**
+     * The final serialized identifier for the module.
+     */
+    get lc_id(): string[];
+    /**
+     * A map of secrets, which will be omitted from serialization.
+     * Keys are paths to the secret in constructor args, e.g. "foo.bar.baz".
+     * Values are the secret ids, which will be used when deserializing.
+     */
+    get lc_secrets(): {
+        [key: string]: string;
+    } | undefined;
+    /**
+     * A map of additional attributes to merge with constructor args.
+     * Keys are the attribute names, e.g. "foo".
+     * Values are the attribute values, which will be serialized.
+     * These attributes need to be accepted by the constructor as arguments.
+     */
+    get lc_attributes(): SerializedFields | undefined;
+    /**
+     * A map of aliases for constructor args.
+     * Keys are the attribute names, e.g. "foo".
+     * Values are the alias that will replace the key in serialization.
+     * This is used to eg. make argument names match Python.
+     */
+    get lc_aliases(): {
+        [key: string]: string;
+    } | undefined;
+    /**
+     * A manual list of keys that should be serialized.
+     * If not overridden, all fields passed into the constructor will be serialized.
+     */
+    get lc_serializable_keys(): string[] | undefined;
+    constructor(kwargs?: SerializedFields, ..._args: never[]);
+    toJSON(): Serialized;
+    toJSONNotImplemented(): SerializedNotImplemented;
+}
+
+interface StoredMessageData {
+    content: string;
+    role: string | undefined;
+    name: string | undefined;
+    tool_call_id: string | undefined;
+    additional_kwargs?: Record<string, any>;
+    /** Response metadata. For example: response headers, logprobs, token counts. */
+    response_metadata?: Record<string, any>;
+    id?: string;
+}
+interface StoredMessage {
+    type: string;
+    data: StoredMessageData;
+}
+type MessageType = "human" | "ai" | "generic" | "developer" | "system" | "function" | "tool" | "remove";
+type ImageDetail = "auto" | "low" | "high";
+type MessageContentText = {
+    type: "text";
+    text: string;
+};
+type MessageContentImageUrl = {
+    type: "image_url";
+    image_url: string | {
+        url: string;
+        detail?: ImageDetail;
+    };
+};
+type MessageContentComplex = MessageContentText | MessageContentImageUrl | (Record<string, any> & {
+    type?: "text" | "image_url" | string;
+}) | (Record<string, any> & {
+    type?: never;
+});
+type MessageContent = string | MessageContentComplex[];
+interface FunctionCall {
+    /**
+     * The arguments to call the function with, as generated by the model in JSON
+     * format. Note that the model does not always generate valid JSON, and may
+     * hallucinate parameters not defined by your function schema. Validate the
+     * arguments in your code before calling your function.
+     */
+    arguments: string;
+    /**
+     * The name of the function to call.
+     */
+    name: string;
+}
+type BaseMessageFields = {
+    content: MessageContent;
+    name?: string;
+    additional_kwargs?: {
+        /**
+         * @deprecated Use "tool_calls" field on AIMessages instead
+         */
+        function_call?: FunctionCall;
+        /**
+         * @deprecated Use "tool_calls" field on AIMessages instead
+         */
+        tool_calls?: OpenAIToolCall[];
+        [key: string]: unknown;
+    };
+    /** Response metadata. For example: response headers, logprobs, token counts. */
+    response_metadata?: Record<string, any>;
+    /**
+     * An optional unique identifier for the message. This should ideally be
+     * provided by the provider/model which created the message.
+     */
+    id?: string;
+};
+/**
+ * Base class for all types of messages in a conversation. It includes
+ * properties like `content`, `name`, and `additional_kwargs`. It also
+ * includes methods like `toDict()` and `_getType()`.
+ */
+declare abstract class BaseMessage extends Serializable implements BaseMessageFields {
+    lc_namespace: string[];
+    lc_serializable: boolean;
+    get lc_aliases(): Record<string, string>;
+    /**
+     * @deprecated
+     * Use {@link BaseMessage.content} instead.
+     */
+    get text(): string;
+    /** The content of the message. */
+    content: MessageContent;
+    /** The name of the message sender in a multi-user chat. */
+    name?: string;
+    /** Additional keyword arguments */
+    additional_kwargs: NonNullable<BaseMessageFields["additional_kwargs"]>;
+    /** Response metadata. For example: response headers, logprobs, token counts. */
+    response_metadata: NonNullable<BaseMessageFields["response_metadata"]>;
+    /**
+     * An optional unique identifier for the message. This should ideally be
+     * provided by the provider/model which created the message.
+     */
+    id?: string;
+    /**
+     * @deprecated Use .getType() instead or import the proper typeguard.
+     * For example:
+     *
+     * ```ts
+     * import { isAIMessage } from "@langchain/core/messages";
+     *
+     * const message = new AIMessage("Hello!");
+     * isAIMessage(message); // true
+     * ```
+     */
+    abstract _getType(): MessageType;
+    /** The type of the message. */
+    getType(): MessageType;
+    constructor(fields: string | BaseMessageFields, 
+    /** @deprecated */
+    kwargs?: Record<string, unknown>);
+    toDict(): StoredMessage;
+    static lc_name(): string;
+    get _printableFields(): Record<string, unknown>;
+    _updateId(value: string | undefined): void;
+    get [Symbol.toStringTag](): any;
+}
+/**
+ * @deprecated Use "tool_calls" field on AIMessages instead
+ */
+type OpenAIToolCall = {
+    /**
+     * The ID of the tool call.
+     */
+    id: string;
+    /**
+     * The function that the model called.
+     */
+    function: FunctionCall;
+    /**
+     * The type of the tool. Currently, only `function` is supported.
+     */
+    type: "function";
+    index?: number;
+};
+/**
+ * Represents a chunk of a message, which can be concatenated with other
+ * message chunks. It includes a method `_merge_kwargs_dict()` for merging
+ * additional keyword arguments from another `BaseMessageChunk` into this
+ * one. It also overrides the `__add__()` method to support concatenation
+ * of `BaseMessageChunk` instances.
+ */
+declare abstract class BaseMessageChunk extends BaseMessage {
+    abstract concat(chunk: BaseMessageChunk): BaseMessageChunk;
+}
+
+declare const RUN_KEY = "__run";
+/**
+ * Output of a single generation.
+ */
+interface Generation {
+    /**
+     * Generated text output
+     */
+    text: string;
+    /**
+     * Raw generation info response from the provider.
+     * May include things like reason for finishing (e.g. in {@link OpenAI})
+     */
+    generationInfo?: Record<string, any>;
+}
+type GenerationChunkFields = {
+    text: string;
+    generationInfo?: Record<string, any>;
+};
+/**
+ * Chunk of a single generation. Used for streaming.
+ */
+declare class GenerationChunk implements Generation {
+    text: string;
+    generationInfo?: Record<string, any>;
+    constructor(fields: GenerationChunkFields);
+    concat(chunk: GenerationChunk): GenerationChunk;
+}
+/**
+ * Contains all relevant information returned by an LLM.
+ */
+type LLMResult = {
+    /**
+     * List of the things generated. Each input could have multiple {@link Generation | generations}, hence this is a list of lists.
+     */
+    generations: Generation[][];
+    /**
+     * Dictionary of arbitrary LLM-provider specific output.
+     */
+    llmOutput?: Record<string, any>;
+    /**
+     * Dictionary of run metadata
+     */
+    [RUN_KEY]?: Record<string, any>;
+};
+interface ChatGeneration extends Generation {
+    message: BaseMessage;
+}
+type ChatGenerationChunkFields = GenerationChunkFields & {
+    message: BaseMessageChunk;
+};
+declare class ChatGenerationChunk extends GenerationChunk implements ChatGeneration {
+    message: BaseMessageChunk;
+    constructor(fields: ChatGenerationChunkFields);
+    concat(chunk: ChatGenerationChunk): ChatGenerationChunk;
+}
+
+interface DocumentInput<Metadata extends Record<string, any> = Record<string, any>> {
+    pageContent: string;
+    metadata?: Metadata;
+    /**
+     * An optional identifier for the document.
+     *
+     * Ideally this should be unique across the document collection and formatted
+     * as a UUID, but this will not be enforced.
+     */
+    id?: string;
+}
+interface DocumentInterface<Metadata extends Record<string, any> = Record<string, any>> {
+    pageContent: string;
+    metadata: Metadata;
+    /**
+     * An optional identifier for the document.
+     *
+     * Ideally this should be unique across the document collection and formatted
+     * as a UUID, but this will not be enforced.
+     */
+    id?: string;
+}
+/**
+ * Interface for interacting with a document.
+ */
+declare class Document<Metadata extends Record<string, any> = Record<string, any>> implements DocumentInput, DocumentInterface {
+    pageContent: string;
+    metadata: Metadata;
+    /**
+     * An optional identifier for the document.
+     *
+     * Ideally this should be unique across the document collection and formatted
+     * as a UUID, but this will not be enforced.
+     */
+    id?: string;
+    constructor(fields: DocumentInput<Metadata>);
+}
+
+type Error$1 = any;
+/**
+ * Interface for the input parameters of the BaseCallbackHandler class. It
+ * allows to specify which types of events should be ignored by the
+ * callback handler.
+ */
+interface BaseCallbackHandlerInput {
+    ignoreLLM?: boolean;
+    ignoreChain?: boolean;
+    ignoreAgent?: boolean;
+    ignoreRetriever?: boolean;
+    ignoreCustomEvent?: boolean;
+    _awaitHandler?: boolean;
+    raiseError?: boolean;
+}
+/**
+ * Interface for the indices of a new token produced by an LLM or Chat
+ * Model in streaming mode.
+ */
+interface NewTokenIndices {
+    prompt: number;
+    completion: number;
+}
+type HandleLLMNewTokenCallbackFields = {
+    chunk?: GenerationChunk | ChatGenerationChunk;
+};
+/**
+ * Abstract class that provides a set of optional methods that can be
+ * overridden in derived classes to handle various events during the
+ * execution of a LangChain application.
+ */
+declare abstract class BaseCallbackHandlerMethodsClass {
+    /**
+     * Called at the start of an LLM or Chat Model run, with the prompt(s)
+     * and the run ID.
+     */
+    handleLLMStart?(llm: Serialized, prompts: string[], runId: string, parentRunId?: string, extraParams?: Record<string, unknown>, tags?: string[], metadata?: Record<string, unknown>, runName?: string): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Promise<any> | any;
+    /**
+     * Called when an LLM/ChatModel in `streaming` mode produces a new token
+     */
+    handleLLMNewToken?(token: string, 
+    /**
+     * idx.prompt is the index of the prompt that produced the token
+     *   (if there are multiple prompts)
+     * idx.completion is the index of the completion that produced the token
+     *   (if multiple completions per prompt are requested)
+     */
+    idx: NewTokenIndices, runId: string, parentRunId?: string, tags?: string[], fields?: HandleLLMNewTokenCallbackFields): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Promise<any> | any;
+    /**
+     * Called if an LLM/ChatModel run encounters an error
+     */
+    handleLLMError?(err: Error$1, runId: string, parentRunId?: string, tags?: string[], extraParams?: Record<string, unknown>): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Promise<any> | any;
+    /**
+     * Called at the end of an LLM/ChatModel run, with the output and the run ID.
+     */
+    handleLLMEnd?(output: LLMResult, runId: string, parentRunId?: string, tags?: string[], extraParams?: Record<string, unknown>): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Promise<any> | any;
+    /**
+     * Called at the start of a Chat Model run, with the prompt(s)
+     * and the run ID.
+     */
+    handleChatModelStart?(llm: Serialized, messages: BaseMessage[][], runId: string, parentRunId?: string, extraParams?: Record<string, unknown>, tags?: string[], metadata?: Record<string, unknown>, runName?: string): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Promise<any> | any;
+    /**
+     * Called at the start of a Chain run, with the chain name and inputs
+     * and the run ID.
+     */
+    handleChainStart?(chain: Serialized, inputs: ChainValues, runId: string, parentRunId?: string, tags?: string[], metadata?: Record<string, unknown>, runType?: string, runName?: string): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Promise<any> | any;
+    /**
+     * Called if a Chain run encounters an error
+     */
+    handleChainError?(err: Error$1, runId: string, parentRunId?: string, tags?: string[], kwargs?: {
+        inputs?: Record<string, unknown>;
+    }): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Promise<any> | any;
+    /**
+     * Called at the end of a Chain run, with the outputs and the run ID.
+     */
+    handleChainEnd?(outputs: ChainValues, runId: string, parentRunId?: string, tags?: string[], kwargs?: {
+        inputs?: Record<string, unknown>;
+    }): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Promise<any> | any;
+    /**
+     * Called at the start of a Tool run, with the tool name and input
+     * and the run ID.
+     */
+    handleToolStart?(tool: Serialized, input: string, runId: string, parentRunId?: string, tags?: string[], metadata?: Record<string, unknown>, runName?: string): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Promise<any> | any;
+    /**
+     * Called if a Tool run encounters an error
+     */
+    handleToolError?(err: Error$1, runId: string, parentRunId?: string, tags?: string[]): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Promise<any> | any;
+    /**
+     * Called at the end of a Tool run, with the tool output and the run ID.
+     */
+    handleToolEnd?(output: any, runId: string, parentRunId?: string, tags?: string[]): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Promise<any> | any;
+    handleText?(text: string, runId: string, parentRunId?: string, tags?: string[]): Promise<void> | void;
+    /**
+     * Called when an agent is about to execute an action,
+     * with the action and the run ID.
+     */
+    handleAgentAction?(action: AgentAction, runId: string, parentRunId?: string, tags?: string[]): Promise<void> | void;
+    /**
+     * Called when an agent finishes execution, before it exits.
+     * with the final output and the run ID.
+     */
+    handleAgentEnd?(action: AgentFinish, runId: string, parentRunId?: string, tags?: string[]): Promise<void> | void;
+    handleRetrieverStart?(retriever: Serialized, query: string, runId: string, parentRunId?: string, tags?: string[], metadata?: Record<string, unknown>, name?: string): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Promise<any> | any;
+    handleRetrieverEnd?(documents: DocumentInterface[], runId: string, parentRunId?: string, tags?: string[]): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Promise<any> | any;
+    handleRetrieverError?(err: Error$1, runId: string, parentRunId?: string, tags?: string[]): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Promise<any> | any;
+    handleCustomEvent?(eventName: string, data: any, runId: string, tags?: string[], metadata?: Record<string, any>): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Promise<any> | any;
+}
+/**
+ * Base interface for callbacks. All methods are optional. If a method is not
+ * implemented, it will be ignored. If a method is implemented, it will be
+ * called at the appropriate time. All methods are called with the run ID of
+ * the LLM/ChatModel/Chain that is running, which is generated by the
+ * CallbackManager.
+ *
+ * @interface
+ */
+type CallbackHandlerMethods = BaseCallbackHandlerMethodsClass;
+/**
+ * Interface for handlers that can indicate a preference for streaming responses.
+ * When implemented, this allows the handler to signal whether it prefers to receive
+ * streaming responses from language models rather than complete responses.
+ */
+interface CallbackHandlerPrefersStreaming {
+    readonly lc_prefer_streaming: boolean;
+}
+/**
+ * Abstract base class for creating callback handlers in the LangChain
+ * framework. It provides a set of optional methods that can be overridden
+ * in derived classes to handle various events during the execution of a
+ * LangChain application.
+ */
+declare abstract class BaseCallbackHandler extends BaseCallbackHandlerMethodsClass implements BaseCallbackHandlerInput, Serializable {
+    lc_serializable: boolean;
+    get lc_namespace(): ["langchain_core", "callbacks", string];
+    get lc_secrets(): {
+        [key: string]: string;
+    } | undefined;
+    get lc_attributes(): {
+        [key: string]: string;
+    } | undefined;
+    get lc_aliases(): {
+        [key: string]: string;
+    } | undefined;
+    get lc_serializable_keys(): string[] | undefined;
+    /**
+     * The name of the serializable. Override to provide an alias or
+     * to preserve the serialized module name in minified environments.
+     *
+     * Implemented as a static method to support loading logic.
+     */
+    static lc_name(): string;
+    /**
+     * The final serialized identifier for the module.
+     */
+    get lc_id(): string[];
+    lc_kwargs: SerializedFields;
+    abstract name: string;
+    ignoreLLM: boolean;
+    ignoreChain: boolean;
+    ignoreAgent: boolean;
+    ignoreRetriever: boolean;
+    ignoreCustomEvent: boolean;
+    raiseError: boolean;
+    awaitHandlers: boolean;
+    constructor(input?: BaseCallbackHandlerInput);
+    copy(): BaseCallbackHandler;
+    toJSON(): Serialized;
+    toJSONNotImplemented(): SerializedNotImplemented;
+    static fromMethods(methods: CallbackHandlerMethods): {
+        name: string;
+        lc_serializable: boolean;
+        readonly lc_namespace: ["langchain_core", "callbacks", string];
+        readonly lc_secrets: {
+            [key: string]: string;
+        } | undefined;
+        readonly lc_attributes: {
+            [key: string]: string;
+        } | undefined;
+        readonly lc_aliases: {
+            [key: string]: string;
+        } | undefined;
+        readonly lc_serializable_keys: string[] | undefined;
+        /**
+         * The final serialized identifier for the module.
+         */
+        readonly lc_id: string[];
+        lc_kwargs: SerializedFields;
+        ignoreLLM: boolean;
+        ignoreChain: boolean;
+        ignoreAgent: boolean;
+        ignoreRetriever: boolean;
+        ignoreCustomEvent: boolean;
+        raiseError: boolean;
+        awaitHandlers: boolean;
+        copy(): BaseCallbackHandler;
+        toJSON(): Serialized;
+        toJSONNotImplemented(): SerializedNotImplemented;
+        /**
+         * Called at the start of an LLM or Chat Model run, with the prompt(s)
+         * and the run ID.
+         */
+        handleLLMStart?(llm: Serialized, prompts: string[], runId: string, parentRunId?: string | undefined, extraParams?: Record<string, unknown> | undefined, tags?: string[] | undefined, metadata?: Record<string, unknown> | undefined, runName?: string | undefined): any;
+        /**
+         * Called when an LLM/ChatModel in `streaming` mode produces a new token
+         */
+        handleLLMNewToken?(token: string, idx: NewTokenIndices, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined, fields?: HandleLLMNewTokenCallbackFields | undefined): any;
+        /**
+         * Called if an LLM/ChatModel run encounters an error
+         */
+        handleLLMError?(err: any, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined, extraParams?: Record<string, unknown> | undefined): any;
+        /**
+         * Called at the end of an LLM/ChatModel run, with the output and the run ID.
+         */
+        handleLLMEnd?(output: LLMResult, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined, extraParams?: Record<string, unknown> | undefined): any;
+        /**
+         * Called at the start of a Chat Model run, with the prompt(s)
+         * and the run ID.
+         */
+        handleChatModelStart?(llm: Serialized, messages: BaseMessage[][], runId: string, parentRunId?: string | undefined, extraParams?: Record<string, unknown> | undefined, tags?: string[] | undefined, metadata?: Record<string, unknown> | undefined, runName?: string | undefined): any;
+        /**
+         * Called at the start of a Chain run, with the chain name and inputs
+         * and the run ID.
+         */
+        handleChainStart?(chain: Serialized, inputs: ChainValues, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined, metadata?: Record<string, unknown> | undefined, runType?: string | undefined, runName?: string | undefined): any;
+        /**
+         * Called if a Chain run encounters an error
+         */
+        handleChainError?(err: any, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined, kwargs?: {
+            inputs?: Record<string, unknown> | undefined;
+        } | undefined): any;
+        /**
+         * Called at the end of a Chain run, with the outputs and the run ID.
+         */
+        handleChainEnd?(outputs: ChainValues, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined, kwargs?: {
+            inputs?: Record<string, unknown> | undefined;
+        } | undefined): any;
+        /**
+         * Called at the start of a Tool run, with the tool name and input
+         * and the run ID.
+         */
+        handleToolStart?(tool: Serialized, input: string, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined, metadata?: Record<string, unknown> | undefined, runName?: string | undefined): any;
+        /**
+         * Called if a Tool run encounters an error
+         */
+        handleToolError?(err: any, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined): any;
+        /**
+         * Called at the end of a Tool run, with the tool output and the run ID.
+         */
+        handleToolEnd?(output: any, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined): any;
+        handleText?(text: string, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined): void | Promise<void>;
+        /**
+         * Called when an agent is about to execute an action,
+         * with the action and the run ID.
+         */
+        handleAgentAction?(action: AgentAction, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined): void | Promise<void>;
+        /**
+         * Called when an agent finishes execution, before it exits.
+         * with the final output and the run ID.
+         */
+        handleAgentEnd?(action: AgentFinish, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined): void | Promise<void>;
+        handleRetrieverStart?(retriever: Serialized, query: string, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined, metadata?: Record<string, unknown> | undefined, name?: string | undefined): any;
+        handleRetrieverEnd?(documents: DocumentInterface<Record<string, any>>[], runId: string, parentRunId?: string | undefined, tags?: string[] | undefined): any;
+        handleRetrieverError?(err: any, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined): any;
+        handleCustomEvent?(eventName: string, data: any, runId: string, tags?: string[] | undefined, metadata?: Record<string, any> | undefined): any;
+    };
+}
+
+type KVMap = Record<string, any>;
+type AttachmentData = Uint8Array | ArrayBuffer;
+type AttachmentDescription = {
+    mimeType: string;
+    data: AttachmentData;
+};
+type Attachments = Record<string, [
+    string,
+    AttachmentData
+] | AttachmentDescription>;
+/**
+ * A run can represent either a trace (root run)
+ * or a child run (~span).
+ */
+interface BaseRun {
+    /** Optionally, a unique identifier for the run. */
+    id?: string;
+    /** A human-readable name for the run. */
+    name: string;
+    /** The epoch time at which the run started, if available. */
+    start_time?: number;
+    /** Specifies the type of run (tool, chain, llm, etc.). */
+    run_type: string;
+    /** The epoch time at which the run ended, if applicable. */
+    end_time?: number;
+    /** Any additional metadata or settings for the run. */
+    extra?: KVMap;
+    /** Error message, captured if the run faces any issues. */
+    error?: string;
+    /** Serialized state of the run for potential future use. */
+    serialized?: object;
+    /** Events like 'start', 'end' linked to the run. */
+    events?: KVMap[];
+    /** Inputs that were used to initiate the run. */
+    inputs: KVMap;
+    /** Outputs produced by the run, if any. */
+    outputs?: KVMap;
+    /** ID of an example that might be related to this run. */
+    reference_example_id?: string;
+    /** ID of a parent run, if this run is part of a larger operation. */
+    parent_run_id?: string;
+    /** Tags for further categorizing or annotating the run. */
+    tags?: string[];
+    /** Unique ID assigned to every run within this nested trace. **/
+    trace_id?: string;
+    /**
+     * The dotted order for the run.
+     *
+     * This is a string composed of {time}{run-uuid}.* so that a trace can be
+     * sorted in the order it was executed.
+     *
+     * Example:
+     * - Parent: 20230914T223155647Z1b64098b-4ab7-43f6-afee-992304f198d8
+     * - Children:
+     *    - 20230914T223155647Z1b64098b-4ab7-43f6-afee-992304f198d8.20230914T223155649Z809ed3a2-0172-4f4d-8a02-a64e9b7a0f8a
+     *   - 20230915T223155647Z1b64098b-4ab7-43f6-afee-992304f198d8.20230914T223155650Zc8d9f4c5-6c5a-4b2d-9b1c-3d9d7a7c5c7c
+     */
+    dotted_order?: string;
+    /**
+     * Attachments associated with the run.
+     * Each entry is a tuple of [mime_type, bytes]
+     */
+    attachments?: Attachments;
+}
+
+interface Run extends BaseRun {
+    id: string;
+    start_time: number;
+    execution_order: number;
+    child_runs: this[];
+    child_execution_order: number;
+    events: Array<{
+        name: string;
+        time: string;
+        kwargs?: Record<string, unknown>;
+    }>;
+    trace_id?: string;
+    dotted_order?: string;
+}
+declare abstract class BaseTracer extends BaseCallbackHandler {
+    protected runMap: Map<string, Run>;
+    constructor(_fields?: BaseCallbackHandlerInput);
+    copy(): this;
+    protected stringifyError(error: unknown): string;
+    protected abstract persistRun(run: Run): Promise<void>;
+    protected _addChildRun(parentRun: Run, childRun: Run): void;
+    _addRunToRunMap(run: Run): {
+        id: string;
+        start_time: number;
+        execution_order: number;
+        child_runs: Run[];
+        child_execution_order: number;
+        events: {
+            name: string;
+            time: string;
+            kwargs?: Record<string, unknown> | undefined;
+        }[];
+        trace_id?: string | undefined;
+        dotted_order?: string | undefined;
+        name: string;
+        run_type: string;
+        end_time?: number | undefined;
+        extra?: KVMap | undefined;
+        error?: string | undefined;
+        serialized?: object | undefined;
+        inputs: KVMap;
+        outputs?: KVMap | undefined;
+        reference_example_id?: string | undefined;
+        parent_run_id?: string | undefined;
+        tags?: string[] | undefined;
+        attachments?: Attachments | undefined;
+    };
+    protected _endTrace(run: Run): Promise<void>;
+    protected _getExecutionOrder(parentRunId: string | undefined): number;
+    /**
+     * Create and add a run to the run map for LLM start events.
+     * This must sometimes be done synchronously to avoid race conditions
+     * when callbacks are backgrounded, so we expose it as a separate method here.
+     */
+    _createRunForLLMStart(llm: Serialized, prompts: string[], runId: string, parentRunId?: string, extraParams?: KVMap, tags?: string[], metadata?: KVMap, name?: string): {
+        id: string;
+        start_time: number;
+        execution_order: number;
+        child_runs: Run[];
+        child_execution_order: number;
+        events: {
+            name: string;
+            time: string;
+            kwargs?: Record<string, unknown> | undefined;
+        }[];
+        trace_id?: string | undefined;
+        dotted_order?: string | undefined;
+        name: string;
+        run_type: string;
+        end_time?: number | undefined;
+        extra?: KVMap | undefined;
+        error?: string | undefined;
+        serialized?: object | undefined;
+        inputs: KVMap;
+        outputs?: KVMap | undefined;
+        reference_example_id?: string | undefined;
+        parent_run_id?: string | undefined;
+        tags?: string[] | undefined;
+        attachments?: Attachments | undefined;
+    };
+    handleLLMStart(llm: Serialized, prompts: string[], runId: string, parentRunId?: string, extraParams?: KVMap, tags?: string[], metadata?: KVMap, name?: string): Promise<Run>;
+    /**
+     * Create and add a run to the run map for chat model start events.
+     * This must sometimes be done synchronously to avoid race conditions
+     * when callbacks are backgrounded, so we expose it as a separate method here.
+     */
+    _createRunForChatModelStart(llm: Serialized, messages: BaseMessage[][], runId: string, parentRunId?: string, extraParams?: KVMap, tags?: string[], metadata?: KVMap, name?: string): {
+        id: string;
+        start_time: number;
+        execution_order: number;
+        child_runs: Run[];
+        child_execution_order: number;
+        events: {
+            name: string;
+            time: string;
+            kwargs?: Record<string, unknown> | undefined;
+        }[];
+        trace_id?: string | undefined;
+        dotted_order?: string | undefined;
+        name: string;
+        run_type: string;
+        end_time?: number | undefined;
+        extra?: KVMap | undefined;
+        error?: string | undefined;
+        serialized?: object | undefined;
+        inputs: KVMap;
+        outputs?: KVMap | undefined;
+        reference_example_id?: string | undefined;
+        parent_run_id?: string | undefined;
+        tags?: string[] | undefined;
+        attachments?: Attachments | undefined;
+    };
+    handleChatModelStart(llm: Serialized, messages: BaseMessage[][], runId: string, parentRunId?: string, extraParams?: KVMap, tags?: string[], metadata?: KVMap, name?: string): Promise<Run>;
+    handleLLMEnd(output: LLMResult, runId: string, _parentRunId?: string, _tags?: string[], extraParams?: Record<string, unknown>): Promise<Run>;
+    handleLLMError(error: unknown, runId: string, _parentRunId?: string, _tags?: string[], extraParams?: Record<string, unknown>): Promise<Run>;
+    /**
+     * Create and add a run to the run map for chain start events.
+     * This must sometimes be done synchronously to avoid race conditions
+     * when callbacks are backgrounded, so we expose it as a separate method here.
+     */
+    _createRunForChainStart(chain: Serialized, inputs: ChainValues, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, runType?: string, name?: string): {
+        id: string;
+        start_time: number;
+        execution_order: number;
+        child_runs: Run[];
+        child_execution_order: number;
+        events: {
+            name: string;
+            time: string;
+            kwargs?: Record<string, unknown> | undefined;
+        }[];
+        trace_id?: string | undefined;
+        dotted_order?: string | undefined;
+        name: string;
+        run_type: string;
+        end_time?: number | undefined;
+        extra?: KVMap | undefined;
+        error?: string | undefined;
+        serialized?: object | undefined;
+        inputs: KVMap;
+        outputs?: KVMap | undefined;
+        reference_example_id?: string | undefined;
+        parent_run_id?: string | undefined;
+        tags?: string[] | undefined;
+        attachments?: Attachments | undefined;
+    };
+    handleChainStart(chain: Serialized, inputs: ChainValues, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, runType?: string, name?: string): Promise<Run>;
+    handleChainEnd(outputs: ChainValues, runId: string, _parentRunId?: string, _tags?: string[], kwargs?: {
+        inputs?: Record<string, unknown>;
+    }): Promise<Run>;
+    handleChainError(error: unknown, runId: string, _parentRunId?: string, _tags?: string[], kwargs?: {
+        inputs?: Record<string, unknown>;
+    }): Promise<Run>;
+    /**
+     * Create and add a run to the run map for tool start events.
+     * This must sometimes be done synchronously to avoid race conditions
+     * when callbacks are backgrounded, so we expose it as a separate method here.
+     */
+    _createRunForToolStart(tool: Serialized, input: string, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, name?: string): {
+        id: string;
+        start_time: number;
+        execution_order: number;
+        child_runs: Run[];
+        child_execution_order: number;
+        events: {
+            name: string;
+            time: string;
+            kwargs?: Record<string, unknown> | undefined;
+        }[];
+        trace_id?: string | undefined;
+        dotted_order?: string | undefined;
+        name: string;
+        run_type: string;
+        end_time?: number | undefined;
+        extra?: KVMap | undefined;
+        error?: string | undefined;
+        serialized?: object | undefined;
+        inputs: KVMap;
+        outputs?: KVMap | undefined;
+        reference_example_id?: string | undefined;
+        parent_run_id?: string | undefined;
+        tags?: string[] | undefined;
+        attachments?: Attachments | undefined;
+    };
+    handleToolStart(tool: Serialized, input: string, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, name?: string): Promise<Run>;
+    handleToolEnd(output: any, runId: string): Promise<Run>;
+    handleToolError(error: unknown, runId: string): Promise<Run>;
+    handleAgentAction(action: AgentAction, runId: string): Promise<void>;
+    handleAgentEnd(action: AgentFinish, runId: string): Promise<void>;
+    /**
+     * Create and add a run to the run map for retriever start events.
+     * This must sometimes be done synchronously to avoid race conditions
+     * when callbacks are backgrounded, so we expose it as a separate method here.
+     */
+    _createRunForRetrieverStart(retriever: Serialized, query: string, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, name?: string): {
+        id: string;
+        start_time: number;
+        execution_order: number;
+        child_runs: Run[];
+        child_execution_order: number;
+        events: {
+            name: string;
+            time: string;
+            kwargs?: Record<string, unknown> | undefined;
+        }[];
+        trace_id?: string | undefined;
+        dotted_order?: string | undefined;
+        name: string;
+        run_type: string;
+        end_time?: number | undefined;
+        extra?: KVMap | undefined;
+        error?: string | undefined;
+        serialized?: object | undefined;
+        inputs: KVMap;
+        outputs?: KVMap | undefined;
+        reference_example_id?: string | undefined;
+        parent_run_id?: string | undefined;
+        tags?: string[] | undefined;
+        attachments?: Attachments | undefined;
+    };
+    handleRetrieverStart(retriever: Serialized, query: string, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, name?: string): Promise<Run>;
+    handleRetrieverEnd(documents: Document<Record<string, unknown>>[], runId: string): Promise<Run>;
+    handleRetrieverError(error: unknown, runId: string): Promise<Run>;
+    handleText(text: string, runId: string): Promise<void>;
+    handleLLMNewToken(token: string, idx: NewTokenIndices, runId: string, _parentRunId?: string, _tags?: string[], fields?: HandleLLMNewTokenCallbackFields): Promise<Run>;
+    onRunCreate?(run: Run): void | Promise<void>;
+    onRunUpdate?(run: Run): void | Promise<void>;
+    onLLMStart?(run: Run): void | Promise<void>;
+    onLLMEnd?(run: Run): void | Promise<void>;
+    onLLMError?(run: Run): void | Promise<void>;
+    onChainStart?(run: Run): void | Promise<void>;
+    onChainEnd?(run: Run): void | Promise<void>;
+    onChainError?(run: Run): void | Promise<void>;
+    onToolStart?(run: Run): void | Promise<void>;
+    onToolEnd?(run: Run): void | Promise<void>;
+    onToolError?(run: Run): void | Promise<void>;
+    onAgentAction?(run: Run): void | Promise<void>;
+    onAgentEnd?(run: Run): void | Promise<void>;
+    onRetrieverStart?(run: Run): void | Promise<void>;
+    onRetrieverEnd?(run: Run): void | Promise<void>;
+    onRetrieverError?(run: Run): void | Promise<void>;
+    onText?(run: Run): void | Promise<void>;
+    onLLMNewToken?(run: Run, token: string, kwargs?: {
+        chunk: any;
+    }): void | Promise<void>;
+}
+
+type BaseCallbackManagerMethods = {
+    [K in keyof CallbackHandlerMethods]?: (...args: Parameters<Required<CallbackHandlerMethods>[K]>) => Promise<unknown>;
+};
+interface CallbackManagerOptions {
+    verbose?: boolean;
+    tracing?: boolean;
+}
+type Callbacks = CallbackManager | (BaseCallbackHandler | CallbackHandlerMethods)[];
+interface BaseCallbackConfig {
+    /**
+     * Name for the tracer run for this call. Defaults to the name of the class.
+     */
+    runName?: string;
+    /**
+     * Tags for this call and any sub-calls (eg. a Chain calling an LLM).
+     * You can use these to filter calls.
+     */
+    tags?: string[];
+    /**
+     * Metadata for this call and any sub-calls (eg. a Chain calling an LLM).
+     * Keys should be strings, values should be JSON-serializable.
+     */
+    metadata?: Record<string, unknown>;
+    /**
+     * Callbacks for this call and any sub-calls (eg. a Chain calling an LLM).
+     * Tags are passed to all callbacks, metadata is passed to handle*Start callbacks.
+     */
+    callbacks?: Callbacks;
+    /**
+     * Unique identifier for the tracer run for this call. If not provided, a new UUID
+     * will be generated.
+     */
+    runId?: string;
+}
+/**
+ * Manage callbacks from different components of LangChain.
+ */
+declare abstract class BaseCallbackManager {
+    abstract addHandler(handler: BaseCallbackHandler): void;
+    abstract removeHandler(handler: BaseCallbackHandler): void;
+    abstract setHandlers(handlers: BaseCallbackHandler[]): void;
+    setHandler(handler: BaseCallbackHandler): void;
+}
+/**
+ * Base class for run manager in LangChain.
+ */
+declare class BaseRunManager {
+    readonly runId: string;
+    readonly handlers: BaseCallbackHandler[];
+    protected readonly inheritableHandlers: BaseCallbackHandler[];
+    protected readonly tags: string[];
+    protected readonly inheritableTags: string[];
+    protected readonly metadata: Record<string, unknown>;
+    protected readonly inheritableMetadata: Record<string, unknown>;
+    protected readonly _parentRunId?: string | undefined;
+    constructor(runId: string, handlers: BaseCallbackHandler[], inheritableHandlers: BaseCallbackHandler[], tags: string[], inheritableTags: string[], metadata: Record<string, unknown>, inheritableMetadata: Record<string, unknown>, _parentRunId?: string | undefined);
+    get parentRunId(): string | undefined;
+    handleText(text: string): Promise<void>;
+    handleCustomEvent(eventName: string, data: any, _runId?: string, _tags?: string[], _metadata?: Record<string, any>): Promise<void>;
+}
+/**
+ * Manages callbacks for retriever runs.
+ */
+declare class CallbackManagerForRetrieverRun extends BaseRunManager implements BaseCallbackManagerMethods {
+    getChild(tag?: string): CallbackManager;
+    handleRetrieverEnd(documents: DocumentInterface[]): Promise<void>;
+    handleRetrieverError(err: Error | unknown): Promise<void>;
+}
+declare class CallbackManagerForLLMRun extends BaseRunManager implements BaseCallbackManagerMethods {
+    handleLLMNewToken(token: string, idx?: NewTokenIndices, _runId?: string, _parentRunId?: string, _tags?: string[], fields?: HandleLLMNewTokenCallbackFields): Promise<void>;
+    handleLLMError(err: Error | unknown, _runId?: string, _parentRunId?: string, _tags?: string[], extraParams?: Record<string, unknown>): Promise<void>;
+    handleLLMEnd(output: LLMResult, _runId?: string, _parentRunId?: string, _tags?: string[], extraParams?: Record<string, unknown>): Promise<void>;
+}
+declare class CallbackManagerForChainRun extends BaseRunManager implements BaseCallbackManagerMethods {
+    getChild(tag?: string): CallbackManager;
+    handleChainError(err: Error | unknown, _runId?: string, _parentRunId?: string, _tags?: string[], kwargs?: {
+        inputs?: Record<string, unknown>;
+    }): Promise<void>;
+    handleChainEnd(output: ChainValues, _runId?: string, _parentRunId?: string, _tags?: string[], kwargs?: {
+        inputs?: Record<string, unknown>;
+    }): Promise<void>;
+    handleAgentAction(action: AgentAction): Promise<void>;
+    handleAgentEnd(action: AgentFinish): Promise<void>;
+}
+declare class CallbackManagerForToolRun extends BaseRunManager implements BaseCallbackManagerMethods {
+    getChild(tag?: string): CallbackManager;
+    handleToolError(err: Error | unknown): Promise<void>;
+    handleToolEnd(output: any): Promise<void>;
+}
+/**
+ * @example
+ * ```typescript
+ * const prompt = PromptTemplate.fromTemplate("What is the answer to {question}?");
+ *
+ * // Example of using LLMChain with OpenAI and a simple prompt
+ * const chain = new LLMChain({
+ *   llm: new ChatOpenAI({ temperature: 0.9 }),
+ *   prompt,
+ * });
+ *
+ * // Running the chain with a single question
+ * const result = await chain.call({
+ *   question: "What is the airspeed velocity of an unladen swallow?",
+ * });
+ * console.log("The answer is:", result);
+ * ```
+ */
+declare class CallbackManager extends BaseCallbackManager implements BaseCallbackManagerMethods {
+    handlers: BaseCallbackHandler[];
+    inheritableHandlers: BaseCallbackHandler[];
+    tags: string[];
+    inheritableTags: string[];
+    metadata: Record<string, unknown>;
+    inheritableMetadata: Record<string, unknown>;
+    name: string;
+    _parentRunId?: string;
+    constructor(parentRunId?: string, options?: {
+        handlers?: BaseCallbackHandler[];
+        inheritableHandlers?: BaseCallbackHandler[];
+        tags?: string[];
+        inheritableTags?: string[];
+        metadata?: Record<string, unknown>;
+        inheritableMetadata?: Record<string, unknown>;
+    });
+    /**
+     * Gets the parent run ID, if any.
+     *
+     * @returns The parent run ID.
+     */
+    getParentRunId(): string | undefined;
+    handleLLMStart(llm: Serialized, prompts: string[], runId?: string | undefined, _parentRunId?: string | undefined, extraParams?: Record<string, unknown> | undefined, _tags?: string[] | undefined, _metadata?: Record<string, unknown> | undefined, runName?: string | undefined): Promise<CallbackManagerForLLMRun[]>;
+    handleChatModelStart(llm: Serialized, messages: BaseMessage[][], runId?: string | undefined, _parentRunId?: string | undefined, extraParams?: Record<string, unknown> | undefined, _tags?: string[] | undefined, _metadata?: Record<string, unknown> | undefined, runName?: string | undefined): Promise<CallbackManagerForLLMRun[]>;
+    handleChainStart(chain: Serialized, inputs: ChainValues, runId?: string, runType?: string | undefined, _tags?: string[] | undefined, _metadata?: Record<string, unknown> | undefined, runName?: string | undefined): Promise<CallbackManagerForChainRun>;
+    handleToolStart(tool: Serialized, input: string, runId?: string, _parentRunId?: string | undefined, _tags?: string[] | undefined, _metadata?: Record<string, unknown> | undefined, runName?: string | undefined): Promise<CallbackManagerForToolRun>;
+    handleRetrieverStart(retriever: Serialized, query: string, runId?: string, _parentRunId?: string | undefined, _tags?: string[] | undefined, _metadata?: Record<string, unknown> | undefined, runName?: string | undefined): Promise<CallbackManagerForRetrieverRun>;
+    handleCustomEvent?(eventName: string, data: any, runId: string, _tags?: string[], _metadata?: Record<string, any>): Promise<any>;
+    addHandler(handler: BaseCallbackHandler, inherit?: boolean): void;
+    removeHandler(handler: BaseCallbackHandler): void;
+    setHandlers(handlers: BaseCallbackHandler[], inherit?: boolean): void;
+    addTags(tags: string[], inherit?: boolean): void;
+    removeTags(tags: string[]): void;
+    addMetadata(metadata: Record<string, unknown>, inherit?: boolean): void;
+    removeMetadata(metadata: Record<string, unknown>): void;
+    copy(additionalHandlers?: BaseCallbackHandler[], inherit?: boolean): CallbackManager;
+    static fromHandlers(handlers: CallbackHandlerMethods): CallbackManager;
+    static configure(inheritableHandlers?: Callbacks, localHandlers?: Callbacks, inheritableTags?: string[], localTags?: string[], inheritableMetadata?: Record<string, unknown>, localMetadata?: Record<string, unknown>, options?: CallbackManagerOptions): CallbackManager | undefined;
+    static _configureSync(inheritableHandlers?: Callbacks, localHandlers?: Callbacks, inheritableTags?: string[], localTags?: string[], inheritableMetadata?: Record<string, unknown>, localMetadata?: Record<string, unknown>, options?: CallbackManagerOptions): CallbackManager | undefined;
+}
+
+/**
+ * A call to a tool.
+ * @property {string} name - The name of the tool to be called
+ * @property {Record<string, any>} args - The arguments to the tool call
+ * @property {string} [id] - If provided, an identifier associated with the tool call
+ */
+type ToolCall = {
+    name: string;
+    args: Record<string, any>;
+    id?: string;
+    type?: "tool_call";
+};
+
+type IterableReadableStreamInterface<T> = ReadableStream<T> & AsyncIterable<T>;
+
+type RunnableBatchOptions = {
+    /** @deprecated Pass in via the standard runnable config object instead */
+    maxConcurrency?: number;
+    returnExceptions?: boolean;
+};
+type RunnableIOSchema = {
+    name?: string;
+    schema: z.ZodType;
+};
+/**
+ * Base interface implemented by all runnables.
+ * Used for cross-compatibility between different versions of LangChain core.
+ *
+ * Should not change on patch releases.
+ */
+interface RunnableInterface<RunInput = any, RunOutput = any, CallOptions extends RunnableConfig = RunnableConfig> extends SerializableInterface {
+    lc_serializable: boolean;
+    invoke(input: RunInput, options?: Partial<CallOptions>): Promise<RunOutput>;
+    batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions & {
+        returnExceptions?: false;
+    }): Promise<RunOutput[]>;
+    batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions & {
+        returnExceptions: true;
+    }): Promise<(RunOutput | Error)[]>;
+    batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions): Promise<(RunOutput | Error)[]>;
+    stream(input: RunInput, options?: Partial<CallOptions>): Promise<IterableReadableStreamInterface<RunOutput>>;
+    transform(generator: AsyncGenerator<RunInput>, options: Partial<CallOptions>): AsyncGenerator<RunOutput>;
+    getName(suffix?: string): string;
+}
+interface Edge {
+    source: string;
+    target: string;
+    data?: string;
+    conditional?: boolean;
+}
+interface Node {
+    id: string;
+    name: string;
+    data: RunnableIOSchema | RunnableInterface;
+    metadata?: Record<string, any>;
+}
+interface RunnableConfig<ConfigurableFieldType extends Record<string, any> = Record<string, any>> extends BaseCallbackConfig {
+    /**
+     * Runtime values for attributes previously made configurable on this Runnable,
+     * or sub-Runnables.
+     */
+    configurable?: ConfigurableFieldType;
+    /**
+     * Maximum number of times a call can recurse. If not provided, defaults to 25.
+     */
+    recursionLimit?: number;
+    /** Maximum number of parallel calls to make. */
+    maxConcurrency?: number;
+    /**
+     * Timeout for this call in milliseconds.
+     */
+    timeout?: number;
+    /**
+     * Abort signal for this call.
+     * If provided, the call will be aborted when the signal is aborted.
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal
+     */
+    signal?: AbortSignal;
+}
+
+type Operation = AddOperation<any> | RemoveOperation | ReplaceOperation<any> | MoveOperation | CopyOperation | TestOperation<any> | GetOperation<any>;
+interface BaseOperation {
+    path: string;
+}
+interface AddOperation<T> extends BaseOperation {
+    op: "add";
+    value: T;
+}
+interface RemoveOperation extends BaseOperation {
+    op: "remove";
+}
+interface ReplaceOperation<T> extends BaseOperation {
+    op: "replace";
+    value: T;
+}
+interface MoveOperation extends BaseOperation {
+    op: "move";
+    from: string;
+}
+interface CopyOperation extends BaseOperation {
+    op: "copy";
+    from: string;
+}
+interface TestOperation<T> extends BaseOperation {
+    op: "test";
+    value: T;
+}
+interface GetOperation<T> extends BaseOperation {
+    op: "_get";
+    value: T;
+}
+
+declare class IterableReadableStream<T> extends ReadableStream<T> implements IterableReadableStreamInterface<T> {
+    reader: ReadableStreamDefaultReader<T>;
+    ensureReader(): void;
+    next(): Promise<IteratorResult<T>>;
+    return(): Promise<IteratorResult<T>>;
+    throw(e: any): Promise<IteratorResult<T>>;
+    [Symbol.asyncIterator](): this;
+    [Symbol.asyncDispose](): Promise<void>;
+    static fromReadableStream<T>(stream: ReadableStream<T>): IterableReadableStream<T>;
+    static fromAsyncGenerator<T>(generator: AsyncGenerator<T>): IterableReadableStream<T>;
+}
+
+/**
+ * Data associated with a StreamEvent.
+ */
+type StreamEventData = {
+    /**
+     * The input passed to the runnable that generated the event.
+     * Inputs will sometimes be available at the *START* of the runnable, and
+     * sometimes at the *END* of the runnable.
+     * If a runnable is able to stream its inputs, then its input by definition
+     * won't be known until the *END* of the runnable when it has finished streaming
+     * its inputs.
+     */
+    input?: any;
+    /**
+     * The output of the runnable that generated the event.
+     * Outputs will only be available at the *END* of the runnable.
+     * For most runnables, this field can be inferred from the `chunk` field,
+     * though there might be some exceptions for special cased runnables (e.g., like
+     * chat models), which may return more information.
+     */
+    output?: any;
+    /**
+     * A streaming chunk from the output that generated the event.
+     * chunks support addition in general, and adding them up should result
+     * in the output of the runnable that generated the event.
+     */
+    chunk?: any;
+};
+/**
+ * A streaming event.
+ *
+ * Schema of a streaming event which is produced from the streamEvents method.
+ */
+type StreamEvent = {
+    /**
+     * Event names are of the format: on_[runnable_type]_(start|stream|end).
+     *
+     * Runnable types are one of:
+     * - llm - used by non chat models
+     * - chat_model - used by chat models
+     * - prompt --  e.g., ChatPromptTemplate
+     * - tool -- LangChain tools
+     * - chain - most Runnables are of this type
+     *
+     * Further, the events are categorized as one of:
+     * - start - when the runnable starts
+     * - stream - when the runnable is streaming
+     * - end - when the runnable ends
+     *
+     * start, stream and end are associated with slightly different `data` payload.
+     *
+     * Please see the documentation for `EventData` for more details.
+     */
+    event: string;
+    /** The name of the runnable that generated the event. */
+    name: string;
+    /**
+     * An randomly generated ID to keep track of the execution of the given runnable.
+     *
+     * Each child runnable that gets invoked as part of the execution of a parent runnable
+     * is assigned its own unique ID.
+     */
+    run_id: string;
+    /**
+     * Tags associated with the runnable that generated this event.
+     * Tags are always inherited from parent runnables.
+     */
+    tags?: string[];
+    /** Metadata associated with the runnable that generated this event. */
+    metadata: Record<string, any>;
+    /**
+     * Event data.
+     *
+     * The contents of the event data depend on the event type.
+     */
+    data: StreamEventData;
+};
+interface EventStreamCallbackHandlerInput extends BaseCallbackHandlerInput {
+    autoClose?: boolean;
+    includeNames?: string[];
+    includeTypes?: string[];
+    includeTags?: string[];
+    excludeNames?: string[];
+    excludeTypes?: string[];
+    excludeTags?: string[];
+}
+
+/**
+ * Interface that represents the structure of a log entry in the
+ * `LogStreamCallbackHandler`.
+ */
+type LogEntry = {
+    /** ID of the sub-run. */
+    id: string;
+    /** Name of the object being run. */
+    name: string;
+    /** Type of the object being run, eg. prompt, chain, llm, etc. */
+    type: string;
+    /** List of tags for the run. */
+    tags: string[];
+    /** Key-value pairs of metadata for the run. */
+    metadata: Record<string, any>;
+    /** ISO-8601 timestamp of when the run started. */
+    start_time: string;
+    /** List of general output chunks streamed by this run. */
+    streamed_output: any[];
+    /** List of LLM tokens streamed by this run, if applicable. */
+    streamed_output_str: string[];
+    /** Inputs to this run. Not available currently via streamLog. */
+    inputs?: any;
+    /** Final output of this run. Only available after the run has finished successfully. */
+    final_output?: any;
+    /** ISO-8601 timestamp of when the run ended. Only available after the run has finished. */
+    end_time?: string;
+};
+type RunState = {
+    /** ID of the sub-run. */
+    id: string;
+    /** List of output chunks streamed by Runnable.stream() */
+    streamed_output: any[];
+    /** Final output of the run, usually the result of aggregating streamed_output. Only available after the run has finished successfully. */
+    final_output?: any;
+    /**
+     * List of sub-runs contained in this run, if any, in the order they were started.
+     * If filters were supplied, this list will contain only the runs that matched the filters.
+     */
+    logs: Record<string, LogEntry>;
+    /** Name of the object being run. */
+    name: string;
+    /** Type of the object being run, eg. prompt, chain, llm, etc. */
+    type: string;
+};
+/**
+ * List of jsonpatch JSONPatchOperations, which describe how to create the run state
+ * from an empty dict. This is the minimal representation of the log, designed to
+ * be serialized as JSON and sent over the wire to reconstruct the log on the other
+ * side. Reconstruction of the state can be done with any jsonpatch-compliant library,
+ * see https://jsonpatch.com for more information.
+ */
+declare class RunLogPatch {
+    ops: Operation[];
+    constructor(fields: {
+        ops?: Operation[];
+    });
+    concat(other: RunLogPatch): RunLog;
+}
+declare class RunLog extends RunLogPatch {
+    state: RunState;
+    constructor(fields: {
+        ops?: Operation[];
+        state: RunState;
+    });
+    concat(other: RunLogPatch): RunLog;
+    static fromRunLogPatch(patch: RunLogPatch): RunLog;
+}
+type SchemaFormat = "original" | "streaming_events";
+interface LogStreamCallbackHandlerInput extends BaseCallbackHandlerInput {
+    autoClose?: boolean;
+    includeNames?: string[];
+    includeTypes?: string[];
+    includeTags?: string[];
+    excludeNames?: string[];
+    excludeTypes?: string[];
+    excludeTags?: string[];
+    _schemaFormat?: SchemaFormat;
+}
+/**
+ * Class that extends the `BaseTracer` class from the
+ * `langchain.callbacks.tracers.base` module. It represents a callback
+ * handler that logs the execution of runs and emits `RunLog` instances to a
+ * `RunLogStream`.
+ */
+declare class LogStreamCallbackHandler extends BaseTracer implements CallbackHandlerPrefersStreaming {
+    protected autoClose: boolean;
+    protected includeNames?: string[];
+    protected includeTypes?: string[];
+    protected includeTags?: string[];
+    protected excludeNames?: string[];
+    protected excludeTypes?: string[];
+    protected excludeTags?: string[];
+    protected _schemaFormat: SchemaFormat;
+    protected rootId?: string;
+    private keyMapByRunId;
+    private counterMapByRunName;
+    protected transformStream: TransformStream;
+    writer: WritableStreamDefaultWriter;
+    receiveStream: IterableReadableStream<RunLogPatch>;
+    name: string;
+    lc_prefer_streaming: boolean;
+    constructor(fields?: LogStreamCallbackHandlerInput);
+    [Symbol.asyncIterator](): IterableReadableStream<RunLogPatch>;
+    protected persistRun(_run: Run): Promise<void>;
+    _includeRun(run: Run): boolean;
+    tapOutputIterable<T>(runId: string, output: AsyncGenerator<T>): AsyncGenerator<T>;
+    onRunCreate(run: Run): Promise<void>;
+    onRunUpdate(run: Run): Promise<void>;
+    onLLMNewToken(run: Run, token: string, kwargs?: HandleLLMNewTokenCallbackFields): Promise<void>;
+}
+
+declare class Graph {
+    nodes: Record<string, Node>;
+    edges: Edge[];
+    constructor(params?: {
+        nodes: Record<string, Node>;
+        edges: Edge[];
+    });
+    toJSON(): Record<string, any>;
+    addNode(data: RunnableInterface | RunnableIOSchema, id?: string, metadata?: Record<string, any>): Node;
+    removeNode(node: Node): void;
+    addEdge(source: Node, target: Node, data?: string, conditional?: boolean): Edge;
+    firstNode(): Node | undefined;
+    lastNode(): Node | undefined;
+    /**
+     * Add all nodes and edges from another graph.
+     * Note this doesn't check for duplicates, nor does it connect the graphs.
+     */
+    extend(graph: Graph, prefix?: string): ({
+        id: string;
+        data: RunnableIOSchema | RunnableInterface<any, any, RunnableConfig<Record<string, any>>>;
+    } | undefined)[];
+    trimFirstNode(): void;
+    trimLastNode(): void;
+    /**
+     * Return a new graph with all nodes re-identified,
+     * using their unique, readable names where possible.
+     */
+    reid(): Graph;
+    drawMermaid(params?: {
+        withStyles?: boolean;
+        curveStyle?: string;
+        nodeColors?: Record<string, string>;
+        wrapLabelNWords?: number;
+    }): string;
+    drawMermaidPng(params?: {
+        withStyles?: boolean;
+        curveStyle?: string;
+        nodeColors?: Record<string, string>;
+        wrapLabelNWords?: number;
+        backgroundColor?: string;
+    }): Promise<Blob>;
+}
+
+type RunnableFunc<RunInput, RunOutput, CallOptions extends RunnableConfig = RunnableConfig> = (input: RunInput, options: CallOptions | Record<string, any> | (Record<string, any> & CallOptions)) => RunOutput | Promise<RunOutput>;
+type RunnableMapLike<RunInput, RunOutput> = {
+    [K in keyof RunOutput]: RunnableLike<RunInput, RunOutput[K]>;
+};
+type RunnableLike<RunInput = any, RunOutput = any, CallOptions extends RunnableConfig = RunnableConfig> = RunnableInterface<RunInput, RunOutput, CallOptions> | RunnableFunc<RunInput, RunOutput, CallOptions> | RunnableMapLike<RunInput, RunOutput>;
+type RunnableRetryFailedAttemptHandler = (error: any, input: any) => any;
+/**
+ * A Runnable is a generic unit of work that can be invoked, batched, streamed, and/or
+ * transformed.
+ */
+declare abstract class Runnable<RunInput = any, RunOutput = any, CallOptions extends RunnableConfig = RunnableConfig> extends Serializable implements RunnableInterface<RunInput, RunOutput, CallOptions> {
+    protected lc_runnable: boolean;
+    name?: string;
+    getName(suffix?: string): string;
+    abstract invoke(input: RunInput, options?: Partial<CallOptions>): Promise<RunOutput>;
+    /**
+     * Bind arguments to a Runnable, returning a new Runnable.
+     * @param kwargs
+     * @returns A new RunnableBinding that, when invoked, will apply the bound args.
+     */
+    bind(kwargs: Partial<CallOptions>): Runnable<RunInput, RunOutput, CallOptions>;
+    /**
+     * Return a new Runnable that maps a list of inputs to a list of outputs,
+     * by calling invoke() with each input.
+     */
+    map(): Runnable<RunInput[], RunOutput[], CallOptions>;
+    /**
+     * Add retry logic to an existing runnable.
+     * @param kwargs
+     * @returns A new RunnableRetry that, when invoked, will retry according to the parameters.
+     */
+    withRetry(fields?: {
+        stopAfterAttempt?: number;
+        onFailedAttempt?: RunnableRetryFailedAttemptHandler;
+    }): RunnableRetry<RunInput, RunOutput, CallOptions>;
+    /**
+     * 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: RunnableConfig): Runnable<RunInput, RunOutput, CallOptions>;
+    /**
+     * 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: {
+        fallbacks: Runnable<RunInput, RunOutput>[];
+    } | Runnable<RunInput, RunOutput>[]): RunnableWithFallbacks<RunInput, RunOutput>;
+    protected _getOptionsList<O extends CallOptions & {
+        runType?: string;
+    }>(options: Partial<O> | Partial<O>[], length?: number): Partial<O>[];
+    /**
+     * Default implementation of batch, which calls invoke N times.
+     * Subclasses should override this method if they can batch more efficiently.
+     * @param inputs Array of inputs to each batch call.
+     * @param options Either a single call options object to apply to each batch call or an array for each call.
+     * @param batchOptions.returnExceptions Whether to return errors rather than throwing on the first one
+     * @returns An array of RunOutputs, or mixed RunOutputs and errors if batchOptions.returnExceptions is set
+     */
+    batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions & {
+        returnExceptions?: false;
+    }): Promise<RunOutput[]>;
+    batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions & {
+        returnExceptions: true;
+    }): Promise<(RunOutput | Error)[]>;
+    batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions): Promise<(RunOutput | Error)[]>;
+    /**
+     * Default streaming implementation.
+     * Subclasses should override this method if they support streaming output.
+     * @param input
+     * @param options
+     */
+    _streamIterator(input: RunInput, options?: Partial<CallOptions>): AsyncGenerator<RunOutput>;
+    /**
+     * Stream output in chunks.
+     * @param input
+     * @param options
+     * @returns A readable stream that is also an iterable.
+     */
+    stream(input: RunInput, options?: Partial<CallOptions>): Promise<IterableReadableStream<RunOutput>>;
+    protected _separateRunnableConfigFromCallOptions(options?: Partial<CallOptions>): [RunnableConfig, Omit<Partial<CallOptions>, keyof RunnableConfig>];
+    protected _callWithConfig<T extends RunInput>(func: ((input: T) => Promise<RunOutput>) | ((input: T, config?: Partial<CallOptions>, runManager?: CallbackManagerForChainRun) => Promise<RunOutput>), input: T, options?: Partial<CallOptions> & {
+        runType?: string;
+    }): Promise<RunOutput>;
+    /**
+     * 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.
+     */
+    _batchWithConfig<T extends RunInput>(func: (inputs: T[], options?: Partial<CallOptions>[], runManagers?: (CallbackManagerForChainRun | undefined)[], batchOptions?: RunnableBatchOptions) => Promise<(RunOutput | Error)[]>, inputs: T[], options?: Partial<CallOptions & {
+        runType?: string;
+    }> | Partial<CallOptions & {
+        runType?: string;
+    }>[], batchOptions?: RunnableBatchOptions): Promise<(RunOutput | Error)[]>;
+    /**
+     * 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.
+     */
+    protected _transformStreamWithConfig<I extends RunInput, O extends RunOutput>(inputGenerator: AsyncGenerator<I>, transformer: (generator: AsyncGenerator<I>, runManager?: CallbackManagerForChainRun, options?: Partial<CallOptions>) => AsyncGenerator<O>, options?: Partial<CallOptions> & {
+        runType?: string;
+    }): AsyncGenerator<O>;
+    getGraph(_?: RunnableConfig): 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<NewRunOutput>(coerceable: RunnableLike<RunOutput, NewRunOutput>): Runnable<RunInput, Exclude<NewRunOutput, Error>>;
+    /**
+     * Pick keys from the dict output of this runnable. Returns a new runnable.
+     */
+    pick(keys: string | string[]): Runnable;
+    /**
+     * Assigns new fields to the dict output of this runnable. Returns a new runnable.
+     */
+    assign(mapping: RunnableMapLike<Record<string, unknown>, Record<string, unknown>>): Runnable;
+    /**
+     * 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
+     */
+    transform(generator: AsyncGenerator<RunInput>, options: Partial<CallOptions>): AsyncGenerator<RunOutput>;
+    /**
+     * 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
+     */
+    streamLog(input: RunInput, options?: Partial<CallOptions>, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): AsyncGenerator<RunLogPatch>;
+    protected _streamLog(input: RunInput, logStreamCallbackHandler: LogStreamCallbackHandler, config: Partial<CallOptions>): AsyncGenerator<RunLogPatch>;
+    /**
+     * Generate a stream of events emitted by the internal steps of the runnable.
+     *
+     * Use to create an iterator over StreamEvents that provide real-time information
+     * about the progress of the runnable, including StreamEvents from intermediate
+     * results.
+     *
+     * A StreamEvent is a dictionary with the following schema:
+     *
+     * - `event`: string - Event names are of the format: on_[runnable_type]_(start|stream|end).
+     * - `name`: string - The name of the runnable that generated the event.
+     * - `run_id`: string - Randomly generated ID associated with the given execution of
+     *   the runnable that emitted the event. A child runnable that gets invoked as part of the execution of a
+     *   parent runnable is assigned its own unique ID.
+     * - `tags`: string[] - The tags of the runnable that generated the event.
+     * - `metadata`: Record<string, any> - The metadata of the runnable that generated the event.
+     * - `data`: Record<string, any>
+     *
+     * Below is a table that illustrates some events that might be emitted by various
+     * chains. Metadata fields have been omitted from the table for brevity.
+     * Chain definitions have been included after the table.
+     *
+     * **ATTENTION** This reference table is for the V2 version of the schema.
+     *
+     * ```md
+     * +----------------------+-----------------------------+------------------------------------------+
+     * | event                | input                       | output/chunk                             |
+     * +======================+=============================+==========================================+
+     * | on_chat_model_start  | {"messages": BaseMessage[]} |                                          |
+     * +----------------------+-----------------------------+------------------------------------------+
+     * | on_chat_model_stream |                             | AIMessageChunk("hello")                  |
+     * +----------------------+-----------------------------+------------------------------------------+
+     * | on_chat_model_end    | {"messages": BaseMessage[]} | AIMessageChunk("hello world")            |
+     * +----------------------+-----------------------------+------------------------------------------+
+     * | on_llm_start         | {'input': 'hello'}          |                                          |
+     * +----------------------+-----------------------------+------------------------------------------+
+     * | on_llm_stream        |                             | 'Hello'                                  |
+     * +----------------------+-----------------------------+------------------------------------------+
+     * | on_llm_end           | 'Hello human!'              |                                          |
+     * +----------------------+-----------------------------+------------------------------------------+
+     * | on_chain_start       |                             |                                          |
+     * +----------------------+-----------------------------+------------------------------------------+
+     * | on_chain_stream      |                             | "hello world!"                           |
+     * +----------------------+-----------------------------+------------------------------------------+
+     * | on_chain_end         | [Document(...)]             | "hello world!, goodbye world!"           |
+     * +----------------------+-----------------------------+------------------------------------------+
+     * | on_tool_start        | {"x": 1, "y": "2"}          |                                          |
+     * +----------------------+-----------------------------+------------------------------------------+
+     * | on_tool_end          |                             | {"x": 1, "y": "2"}                       |
+     * +----------------------+-----------------------------+------------------------------------------+
+     * | on_retriever_start   | {"query": "hello"}          |                                          |
+     * +----------------------+-----------------------------+------------------------------------------+
+     * | on_retriever_end     | {"query": "hello"}          | [Document(...), ..]                      |
+     * +----------------------+-----------------------------+------------------------------------------+
+     * | on_prompt_start      | {"question": "hello"}       |                                          |
+     * +----------------------+-----------------------------+------------------------------------------+
+     * | on_prompt_end        | {"question": "hello"}       | ChatPromptValue(messages: BaseMessage[]) |
+     * +----------------------+-----------------------------+------------------------------------------+
+     * ```
+     *
+     * The "on_chain_*" events are the default for Runnables that don't fit one of the above categories.
+     *
+     * In addition to the standard events above, users can also dispatch custom events.
+     *
+     * Custom events will be only be surfaced with in the `v2` version of the API!
+     *
+     * A custom event has following format:
+     *
+     * ```md
+     * +-----------+------+------------------------------------------------------------+
+     * | Attribute | Type | Description                                                |
+     * +===========+======+============================================================+
+     * | name      | str  | A user defined name for the event.                         |
+     * +-----------+------+------------------------------------------------------------+
+     * | data      | Any  | The data associated with the event. This can be anything.  |
+     * +-----------+------+------------------------------------------------------------+
+     * ```
+     *
+     * Here's an example:
+     *
+     * ```ts
+     * import { RunnableLambda } from "@langchain/core/runnables";
+     * import { dispatchCustomEvent } from "@langchain/core/callbacks/dispatch";
+     * // Use this import for web environments that don't support "async_hooks"
+     * // and manually pass config to child runs.
+     * // import { dispatchCustomEvent } from "@langchain/core/callbacks/dispatch/web";
+     *
+     * const slowThing = RunnableLambda.from(async (someInput: string) => {
+     *   // Placeholder for some slow operation
+     *   await new Promise((resolve) => setTimeout(resolve, 100));
+     *   await dispatchCustomEvent("progress_event", {
+     *    message: "Finished step 1 of 2",
+     *  });
+     *  await new Promise((resolve) => setTimeout(resolve, 100));
+     *  return "Done";
+     * });
+     *
+     * const eventStream = await slowThing.streamEvents("hello world", {
+     *   version: "v2",
+     * });
+     *
+     * for await (const event of eventStream) {
+     *  if (event.event === "on_custom_event") {
+     *    console.log(event);
+     *  }
+     * }
+     * ```
+     */
+    streamEvents(input: RunInput, options: Partial<CallOptions> & {
+        version: "v1" | "v2";
+    }, streamOptions?: Omit<EventStreamCallbackHandlerInput, "autoClose">): IterableReadableStream<StreamEvent>;
+    streamEvents(input: RunInput, options: Partial<CallOptions> & {
+        version: "v1" | "v2";
+        encoding: "text/event-stream";
+    }, streamOptions?: Omit<EventStreamCallbackHandlerInput, "autoClose">): IterableReadableStream<Uint8Array>;
+    private _streamEventsV2;
+    private _streamEventsV1;
+    static isRunnable(thing: any): thing is Runnable;
+    /**
+     * 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, }: {
+        onStart?: (run: Run, config?: RunnableConfig) => void | Promise<void>;
+        onEnd?: (run: Run, config?: RunnableConfig) => void | Promise<void>;
+        onError?: (run: Run, config?: RunnableConfig) => void | Promise<void>;
+    }): Runnable<RunInput, RunOutput, CallOptions>;
+    /**
+     * 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<T extends RunInput = RunInput>(fields: {
+        name?: string;
+        description?: string;
+        schema: z.ZodType<T>;
+    }): RunnableToolLike<z.ZodType<T | ToolCall>, RunOutput>;
+}
+type RunnableBindingArgs<RunInput, RunOutput, CallOptions extends RunnableConfig = RunnableConfig> = {
+    bound: Runnable<RunInput, RunOutput, CallOptions>;
+    kwargs?: Partial<CallOptions>;
+    config: RunnableConfig;
+    configFactories?: Array<(config: RunnableConfig) => RunnableConfig>;
+};
+/**
+ * A runnable that delegates calls to another runnable with a set of kwargs.
+ * @example
+ * ```typescript
+ * import {
+ *   type RunnableConfig,
+ *   RunnableLambda,
+ * } from "@langchain/core/runnables";
+ *
+ * const enhanceProfile = (
+ *   profile: Record<string, any>,
+ *   config?: RunnableConfig
+ * ) => {
+ *   if (config?.configurable?.role) {
+ *     return { ...profile, role: config.configurable.role };
+ *   }
+ *   return profile;
+ * };
+ *
+ * const runnable = RunnableLambda.from(enhanceProfile);
+ *
+ * // Bind configuration to the runnable to set the user's role dynamically
+ * const adminRunnable = runnable.bind({ configurable: { role: "Admin" } });
+ * const userRunnable = runnable.bind({ configurable: { role: "User" } });
+ *
+ * const result1 = await adminRunnable.invoke({
+ *   name: "Alice",
+ *   email: "alice@example.com"
+ * });
+ *
+ * // { name: "Alice", email: "alice@example.com", role: "Admin" }
+ *
+ * const result2 = await userRunnable.invoke({
+ *   name: "Bob",
+ *   email: "bob@example.com"
+ * });
+ *
+ * // { name: "Bob", email: "bob@example.com", role: "User" }
+ * ```
+ */
+declare class RunnableBinding<RunInput, RunOutput, CallOptions extends RunnableConfig = RunnableConfig> extends Runnable<RunInput, RunOutput, CallOptions> {
+    static lc_name(): string;
+    lc_namespace: string[];
+    lc_serializable: boolean;
+    bound: Runnable<RunInput, RunOutput, CallOptions>;
+    config: RunnableConfig;
+    kwargs?: Partial<CallOptions>;
+    configFactories?: Array<(config: RunnableConfig) => RunnableConfig | Promise<RunnableConfig>>;
+    constructor(fields: RunnableBindingArgs<RunInput, RunOutput, CallOptions>);
+    getName(suffix?: string | undefined): string;
+    _mergeConfig(...options: (Partial<CallOptions> | RunnableConfig | undefined)[]): Promise<Partial<CallOptions>>;
+    bind(kwargs: Partial<CallOptions>): RunnableBinding<RunInput, RunOutput, CallOptions>;
+    withConfig(config: RunnableConfig): Runnable<RunInput, RunOutput, CallOptions>;
+    withRetry(fields?: {
+        stopAfterAttempt?: number;
+        onFailedAttempt?: RunnableRetryFailedAttemptHandler;
+    }): RunnableRetry<RunInput, RunOutput, CallOptions>;
+    invoke(input: RunInput, options?: Partial<CallOptions>): Promise<RunOutput>;
+    batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions & {
+        returnExceptions?: false;
+    }): Promise<RunOutput[]>;
+    batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions & {
+        returnExceptions: true;
+    }): Promise<(RunOutput | Error)[]>;
+    batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions): Promise<(RunOutput | Error)[]>;
+    _streamIterator(input: RunInput, options?: Partial<CallOptions> | undefined): AsyncGenerator<Awaited<RunOutput>, void, unknown>;
+    stream(input: RunInput, options?: Partial<CallOptions> | undefined): Promise<IterableReadableStream<RunOutput>>;
+    transform(generator: AsyncGenerator<RunInput>, options?: Partial<CallOptions>): AsyncGenerator<RunOutput>;
+    streamEvents(input: RunInput, options: Partial<CallOptions> & {
+        version: "v1" | "v2";
+    }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): IterableReadableStream<StreamEvent>;
+    streamEvents(input: RunInput, options: Partial<CallOptions> & {
+        version: "v1" | "v2";
+        encoding: "text/event-stream";
+    }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): IterableReadableStream<Uint8Array>;
+    static isRunnableBinding(thing: any): thing is RunnableBinding<any, any, any>;
+    /**
+     * 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, }: {
+        onStart?: (run: Run, config?: RunnableConfig) => void | Promise<void>;
+        onEnd?: (run: Run, config?: RunnableConfig) => void | Promise<void>;
+        onError?: (run: Run, config?: RunnableConfig) => void | Promise<void>;
+    }): Runnable<RunInput, RunOutput, CallOptions>;
+}
+/**
+ * Base class for runnables that can be retried a
+ * specified number of times.
+ * @example
+ * ```typescript
+ * import {
+ *   RunnableLambda,
+ *   RunnableRetry,
+ * } from "@langchain/core/runnables";
+ *
+ * // Simulate an API call that fails
+ * const simulateApiCall = (input: string): string => {
+ *   console.log(`Attempting API call with input: ${input}`);
+ *   throw new Error("API call failed due to network issue");
+ * };
+ *
+ * const apiCallLambda = RunnableLambda.from(simulateApiCall);
+ *
+ * // Apply retry logic using the .withRetry() method
+ * const apiCallWithRetry = apiCallLambda.withRetry({ stopAfterAttempt: 3 });
+ *
+ * // Alternatively, create a RunnableRetry instance manually
+ * const manualRetry = new RunnableRetry({
+ *   bound: apiCallLambda,
+ *   maxAttemptNumber: 3,
+ *   config: {},
+ * });
+ *
+ * // Example invocation using the .withRetry() method
+ * const res = await apiCallWithRetry
+ *   .invoke("Request 1")
+ *   .catch((error) => {
+ *     console.error("Failed after multiple retries:", error.message);
+ *   });
+ *
+ * // Example invocation using the manual retry instance
+ * const res2 = await manualRetry
+ *   .invoke("Request 2")
+ *   .catch((error) => {
+ *     console.error("Failed after multiple retries:", error.message);
+ *   });
+ * ```
+ */
+declare class RunnableRetry<RunInput = any, RunOutput = any, CallOptions extends RunnableConfig = RunnableConfig> extends RunnableBinding<RunInput, RunOutput, CallOptions> {
+    static lc_name(): string;
+    lc_namespace: string[];
+    protected maxAttemptNumber: number;
+    onFailedAttempt: RunnableRetryFailedAttemptHandler;
+    constructor(fields: RunnableBindingArgs<RunInput, RunOutput, CallOptions> & {
+        maxAttemptNumber?: number;
+        onFailedAttempt?: RunnableRetryFailedAttemptHandler;
+    });
+    _patchConfigForRetry(attempt: number, config?: Partial<CallOptions>, runManager?: CallbackManagerForChainRun): Partial<CallOptions>;
+    protected _invoke(input: RunInput, config?: CallOptions, runManager?: CallbackManagerForChainRun): Promise<RunOutput>;
+    /**
+     * 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.
+     */
+    invoke(input: RunInput, config?: CallOptions): Promise<RunOutput>;
+    _batch<ReturnExceptions extends boolean = false>(inputs: RunInput[], configs?: RunnableConfig[], runManagers?: (CallbackManagerForChainRun | undefined)[], batchOptions?: RunnableBatchOptions): Promise<ReturnExceptions extends false ? RunOutput[] : (Error | RunOutput)[]>;
+    batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions & {
+        returnExceptions?: false;
+    }): Promise<RunOutput[]>;
+    batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions & {
+        returnExceptions: true;
+    }): Promise<(RunOutput | Error)[]>;
+    batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions): Promise<(RunOutput | Error)[]>;
+}
+/**
+ * A Runnable that can fallback to other Runnables if it fails.
+ * External APIs (e.g., APIs for a language model) may at times experience
+ * degraded performance or even downtime.
+ *
+ * In these cases, it can be useful to have a fallback Runnable that can be
+ * used in place of the original Runnable (e.g., fallback to another LLM provider).
+ *
+ * Fallbacks can be defined at the level of a single Runnable, or at the level
+ * of a chain of Runnables. Fallbacks are tried in order until one succeeds or
+ * all fail.
+ *
+ * While you can instantiate a `RunnableWithFallbacks` directly, it is usually
+ * more convenient to use the `withFallbacks` method on an existing Runnable.
+ *
+ * When streaming, fallbacks will only be called on failures during the initial
+ * stream creation. Errors that occur after a stream starts will not fallback
+ * to the next Runnable.
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   RunnableLambda,
+ *   RunnableWithFallbacks,
+ * } from "@langchain/core/runnables";
+ *
+ * const primaryOperation = (input: string): string => {
+ *   if (input !== "safe") {
+ *     throw new Error("Primary operation failed due to unsafe input");
+ *   }
+ *   return `Processed: ${input}`;
+ * };
+ *
+ * // Define a fallback operation that processes the input differently
+ * const fallbackOperation = (input: string): string =>
+ *   `Fallback processed: ${input}`;
+ *
+ * const primaryRunnable = RunnableLambda.from(primaryOperation);
+ * const fallbackRunnable = RunnableLambda.from(fallbackOperation);
+ *
+ * // Apply the fallback logic using the .withFallbacks() method
+ * const runnableWithFallback = primaryRunnable.withFallbacks([fallbackRunnable]);
+ *
+ * // Alternatively, create a RunnableWithFallbacks instance manually
+ * const manualFallbackChain = new RunnableWithFallbacks({
+ *   runnable: primaryRunnable,
+ *   fallbacks: [fallbackRunnable],
+ * });
+ *
+ * // Example invocation using .withFallbacks()
+ * const res = await runnableWithFallback
+ *   .invoke("unsafe input")
+ *   .catch((error) => {
+ *     console.error("Failed after all attempts:", error.message);
+ *   });
+ *
+ * // "Fallback processed: unsafe input"
+ *
+ * // Example invocation using manual instantiation
+ * const res = await manualFallbackChain
+ *   .invoke("safe")
+ *   .catch((error) => {
+ *     console.error("Failed after all attempts:", error.message);
+ *   });
+ *
+ * // "Processed: safe"
+ * ```
+ */
+declare class RunnableWithFallbacks<RunInput, RunOutput> extends Runnable<RunInput, RunOutput> {
+    static lc_name(): string;
+    lc_namespace: string[];
+    lc_serializable: boolean;
+    runnable: Runnable<RunInput, RunOutput>;
+    fallbacks: Runnable<RunInput, RunOutput>[];
+    constructor(fields: {
+        runnable: Runnable<RunInput, RunOutput>;
+        fallbacks: Runnable<RunInput, RunOutput>[];
+    });
+    runnables(): Generator<Runnable<RunInput, RunOutput, RunnableConfig<Record<string, any>>>, void, unknown>;
+    invoke(input: RunInput, options?: Partial<RunnableConfig>): Promise<RunOutput>;
+    _streamIterator(input: RunInput, options?: Partial<RunnableConfig> | undefined): AsyncGenerator<RunOutput>;
+    batch(inputs: RunInput[], options?: Partial<RunnableConfig> | Partial<RunnableConfig>[], batchOptions?: RunnableBatchOptions & {
+        returnExceptions?: false;
+    }): Promise<RunOutput[]>;
+    batch(inputs: RunInput[], options?: Partial<RunnableConfig> | Partial<RunnableConfig>[], batchOptions?: RunnableBatchOptions & {
+        returnExceptions: true;
+    }): Promise<(RunOutput | Error)[]>;
+    batch(inputs: RunInput[], options?: Partial<RunnableConfig> | Partial<RunnableConfig>[], batchOptions?: RunnableBatchOptions): Promise<(RunOutput | Error)[]>;
+}
+interface RunnableToolLikeArgs<RunInput extends z.ZodType = z.ZodType, RunOutput = unknown> extends Omit<RunnableBindingArgs<z.infer<RunInput>, RunOutput>, "config"> {
+    name: string;
+    description?: string;
+    schema: RunInput;
+    config?: RunnableConfig;
+}
+declare class RunnableToolLike<RunInput extends z.ZodType = z.ZodType, RunOutput = unknown> extends RunnableBinding<z.infer<RunInput>, RunOutput> {
+    name: string;
+    description?: string;
+    schema: RunInput;
+    constructor(fields: RunnableToolLikeArgs<RunInput, RunOutput>);
+    static lc_name(): string;
+}
+
+interface BaseLangChainParams {
+    verbose?: boolean;
+    callbacks?: Callbacks;
+    tags?: string[];
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Base class for language models, chains, tools.
+ */
+declare abstract class BaseLangChain<RunInput, RunOutput, CallOptions extends RunnableConfig = RunnableConfig> extends Runnable<RunInput, RunOutput, CallOptions> implements BaseLangChainParams {
+    /**
+     * Whether to print out response text.
+     */
+    verbose: boolean;
+    callbacks?: Callbacks;
+    tags?: string[];
+    metadata?: Record<string, unknown>;
+    get lc_attributes(): {
+        [key: string]: undefined;
+    } | undefined;
+    constructor(params: BaseLangChainParams);
+}
+
+type ResponseFormat = "content" | "content_and_artifact" | string;
+type ToolReturnType = any;
+type ZodObjectAny = z.ZodObject<any, any, any, any>;
+/**
+ * Parameters for the Tool classes.
+ */
+interface ToolParams extends BaseLangChainParams {
+    /**
+     * The tool response format.
+     *
+     * If "content" then the output of the tool is interpreted as the contents of a
+     * ToolMessage. If "content_and_artifact" then the output is expected to be a
+     * two-tuple corresponding to the (content, artifact) of a ToolMessage.
+     *
+     * @default "content"
+     */
+    responseFormat?: ResponseFormat;
+    /**
+     * Whether to show full details in the thrown parsing errors.
+     *
+     * @default false
+     */
+    verboseParsingErrors?: boolean;
+}
+type ToolRunnableConfig<ConfigurableFieldType extends Record<string, any> = Record<string, any>> = RunnableConfig<ConfigurableFieldType> & {
+    toolCall?: ToolCall;
+};
+/**
+ * Base class for Tools that accept input of any shape defined by a Zod schema.
+ */
+declare abstract class StructuredTool<T extends ZodObjectAny = ZodObjectAny> extends BaseLangChain<(z.output<T> extends string ? string : never) | z.input<T> | ToolCall, ToolReturnType> {
+    abstract name: string;
+    abstract description: string;
+    abstract schema: T | z.ZodEffects<T>;
+    /**
+     * Whether to return the tool's output directly.
+     *
+     * Setting this to true means that after the tool is called,
+     * an agent should stop looping.
+     */
+    returnDirect: boolean;
+    verboseParsingErrors: boolean;
+    get lc_namespace(): string[];
+    /**
+     * The tool response format.
+     *
+     * If "content" then the output of the tool is interpreted as the contents of a
+     * ToolMessage. If "content_and_artifact" then the output is expected to be a
+     * two-tuple corresponding to the (content, artifact) of a ToolMessage.
+     *
+     * @default "content"
+     */
+    responseFormat?: ResponseFormat;
+    constructor(fields?: ToolParams);
+    protected abstract _call(arg: z.output<T>, runManager?: CallbackManagerForToolRun, parentConfig?: ToolRunnableConfig): Promise<ToolReturnType>;
+    /**
+     * Invokes the tool with the provided input and configuration.
+     * @param input The input for the tool.
+     * @param config Optional configuration for the tool.
+     * @returns A Promise that resolves with a string.
+     */
+    invoke(input: (z.output<T> extends string ? string : never) | z.input<T> | ToolCall, config?: RunnableConfig): Promise<ToolReturnType>;
+    /**
+     * @deprecated Use .invoke() instead. Will be removed in 0.3.0.
+     *
+     * Calls the tool with the provided argument, configuration, and tags. It
+     * parses the input according to the schema, handles any errors, and
+     * manages callbacks.
+     * @param arg The input argument for the tool.
+     * @param configArg Optional configuration or callbacks for the tool.
+     * @param tags Optional tags for the tool.
+     * @returns A Promise that resolves with a string.
+     */
+    call(arg: (z.output<T> extends string ? string : never) | z.input<T>, configArg?: Callbacks | ToolRunnableConfig, 
+    /** @deprecated */
+    tags?: string[]): Promise<ToolReturnType>;
+}
+interface BaseDynamicToolInput extends ToolParams {
+    name: string;
+    description: string;
+    /**
+     * Whether to return the tool's output directly.
+     *
+     * Setting this to true means that after the tool is called,
+     * an agent should stop looping.
+     */
+    returnDirect?: boolean;
+}
+/**
+ * Interface for the input parameters of the DynamicStructuredTool class.
+ */
+interface DynamicStructuredToolInput<T extends ZodObjectAny | Record<string, any> = ZodObjectAny> extends BaseDynamicToolInput {
+    func: (input: BaseDynamicToolInput["responseFormat"] extends "content_and_artifact" ? ToolCall : T extends ZodObjectAny ? z.infer<T> : T, runManager?: CallbackManagerForToolRun, config?: RunnableConfig) => Promise<ToolReturnType>;
+    schema: T extends ZodObjectAny ? T : T;
+}
+/**
+ * A tool that can be created dynamically from a function, name, and
+ * description, designed to work with structured data. It extends the
+ * StructuredTool class and overrides the _call method to execute the
+ * provided function when the tool is called.
+ *
+ * Schema can be passed as Zod or JSON schema. The tool will not validate
+ * input if JSON schema is passed.
+ */
+declare class DynamicStructuredTool<T extends ZodObjectAny | Record<string, any> = ZodObjectAny> extends StructuredTool<T extends ZodObjectAny ? T : ZodObjectAny> {
+    static lc_name(): string;
+    name: string;
+    description: string;
+    func: DynamicStructuredToolInput<T>["func"];
+    schema: T extends ZodObjectAny ? T : ZodObjectAny;
+    constructor(fields: DynamicStructuredToolInput<T>);
+    /**
+     * @deprecated Use .invoke() instead. Will be removed in 0.3.0.
+     */
+    call(arg: (T extends ZodObjectAny ? z.output<T> : T) | ToolCall, configArg?: RunnableConfig | Callbacks, 
+    /** @deprecated */
+    tags?: string[]): Promise<ToolReturnType>;
+    protected _call(arg: (T extends ZodObjectAny ? z.output<T> : T) | ToolCall, runManager?: CallbackManagerForToolRun, parentConfig?: RunnableConfig): Promise<ToolReturnType>;
+}
 
 declare const executeTool: (config: FreestyleExecuteScriptParamsConfiguration & {
     apiKey: string;