langchain 0.0.138 → 0.0.140

package/dist/agents/initialize.cjs

@@ -8,6 +8,7 @@ const index_js_3 = require("./structured_chat/index.cjs");
 const executor_js_1 = require("./executor.cjs");
 const index_js_4 = require("./mrkl/index.cjs");
 const index_js_5 = require("./openai/index.cjs");
+const index_js_6 = require("./xml/index.cjs");
 /**
  * @deprecated use initializeAgentExecutorWithOptions instead
  */
@@ -88,6 +89,16 @@ async function initializeAgentExecutorWithOptions(tools, llm, options = {
             });
             return executor;
         }
+        case "xml": {
+            const { agentArgs, tags, ...rest } = options;
+            const executor = executor_js_1.AgentExecutor.fromAgentAndTools({
+                tags: [...(tags ?? []), "xml"],
+                agent: index_js_6.XMLAgent.fromLLMAndTools(llm, tools, agentArgs),
+                tools,
+                ...rest,
+            });
+            return executor;
+        }
         case "structured-chat-zero-shot-react-description": {
             const { agentArgs, memory, tags, ...rest } = options;
             const executor = executor_js_1.AgentExecutor.fromAgentAndTools({

package/dist/agents/initialize.d.ts

@@ -7,6 +7,7 @@ import { StructuredChatAgent } from "./structured_chat/index.js";
 import { AgentExecutor, AgentExecutorInput } from "./executor.js";
 import { ZeroShotAgent } from "./mrkl/index.js";
 import { OpenAIAgent } from "./openai/index.js";
+import { XMLAgent } from "./xml/index.js";
 /**
  * Represents the type of an agent in LangChain. It can be
  * "zero-shot-react-description", "chat-zero-shot-react-description", or
@@ -31,6 +32,9 @@ export type InitializeAgentExecutorOptions = ({
 } & Omit<AgentExecutorInput, "agent" | "tools">) | ({
     agentType: "chat-conversational-react-description";
     agentArgs?: Parameters<typeof ChatConversationalAgent.fromLLMAndTools>[2];
+} & Omit<AgentExecutorInput, "agent" | "tools">) | ({
+    agentType: "xml";
+    agentArgs?: Parameters<typeof XMLAgent.fromLLMAndTools>[2];
 } & Omit<AgentExecutorInput, "agent" | "tools">);
 /**
  * @interface

package/dist/agents/initialize.js

@@ -5,6 +5,7 @@ import { StructuredChatAgent } from "./structured_chat/index.js";
 import { AgentExecutor } from "./executor.js";
 import { ZeroShotAgent } from "./mrkl/index.js";
 import { OpenAIAgent } from "./openai/index.js";
+import { XMLAgent } from "./xml/index.js";
 /**
  * @deprecated use initializeAgentExecutorWithOptions instead
  */
@@ -84,6 +85,16 @@ export async function initializeAgentExecutorWithOptions(tools, llm, options = {
             });
             return executor;
         }
+        case "xml": {
+            const { agentArgs, tags, ...rest } = options;
+            const executor = AgentExecutor.fromAgentAndTools({
+                tags: [...(tags ?? []), "xml"],
+                agent: XMLAgent.fromLLMAndTools(llm, tools, agentArgs),
+                tools,
+                ...rest,
+            });
+            return executor;
+        }
         case "structured-chat-zero-shot-react-description": {
             const { agentArgs, memory, tags, ...rest } = options;
             const executor = AgentExecutor.fromAgentAndTools({

package/dist/agents/xml/index.cjs

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XMLAgent = exports.parseOutput = void 0;
+const llm_chain_js_1 = require("../../chains/llm_chain.cjs");
+const chat_js_1 = require("../../prompts/chat.cjs");
+const agent_js_1 = require("../agent.cjs");
+const output_parser_js_1 = require("../../schema/output_parser.cjs");
+const prompt_js_1 = require("./prompt.cjs");
+/**
+ * Parses the output text from the agent and returns an AgentAction or
+ * AgentFinish object.
+ * @param text The output text from the agent.
+ * @returns An AgentAction or AgentFinish object.
+ */
+async function parseOutput(text) {
+    if (text.includes("</tool>")) {
+        const [tool, toolInput] = text.split("</tool>");
+        const _tool = tool.split("<tool>")[1];
+        const _toolInput = toolInput.split("<tool_input>")[1];
+        return { tool: _tool, toolInput: _toolInput, log: text };
+    }
+    else if (text.includes("<final_answer>")) {
+        const [, answer] = text.split("<final_answer>");
+        return { returnValues: { output: answer }, log: text };
+    }
+    else {
+        throw new output_parser_js_1.OutputParserException(`Could not parse LLM output: ${text}`);
+    }
+}
+exports.parseOutput = parseOutput;
+/**
+ * Class that represents an agent that uses XML tags.
+ */
+class XMLAgent extends agent_js_1.BaseSingleActionAgent {
+    static lc_name() {
+        return "XMLAgent";
+    }
+    _agentType() {
+        return "xml";
+    }
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "agents", "xml"]
+        });
+        Object.defineProperty(this, "tools", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "llmChain", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.tools = fields.tools;
+        this.llmChain = fields.llmChain;
+    }
+    get inputKeys() {
+        return ["input"];
+    }
+    static createPrompt() {
+        return chat_js_1.ChatPromptTemplate.fromPromptMessages([
+            chat_js_1.HumanMessagePromptTemplate.fromTemplate(prompt_js_1.AGENT_INSTRUCTIONS),
+            chat_js_1.AIMessagePromptTemplate.fromTemplate("{intermediate_steps}"),
+        ]);
+    }
+    /**
+     * Plans the next action or finish state of the agent based on the
+     * provided steps, inputs, and optional callback manager.
+     * @param steps The steps to consider in planning.
+     * @param inputs The inputs to consider in planning.
+     * @param callbackManager Optional CallbackManager to use in planning.
+     * @returns A Promise that resolves to an AgentAction or AgentFinish object representing the planned action or finish state.
+     */
+    async plan(steps, inputs, callbackManager) {
+        let log = "";
+        for (const { action, observation } of steps) {
+            log += `<tool>${action.tool}</tool><tool_input>${action.toolInput}</tool_input><observation>${observation}</observation>`;
+        }
+        let tools = "";
+        for (const tool of this.tools) {
+            tools += `${tool.name}: ${tool.description}\n`;
+        }
+        const _inputs = {
+            intermediate_steps: log,
+            tools,
+            question: inputs.input,
+            stop: ["</tool_input>", "</final_answer>"],
+        };
+        const response = await this.llmChain.call(_inputs, callbackManager);
+        return parseOutput(response[this.llmChain.outputKey]);
+    }
+    /**
+     * Creates an XMLAgent from a BaseLanguageModel and a list of tools.
+     * @param llm The BaseLanguageModel to use.
+     * @param tools The tools to be used by the agent.
+     * @param args Optional arguments for creating the agent.
+     * @returns An instance of XMLAgent.
+     */
+    static fromLLMAndTools(llm, tools, args) {
+        const prompt = XMLAgent.createPrompt();
+        const chain = new llm_chain_js_1.LLMChain({
+            prompt,
+            llm,
+            callbacks: args?.callbacks,
+        });
+        return new XMLAgent({
+            llmChain: chain,
+            tools,
+        });
+    }
+}
+exports.XMLAgent = XMLAgent;

package/dist/agents/xml/index.d.ts

@@ -0,0 +1,51 @@
+import { Tool } from "../../tools/base.js";
+import { LLMChain } from "../../chains/llm_chain.js";
+import { AgentStep, AgentAction, AgentFinish, ChainValues } from "../../schema/index.js";
+import { ChatPromptTemplate } from "../../prompts/chat.js";
+import { AgentArgs, BaseSingleActionAgent } from "../agent.js";
+import { CallbackManager } from "../../callbacks/manager.js";
+import { BaseLanguageModel } from "../../base_language/index.js";
+/**
+ * Interface for the input to the XMLAgent class.
+ */
+export interface XMLAgentInput {
+    tools: Tool[];
+    llmChain: LLMChain;
+}
+/**
+ * Parses the output text from the agent and returns an AgentAction or
+ * AgentFinish object.
+ * @param text The output text from the agent.
+ * @returns An AgentAction or AgentFinish object.
+ */
+export declare function parseOutput(text: string): Promise<AgentAction | AgentFinish>;
+/**
+ * Class that represents an agent that uses XML tags.
+ */
+export declare class XMLAgent extends BaseSingleActionAgent implements XMLAgentInput {
+    static lc_name(): string;
+    lc_namespace: string[];
+    tools: Tool[];
+    llmChain: LLMChain;
+    _agentType(): "xml";
+    constructor(fields: XMLAgentInput);
+    get inputKeys(): string[];
+    static createPrompt(): ChatPromptTemplate<any, any>;
+    /**
+     * Plans the next action or finish state of the agent based on the
+     * provided steps, inputs, and optional callback manager.
+     * @param steps The steps to consider in planning.
+     * @param inputs The inputs to consider in planning.
+     * @param callbackManager Optional CallbackManager to use in planning.
+     * @returns A Promise that resolves to an AgentAction or AgentFinish object representing the planned action or finish state.
+     */
+    plan(steps: AgentStep[], inputs: ChainValues, callbackManager?: CallbackManager): Promise<AgentAction | AgentFinish>;
+    /**
+     * Creates an XMLAgent from a BaseLanguageModel and a list of tools.
+     * @param llm The BaseLanguageModel to use.
+     * @param tools The tools to be used by the agent.
+     * @param args Optional arguments for creating the agent.
+     * @returns An instance of XMLAgent.
+     */
+    static fromLLMAndTools(llm: BaseLanguageModel, tools: Tool[], args?: XMLAgentInput & Pick<AgentArgs, "callbacks">): XMLAgent;
+}

package/dist/agents/xml/index.js

@@ -0,0 +1,114 @@
+import { LLMChain } from "../../chains/llm_chain.js";
+import { AIMessagePromptTemplate, ChatPromptTemplate, HumanMessagePromptTemplate, } from "../../prompts/chat.js";
+import { BaseSingleActionAgent } from "../agent.js";
+import { OutputParserException } from "../../schema/output_parser.js";
+import { AGENT_INSTRUCTIONS } from "./prompt.js";
+/**
+ * Parses the output text from the agent and returns an AgentAction or
+ * AgentFinish object.
+ * @param text The output text from the agent.
+ * @returns An AgentAction or AgentFinish object.
+ */
+export async function parseOutput(text) {
+    if (text.includes("</tool>")) {
+        const [tool, toolInput] = text.split("</tool>");
+        const _tool = tool.split("<tool>")[1];
+        const _toolInput = toolInput.split("<tool_input>")[1];
+        return { tool: _tool, toolInput: _toolInput, log: text };
+    }
+    else if (text.includes("<final_answer>")) {
+        const [, answer] = text.split("<final_answer>");
+        return { returnValues: { output: answer }, log: text };
+    }
+    else {
+        throw new OutputParserException(`Could not parse LLM output: ${text}`);
+    }
+}
+/**
+ * Class that represents an agent that uses XML tags.
+ */
+export class XMLAgent extends BaseSingleActionAgent {
+    static lc_name() {
+        return "XMLAgent";
+    }
+    _agentType() {
+        return "xml";
+    }
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "agents", "xml"]
+        });
+        Object.defineProperty(this, "tools", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "llmChain", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.tools = fields.tools;
+        this.llmChain = fields.llmChain;
+    }
+    get inputKeys() {
+        return ["input"];
+    }
+    static createPrompt() {
+        return ChatPromptTemplate.fromPromptMessages([
+            HumanMessagePromptTemplate.fromTemplate(AGENT_INSTRUCTIONS),
+            AIMessagePromptTemplate.fromTemplate("{intermediate_steps}"),
+        ]);
+    }
+    /**
+     * Plans the next action or finish state of the agent based on the
+     * provided steps, inputs, and optional callback manager.
+     * @param steps The steps to consider in planning.
+     * @param inputs The inputs to consider in planning.
+     * @param callbackManager Optional CallbackManager to use in planning.
+     * @returns A Promise that resolves to an AgentAction or AgentFinish object representing the planned action or finish state.
+     */
+    async plan(steps, inputs, callbackManager) {
+        let log = "";
+        for (const { action, observation } of steps) {
+            log += `<tool>${action.tool}</tool><tool_input>${action.toolInput}</tool_input><observation>${observation}</observation>`;
+        }
+        let tools = "";
+        for (const tool of this.tools) {
+            tools += `${tool.name}: ${tool.description}\n`;
+        }
+        const _inputs = {
+            intermediate_steps: log,
+            tools,
+            question: inputs.input,
+            stop: ["</tool_input>", "</final_answer>"],
+        };
+        const response = await this.llmChain.call(_inputs, callbackManager);
+        return parseOutput(response[this.llmChain.outputKey]);
+    }
+    /**
+     * Creates an XMLAgent from a BaseLanguageModel and a list of tools.
+     * @param llm The BaseLanguageModel to use.
+     * @param tools The tools to be used by the agent.
+     * @param args Optional arguments for creating the agent.
+     * @returns An instance of XMLAgent.
+     */
+    static fromLLMAndTools(llm, tools, args) {
+        const prompt = XMLAgent.createPrompt();
+        const chain = new LLMChain({
+            prompt,
+            llm,
+            callbacks: args?.callbacks,
+        });
+        return new XMLAgent({
+            llmChain: chain,
+            tools,
+        });
+    }
+}

package/dist/agents/xml/prompt.cjs

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AGENT_INSTRUCTIONS = void 0;
+exports.AGENT_INSTRUCTIONS = `You are a helpful assistant. Help the user answer any questions.
+
+You have access to the following tools:
+
+{tools}
+
+In order to use a tool, you can use <tool></tool> and <tool_input></tool_input> tags.
+You will then get back a response in the form <observation></observation>
+For example, if you have a tool called 'search' that could run a google search, in order to search for the weather in SF you would respond:
+
+<tool>search</tool><tool_input>weather in SF</tool_input>
+<observation>64 degrees</observation>
+
+When you are done, respond with a final answer between <final_answer></final_answer>. For example:
+
+<final_answer>The weather in SF is 64 degrees</final_answer>
+
+Begin!
+
+Question: {question}`;

package/dist/agents/xml/prompt.d.ts

@@ -0,0 +1 @@
+export declare const AGENT_INSTRUCTIONS = "You are a helpful assistant. Help the user answer any questions.\n\nYou have access to the following tools:\n\n{tools}\n\nIn order to use a tool, you can use <tool></tool> and <tool_input></tool_input> tags.\nYou will then get back a response in the form <observation></observation>\nFor example, if you have a tool called 'search' that could run a google search, in order to search for the weather in SF you would respond:\n\n<tool>search</tool><tool_input>weather in SF</tool_input>\n<observation>64 degrees</observation>\n\nWhen you are done, respond with a final answer between <final_answer></final_answer>. For example:\n\n<final_answer>The weather in SF is 64 degrees</final_answer>\n\nBegin!\n\nQuestion: {question}";

package/dist/agents/xml/prompt.js

@@ -0,0 +1,20 @@
+export const AGENT_INSTRUCTIONS = `You are a helpful assistant. Help the user answer any questions.
+
+You have access to the following tools:
+
+{tools}
+
+In order to use a tool, you can use <tool></tool> and <tool_input></tool_input> tags.
+You will then get back a response in the form <observation></observation>
+For example, if you have a tool called 'search' that could run a google search, in order to search for the weather in SF you would respond:
+
+<tool>search</tool><tool_input>weather in SF</tool_input>
+<observation>64 degrees</observation>
+
+When you are done, respond with a final answer between <final_answer></final_answer>. For example:
+
+<final_answer>The weather in SF is 64 degrees</final_answer>
+
+Begin!
+
+Question: {question}`;

package/dist/callbacks/base.d.ts

@@ -68,11 +68,15 @@ declare abstract class BaseCallbackHandlerMethodsClass {
     /**
      * Called if a Chain run encounters an error
      */
-    handleChainError?(err: Error, runId: string, parentRunId?: string, tags?: string[]): Promise<void> | void;
+    handleChainError?(err: Error, runId: string, parentRunId?: string, tags?: string[], kwargs?: {
+        inputs?: Record<string, unknown>;
+    }): Promise<void> | void;
     /**
      * Called at the end of a Chain run, with the outputs and the run ID.
      */
-    handleChainEnd?(outputs: ChainValues, runId: string, parentRunId?: string, tags?: string[]): Promise<void> | void;
+    handleChainEnd?(outputs: ChainValues, runId: string, parentRunId?: string, tags?: string[], kwargs?: {
+        inputs?: Record<string, unknown>;
+    }): Promise<void> | void;
     /**
      * Called at the start of a Tool run, with the tool name and input
      * and the run ID.
@@ -207,11 +211,15 @@ export declare abstract class BaseCallbackHandler extends BaseCallbackHandlerMet
         /**
          * Called if a Chain run encounters an error
          */
-        handleChainError?(err: any, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined): void | Promise<void>;
+        handleChainError?(err: any, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined, kwargs?: {
+            inputs?: Record<string, unknown> | undefined;
+        } | undefined): void | Promise<void>;
         /**
          * 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): void | Promise<void>;
+        handleChainEnd?(outputs: ChainValues, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined, kwargs?: {
+            inputs?: Record<string, unknown> | undefined;
+        } | undefined): void | Promise<void>;
         /**
          * Called at the start of a Tool run, with the tool name and input
          * and the run ID.

package/dist/callbacks/handlers/run_collector.cjs

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunCollectorCallbackHandler = void 0;
+const tracer_js_1 = require("./tracer.cjs");
+/**
+ * A callback handler that collects traced runs and makes it easy to fetch the traced run object from calls through any langchain object.
+ * For instance, it makes it easy to fetch the run ID and then do things with that, such as log feedback.
+ */
+class RunCollectorCallbackHandler extends tracer_js_1.BaseTracer {
+    /**
+     * Creates a new instance of the RunCollectorCallbackHandler class.
+     * @param exampleId The ID of the example.
+     */
+    constructor({ exampleId } = {}) {
+        super();
+        /** The name of the callback handler. */
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "run_collector"
+        });
+        /** The ID of the example. */
+        Object.defineProperty(this, "exampleId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** An array of traced runs. */
+        Object.defineProperty(this, "tracedRuns", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.exampleId = exampleId;
+        this.tracedRuns = [];
+    }
+    /**
+     * Persists the given run object.
+     * @param run The run object to persist.
+     */
+    async persistRun(run) {
+        const run_ = { ...run };
+        run_.reference_example_id = this.exampleId;
+        this.tracedRuns.push(run_);
+    }
+}
+exports.RunCollectorCallbackHandler = RunCollectorCallbackHandler;

package/dist/callbacks/handlers/run_collector.d.ts

@@ -0,0 +1,26 @@
+import { BaseRun, Run } from "langsmith/schemas";
+import { BaseTracer } from "./tracer.js";
+/**
+ * A callback handler that collects traced runs and makes it easy to fetch the traced run object from calls through any langchain object.
+ * For instance, it makes it easy to fetch the run ID and then do things with that, such as log feedback.
+ */
+export declare class RunCollectorCallbackHandler extends BaseTracer {
+    /** The name of the callback handler. */
+    name: string;
+    /** The ID of the example. */
+    exampleId?: string;
+    /** An array of traced runs. */
+    tracedRuns: Run[];
+    /**
+     * Creates a new instance of the RunCollectorCallbackHandler class.
+     * @param exampleId The ID of the example.
+     */
+    constructor({ exampleId }?: {
+        exampleId?: string;
+    });
+    /**
+     * Persists the given run object.
+     * @param run The run object to persist.
+     */
+    protected persistRun(run: BaseRun): Promise<void>;
+}

package/dist/callbacks/handlers/run_collector.js

@@ -0,0 +1,46 @@
+import { BaseTracer } from "./tracer.js";
+/**
+ * A callback handler that collects traced runs and makes it easy to fetch the traced run object from calls through any langchain object.
+ * For instance, it makes it easy to fetch the run ID and then do things with that, such as log feedback.
+ */
+export class RunCollectorCallbackHandler extends BaseTracer {
+    /**
+     * Creates a new instance of the RunCollectorCallbackHandler class.
+     * @param exampleId The ID of the example.
+     */
+    constructor({ exampleId } = {}) {
+        super();
+        /** The name of the callback handler. */
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "run_collector"
+        });
+        /** The ID of the example. */
+        Object.defineProperty(this, "exampleId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** An array of traced runs. */
+        Object.defineProperty(this, "tracedRuns", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.exampleId = exampleId;
+        this.tracedRuns = [];
+    }
+    /**
+     * Persists the given run object.
+     * @param run The run object to persist.
+     */
+    async persistRun(run) {
+        const run_ = { ...run };
+        run_.reference_example_id = this.exampleId;
+        this.tracedRuns.push(run_);
+    }
+}

package/dist/callbacks/handlers/tracer.cjs

@@ -2,6 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseTracer = void 0;
 const base_js_1 = require("../base.cjs");
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function _coerceToDict(value, defaultKey) {
+    return value && !Array.isArray(value) && typeof value === "object"
+        ? value
+        : { [defaultKey]: value };
+}
 class BaseTracer extends base_js_1.BaseCallbackHandler {
     constructor(_fields) {
         super(...arguments);
@@ -23,6 +29,7 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
             const parentRun = this.runMap.get(run.parent_run_id);
             if (parentRun) {
                 this._addChildRun(parentRun, run);
+                parentRun.child_execution_order = Math.max(parentRun.child_execution_order, run.child_execution_order);
             }
         }
         this.runMap.set(run.id, run);
@@ -157,21 +164,24 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
         this._startTrace(run);
         await this.onChainStart?.(run);
     }
-    async handleChainEnd(outputs, runId) {
+    async handleChainEnd(outputs, runId, _parentRunId, _tags, kwargs) {
         const run = this.runMap.get(runId);
         if (!run) {
             throw new Error("No chain run to end.");
         }
         run.end_time = Date.now();
-        run.outputs = outputs;
+        run.outputs = _coerceToDict(outputs, "output");
         run.events.push({
             name: "end",
             time: new Date(run.end_time).toISOString(),
         });
+        if (kwargs?.inputs !== undefined) {
+            run.inputs = _coerceToDict(kwargs.inputs, "input");
+        }
         await this.onChainEnd?.(run);
         await this._endTrace(run);
     }
-    async handleChainError(error, runId) {
+    async handleChainError(error, runId, _parentRunId, _tags, kwargs) {
         const run = this.runMap.get(runId);
         if (!run) {
             throw new Error("No chain run to end.");
@@ -182,6 +192,9 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
             name: "error",
             time: new Date(run.end_time).toISOString(),
         });
+        if (kwargs?.inputs !== undefined) {
+            run.inputs = _coerceToDict(kwargs.inputs, "input");
+        }
         await this.onChainError?.(run);
         await this._endTrace(run);
     }

package/dist/callbacks/handlers/tracer.d.ts

@@ -33,8 +33,12 @@ export declare abstract class BaseTracer extends BaseCallbackHandler {
     handleLLMEnd(output: LLMResult, runId: string): Promise<void>;
     handleLLMError(error: Error, runId: string): Promise<void>;
     handleChainStart(chain: Serialized, inputs: ChainValues, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, runType?: string): Promise<void>;
-    handleChainEnd(outputs: ChainValues, runId: string): Promise<void>;
-    handleChainError(error: Error, runId: string): Promise<void>;
+    handleChainEnd(outputs: ChainValues, runId: string, _parentRunId?: string, _tags?: string[], kwargs?: {
+        inputs?: Record<string, unknown>;
+    }): Promise<void>;
+    handleChainError(error: Error, runId: string, _parentRunId?: string, _tags?: string[], kwargs?: {
+        inputs?: Record<string, unknown>;
+    }): Promise<void>;
     handleToolStart(tool: Serialized, input: string, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap): Promise<void>;
     handleToolEnd(output: string, runId: string): Promise<void>;
     handleToolError(error: Error, runId: string): Promise<void>;