langchain 0.0.65 → 0.0.67

package/dist/agents/chat/outputParser.cjs

@@ -6,13 +6,14 @@ const prompt_js_1 = require("./prompt.cjs");
 exports.FINAL_ANSWER_ACTION = "Final Answer:";
 class ChatAgentOutputParser extends types_js_1.AgentActionOutputParser {
     async parse(text) {
-        if (text.includes(exports.FINAL_ANSWER_ACTION)) {
+        if (text.includes(exports.FINAL_ANSWER_ACTION) || !text.includes(`"action":`)) {
             const parts = text.split(exports.FINAL_ANSWER_ACTION);
             const output = parts[parts.length - 1].trim();
             return { returnValues: { output }, log: text };
         }
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        const [_, action, __] = text.split(/```(?:json)?/g);
+        const action = text.includes("```")
+            ? text.trim().split(/```(?:json)?/)[1]
+            : text.trim();
         try {
             const response = JSON.parse(action.trim());
             return {

package/dist/agents/chat/outputParser.js

@@ -3,13 +3,14 @@ import { FORMAT_INSTRUCTIONS } from "./prompt.js";
 export const FINAL_ANSWER_ACTION = "Final Answer:";
 export class ChatAgentOutputParser extends AgentActionOutputParser {
     async parse(text) {
-        if (text.includes(FINAL_ANSWER_ACTION)) {
+        if (text.includes(FINAL_ANSWER_ACTION) || !text.includes(`"action":`)) {
             const parts = text.split(FINAL_ANSWER_ACTION);
             const output = parts[parts.length - 1].trim();
             return { returnValues: { output }, log: text };
         }
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        const [_, action, __] = text.split(/```(?:json)?/g);
+        const action = text.includes("```")
+            ? text.trim().split(/```(?:json)?/)[1]
+            : text.trim();
         try {
             const response = JSON.parse(action.trim());
             return {

package/dist/agents/chat_convo/outputParser.cjs

@@ -9,14 +9,13 @@ class ChatConversationalAgentOutputParser extends types_js_1.AgentActionOutputPa
         if (jsonOutput.includes("```json")) {
             jsonOutput = jsonOutput.split("```json")[1].trimStart();
         }
-        if (jsonOutput.includes("```")) {
-            jsonOutput = jsonOutput.split("```")[0].trimEnd();
+        else if (jsonOutput.includes("```")) {
+            const firstIndex = jsonOutput.indexOf("```");
+            jsonOutput = jsonOutput.slice(firstIndex + 3).trimStart();
         }
-        if (jsonOutput.startsWith("```")) {
-            jsonOutput = jsonOutput.slice(3).trimStart();
-        }
-        if (jsonOutput.endsWith("```")) {
-            jsonOutput = jsonOutput.slice(0, -3).trimEnd();
+        const lastIndex = jsonOutput.lastIndexOf("```");
+        if (lastIndex !== -1) {
+            jsonOutput = jsonOutput.slice(0, lastIndex).trimEnd();
         }
         const response = JSON.parse(jsonOutput);
         const { action, action_input } = response;

package/dist/agents/chat_convo/outputParser.js

@@ -6,14 +6,13 @@ export class ChatConversationalAgentOutputParser extends AgentActionOutputParser
         if (jsonOutput.includes("```json")) {
             jsonOutput = jsonOutput.split("```json")[1].trimStart();
         }
-        if (jsonOutput.includes("```")) {
-            jsonOutput = jsonOutput.split("```")[0].trimEnd();
+        else if (jsonOutput.includes("```")) {
+            const firstIndex = jsonOutput.indexOf("```");
+            jsonOutput = jsonOutput.slice(firstIndex + 3).trimStart();
         }
-        if (jsonOutput.startsWith("```")) {
-            jsonOutput = jsonOutput.slice(3).trimStart();
-        }
-        if (jsonOutput.endsWith("```")) {
-            jsonOutput = jsonOutput.slice(0, -3).trimEnd();
+        const lastIndex = jsonOutput.lastIndexOf("```");
+        if (lastIndex !== -1) {
+            jsonOutput = jsonOutput.slice(0, lastIndex).trimEnd();
         }
         const response = JSON.parse(jsonOutput);
         const { action, action_input } = response;

package/dist/callbacks/handlers/console.cjs

@@ -1,44 +1,126 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConsoleCallbackHandler = void 0;
-const base_js_1 = require("../base.cjs");
-class ConsoleCallbackHandler extends base_js_1.BaseCallbackHandler {
+const ansi_styles_1 = __importDefault(require("ansi-styles"));
+const tracers_js_1 = require("./tracers.cjs");
+function wrap(style, text) {
+    return `${style.open}${text}${style.close}`;
+}
+function tryJsonStringify(obj, fallback) {
+    try {
+        return JSON.stringify(obj, null, 2);
+    }
+    catch (err) {
+        return fallback;
+    }
+}
+function elapsed(run) {
+    const elapsed = run.end_time - run.start_time;
+    if (elapsed < 1000) {
+        return `${elapsed}ms`;
+    }
+    return `${(elapsed / 1000).toFixed(2)}s`;
+}
+const { color } = ansi_styles_1.default;
+class ConsoleCallbackHandler extends tracers_js_1.BaseTracer {
+    // boilerplate to work with the base tracer class
     constructor() {
-        super(...arguments);
+        super();
         Object.defineProperty(this, "name", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: "console_callback_handler"
         });
+        Object.defineProperty(this, "i", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+    }
+    persistSession(session) {
+        // eslint-disable-next-line no-plusplus
+        return Promise.resolve({ ...session, id: this.i++ });
+    }
+    persistRun(_run) {
+        return Promise.resolve();
+    }
+    loadDefaultSession() {
+        return this.newSession();
+    }
+    loadSession(sessionName) {
+        return this.newSession(sessionName);
+    }
+    // utility methods
+    getParents(run) {
+        const parents = [];
+        let currentRun = run;
+        while (currentRun.parent_uuid) {
+            const parent = this.runMap.get(currentRun.parent_uuid);
+            if (parent) {
+                parents.push(parent);
+                currentRun = parent;
+            }
+            else {
+                break;
+            }
+        }
+        return parents;
+    }
+    getBreadcrumbs(run) {
+        const parents = this.getParents(run).reverse();
+        const string = [...parents, run]
+            .map((parent, i, arr) => {
+            const name = `${parent.execution_order}:${parent.type}:${parent.serialized?.name}`;
+            return i === arr.length - 1 ? wrap(ansi_styles_1.default.bold, name) : name;
+        })
+            .join(" > ");
+        return wrap(color.grey, string);
+    }
+    // logging methods
+    onChainStart(run) {
+        const crumbs = this.getBreadcrumbs(run);
+        console.log(`${wrap(color.green, "[chain/start]")} [${crumbs}] Entering Chain run with input: ${tryJsonStringify(run.inputs, "[inputs]")}`);
     }
-    handleLLMStart(llm, prompts, runId) {
-        console.log(`Starting LLM ${runId} with name ${llm.name} with prompts: ${prompts.join(", ")}\n`);
+    onChainEnd(run) {
+        const crumbs = this.getBreadcrumbs(run);
+        console.log(`${wrap(color.cyan, "[chain/end]")} [${crumbs}] [${elapsed(run)}] Exiting Chain run with output: ${tryJsonStringify(run.outputs, "[outputs]")}`);
     }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    handleLLMError(err, runId) {
-        console.log(`LLM ${runId} errored: ${err}\n`);
+    onChainError(run) {
+        const crumbs = this.getBreadcrumbs(run);
+        console.log(`${wrap(color.red, "[chain/error]")} [${crumbs}] [${elapsed(run)}] Chain run errored with error: ${tryJsonStringify(run.error, "[error]")}`);
     }
-    handleLLMEnd(output, runId) {
-        console.log(`LLM ${runId} finished: ${JSON.stringify(output)}\n`);
+    onLLMStart(run) {
+        const crumbs = this.getBreadcrumbs(run);
+        console.log(`${wrap(color.green, "[llm/start]")} [${crumbs}] Entering LLM run with input: ${tryJsonStringify({ prompts: run.prompts.map((p) => p.trim()) }, "[inputs]")}`);
     }
-    handleChainStart(chain) {
-        console.log(`Entering new ${chain.name} chain...`);
+    onLLMEnd(run) {
+        const crumbs = this.getBreadcrumbs(run);
+        console.log(`${wrap(color.cyan, "[llm/end]")} [${crumbs}] [${elapsed(run)}] Exiting LLM run with output: ${tryJsonStringify(run.response, "[response]")}`);
     }
-    handleChainEnd(_output) {
-        console.log("Finished chain.");
+    onLLMError(run) {
+        const crumbs = this.getBreadcrumbs(run);
+        console.log(`${wrap(color.red, "[llm/error]")} [${crumbs}] [${elapsed(run)}] LLM run errored with error: ${tryJsonStringify(run.error, "[error]")}`);
     }
-    handleAgentAction(action) {
-        console.log(action.log);
+    onToolStart(run) {
+        const crumbs = this.getBreadcrumbs(run);
+        console.log(`${wrap(color.green, "[tool/start]")} [${crumbs}] Entering Tool run with input: "${run.tool_input?.trim()}"`);
     }
-    handleToolEnd(output) {
-        console.log(output);
+    onToolEnd(run) {
+        const crumbs = this.getBreadcrumbs(run);
+        console.log(`${wrap(color.cyan, "[tool/end]")} [${crumbs}] [${elapsed(run)}] Exiting Tool run with output: "${run.output?.trim()}"`);
     }
-    handleText(text) {
-        console.log(text);
+    onToolError(run) {
+        const crumbs = this.getBreadcrumbs(run);
+        console.log(`${wrap(color.red, "[tool/error]")} [${crumbs}] [${elapsed(run)}] Tool run errored with error: ${tryJsonStringify(run.error, "[error]")}`);
     }
-    handleAgentEnd(action) {
-        console.log(action.log);
+    onAgentAction(run) {
+        const crumbs = this.getBreadcrumbs(run);
+        console.log(`${wrap(color.blue, "[agent/action]")} [${crumbs}] Agent selected action: ${tryJsonStringify(run.actions[run.actions.length - 1], "[action]")}`);
     }
 }
 exports.ConsoleCallbackHandler = ConsoleCallbackHandler;

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

@@ -1,18 +1,26 @@
-import { AgentAction, AgentFinish, ChainValues, LLMResult } from "../../schema/index.js";
-import { BaseCallbackHandler } from "../base.js";
-export declare class ConsoleCallbackHandler extends BaseCallbackHandler {
-    name: string;
-    handleLLMStart(llm: {
-        name: string;
-    }, prompts: string[], runId: string): void;
-    handleLLMError(err: any, runId: string): void;
-    handleLLMEnd(output: LLMResult, runId: string): void;
-    handleChainStart(chain: {
-        name: string;
-    }): void;
-    handleChainEnd(_output: ChainValues): void;
-    handleAgentAction(action: AgentAction): void;
-    handleToolEnd(output: string): void;
-    handleText(text: string): void;
-    handleAgentEnd(action: AgentFinish): void;
+import { AgentRun, BaseTracer, BaseTracerSession, ChainRun, LLMRun, Run, ToolRun } from "./tracers.js";
+export declare class ConsoleCallbackHandler extends BaseTracer {
+    name: "console_callback_handler";
+    constructor();
+    i: number;
+    protected persistSession(session: BaseTracerSession): Promise<{
+        id: number;
+        start_time: number;
+        name?: string | undefined;
+    }>;
+    protected persistRun(_run: Run): Promise<void>;
+    loadDefaultSession(): Promise<import("./tracers.js").TracerSession>;
+    loadSession(sessionName: string): Promise<import("./tracers.js").TracerSession>;
+    getParents(run: Run): Run[];
+    getBreadcrumbs(run: Run): string;
+    onChainStart(run: ChainRun): void;
+    onChainEnd(run: ChainRun): void;
+    onChainError(run: ChainRun): void;
+    onLLMStart(run: LLMRun): void;
+    onLLMEnd(run: LLMRun): void;
+    onLLMError(run: LLMRun): void;
+    onToolStart(run: ToolRun): void;
+    onToolEnd(run: ToolRun): void;
+    onToolError(run: ToolRun): void;
+    onAgentAction(run: AgentRun): void;
 }

package/dist/callbacks/handlers/console.js

@@ -1,40 +1,119 @@
-import { BaseCallbackHandler } from "../base.js";
-export class ConsoleCallbackHandler extends BaseCallbackHandler {
+import styles from "ansi-styles";
+import { BaseTracer, } from "./tracers.js";
+function wrap(style, text) {
+    return `${style.open}${text}${style.close}`;
+}
+function tryJsonStringify(obj, fallback) {
+    try {
+        return JSON.stringify(obj, null, 2);
+    }
+    catch (err) {
+        return fallback;
+    }
+}
+function elapsed(run) {
+    const elapsed = run.end_time - run.start_time;
+    if (elapsed < 1000) {
+        return `${elapsed}ms`;
+    }
+    return `${(elapsed / 1000).toFixed(2)}s`;
+}
+const { color } = styles;
+export class ConsoleCallbackHandler extends BaseTracer {
+    // boilerplate to work with the base tracer class
     constructor() {
-        super(...arguments);
+        super();
         Object.defineProperty(this, "name", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: "console_callback_handler"
         });
+        Object.defineProperty(this, "i", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+    }
+    persistSession(session) {
+        // eslint-disable-next-line no-plusplus
+        return Promise.resolve({ ...session, id: this.i++ });
+    }
+    persistRun(_run) {
+        return Promise.resolve();
+    }
+    loadDefaultSession() {
+        return this.newSession();
+    }
+    loadSession(sessionName) {
+        return this.newSession(sessionName);
+    }
+    // utility methods
+    getParents(run) {
+        const parents = [];
+        let currentRun = run;
+        while (currentRun.parent_uuid) {
+            const parent = this.runMap.get(currentRun.parent_uuid);
+            if (parent) {
+                parents.push(parent);
+                currentRun = parent;
+            }
+            else {
+                break;
+            }
+        }
+        return parents;
+    }
+    getBreadcrumbs(run) {
+        const parents = this.getParents(run).reverse();
+        const string = [...parents, run]
+            .map((parent, i, arr) => {
+            const name = `${parent.execution_order}:${parent.type}:${parent.serialized?.name}`;
+            return i === arr.length - 1 ? wrap(styles.bold, name) : name;
+        })
+            .join(" > ");
+        return wrap(color.grey, string);
+    }
+    // logging methods
+    onChainStart(run) {
+        const crumbs = this.getBreadcrumbs(run);
+        console.log(`${wrap(color.green, "[chain/start]")} [${crumbs}] Entering Chain run with input: ${tryJsonStringify(run.inputs, "[inputs]")}`);
     }
-    handleLLMStart(llm, prompts, runId) {
-        console.log(`Starting LLM ${runId} with name ${llm.name} with prompts: ${prompts.join(", ")}\n`);
+    onChainEnd(run) {
+        const crumbs = this.getBreadcrumbs(run);
+        console.log(`${wrap(color.cyan, "[chain/end]")} [${crumbs}] [${elapsed(run)}] Exiting Chain run with output: ${tryJsonStringify(run.outputs, "[outputs]")}`);
     }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    handleLLMError(err, runId) {
-        console.log(`LLM ${runId} errored: ${err}\n`);
+    onChainError(run) {
+        const crumbs = this.getBreadcrumbs(run);
+        console.log(`${wrap(color.red, "[chain/error]")} [${crumbs}] [${elapsed(run)}] Chain run errored with error: ${tryJsonStringify(run.error, "[error]")}`);
     }
-    handleLLMEnd(output, runId) {
-        console.log(`LLM ${runId} finished: ${JSON.stringify(output)}\n`);
+    onLLMStart(run) {
+        const crumbs = this.getBreadcrumbs(run);
+        console.log(`${wrap(color.green, "[llm/start]")} [${crumbs}] Entering LLM run with input: ${tryJsonStringify({ prompts: run.prompts.map((p) => p.trim()) }, "[inputs]")}`);
     }
-    handleChainStart(chain) {
-        console.log(`Entering new ${chain.name} chain...`);
+    onLLMEnd(run) {
+        const crumbs = this.getBreadcrumbs(run);
+        console.log(`${wrap(color.cyan, "[llm/end]")} [${crumbs}] [${elapsed(run)}] Exiting LLM run with output: ${tryJsonStringify(run.response, "[response]")}`);
     }
-    handleChainEnd(_output) {
-        console.log("Finished chain.");
+    onLLMError(run) {
+        const crumbs = this.getBreadcrumbs(run);
+        console.log(`${wrap(color.red, "[llm/error]")} [${crumbs}] [${elapsed(run)}] LLM run errored with error: ${tryJsonStringify(run.error, "[error]")}`);
     }
-    handleAgentAction(action) {
-        console.log(action.log);
+    onToolStart(run) {
+        const crumbs = this.getBreadcrumbs(run);
+        console.log(`${wrap(color.green, "[tool/start]")} [${crumbs}] Entering Tool run with input: "${run.tool_input?.trim()}"`);
     }
-    handleToolEnd(output) {
-        console.log(output);
+    onToolEnd(run) {
+        const crumbs = this.getBreadcrumbs(run);
+        console.log(`${wrap(color.cyan, "[tool/end]")} [${crumbs}] [${elapsed(run)}] Exiting Tool run with output: "${run.output?.trim()}"`);
     }
-    handleText(text) {
-        console.log(text);
+    onToolError(run) {
+        const crumbs = this.getBreadcrumbs(run);
+        console.log(`${wrap(color.red, "[tool/error]")} [${crumbs}] [${elapsed(run)}] Tool run errored with error: ${tryJsonStringify(run.error, "[error]")}`);
     }
-    handleAgentEnd(action) {
-        console.log(action.log);
+    onAgentAction(run) {
+        const crumbs = this.getBreadcrumbs(run);
+        console.log(`${wrap(color.blue, "[agent/action]")} [${crumbs}] Agent selected action: ${tryJsonStringify(run.actions[run.actions.length - 1], "[action]")}`);
     }
 }

package/dist/callbacks/handlers/tracers.cjs

@@ -17,12 +17,9 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
             writable: true,
             value: new Map()
         });
-        Object.defineProperty(this, "executionOrder", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 1
-        });
+    }
+    copy() {
+        return this;
     }
     async newSession(sessionName) {
         const sessionCreate = {
@@ -48,7 +45,6 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
         }
     }
     _startTrace(run) {
-        this.executionOrder += 1;
         if (run.parent_uuid) {
             const parentRun = this.runMap.get(run.parent_uuid);
             if (parentRun) {
@@ -68,14 +64,32 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
     async _endTrace(run) {
         if (!run.parent_uuid) {
             await this.persistRun(run);
-            this.executionOrder = 1;
+        }
+        else {
+            const parentRun = this.runMap.get(run.parent_uuid);
+            if (parentRun === undefined) {
+                throw new Error(`Parent run ${run.parent_uuid} not found`);
+            }
+            parentRun.child_execution_order = Math.max(parentRun.child_execution_order, run.child_execution_order);
         }
         this.runMap.delete(run.uuid);
     }
+    _getExecutionOrder(parentRunId) {
+        // If a run has no parent then execution order is 1
+        if (parentRunId === undefined) {
+            return 1;
+        }
+        const parentRun = this.runMap.get(parentRunId);
+        if (parentRun === undefined) {
+            throw new Error(`Parent run ${parentRunId} not found`);
+        }
+        return parentRun.child_execution_order + 1;
+    }
     async handleLLMStart(llm, prompts, runId, parentRunId) {
         if (this.session === undefined) {
             this.session = await this.loadDefaultSession();
         }
+        const execution_order = this._getExecutionOrder(parentRunId);
         const run = {
             uuid: runId,
             parent_uuid: parentRunId,
@@ -84,10 +98,12 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
             serialized: llm,
             prompts,
             session_id: this.session.id,
-            execution_order: this.executionOrder,
+            execution_order,
+            child_execution_order: execution_order,
             type: "llm",
         };
         this._startTrace(run);
+        await this.onLLMStart?.(run);
     }
     async handleLLMEnd(output, runId) {
         const run = this.runMap.get(runId);
@@ -97,6 +113,7 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
         const llmRun = run;
         llmRun.end_time = Date.now();
         llmRun.response = output;
+        await this.onLLMEnd?.(llmRun);
         await this._endTrace(llmRun);
     }
     async handleLLMError(error, runId) {
@@ -107,12 +124,14 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
         const llmRun = run;
         llmRun.end_time = Date.now();
         llmRun.error = error.message;
+        await this.onLLMError?.(llmRun);
         await this._endTrace(llmRun);
     }
     async handleChainStart(chain, inputs, runId, parentRunId) {
         if (this.session === undefined) {
             this.session = await this.loadDefaultSession();
         }
+        const execution_order = this._getExecutionOrder(parentRunId);
         const run = {
             uuid: runId,
             parent_uuid: parentRunId,
@@ -121,13 +140,15 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
             serialized: chain,
             inputs,
             session_id: this.session.id,
-            execution_order: this.executionOrder,
+            execution_order,
+            child_execution_order: execution_order,
             type: "chain",
             child_llm_runs: [],
             child_chain_runs: [],
             child_tool_runs: [],
         };
         this._startTrace(run);
+        await this.onChainStart?.(run);
     }
     async handleChainEnd(outputs, runId) {
         const run = this.runMap.get(runId);
@@ -137,6 +158,7 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
         const chainRun = run;
         chainRun.end_time = Date.now();
         chainRun.outputs = outputs;
+        await this.onChainEnd?.(chainRun);
         await this._endTrace(chainRun);
     }
     async handleChainError(error, runId) {
@@ -147,12 +169,14 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
         const chainRun = run;
         chainRun.end_time = Date.now();
         chainRun.error = error.message;
+        await this.onChainError?.(chainRun);
         await this._endTrace(chainRun);
     }
     async handleToolStart(tool, input, runId, parentRunId) {
         if (this.session === undefined) {
             this.session = await this.loadDefaultSession();
         }
+        const execution_order = this._getExecutionOrder(parentRunId);
         const run = {
             uuid: runId,
             parent_uuid: parentRunId,
@@ -161,7 +185,8 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
             serialized: tool,
             tool_input: input,
             session_id: this.session.id,
-            execution_order: this.executionOrder,
+            execution_order,
+            child_execution_order: execution_order,
             type: "tool",
             action: JSON.stringify(tool),
             child_llm_runs: [],
@@ -169,6 +194,7 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
             child_tool_runs: [],
         };
         this._startTrace(run);
+        await this.onToolStart?.(run);
     }
     async handleToolEnd(output, runId) {
         const run = this.runMap.get(runId);
@@ -178,6 +204,7 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
         const toolRun = run;
         toolRun.end_time = Date.now();
         toolRun.output = output;
+        await this.onToolEnd?.(toolRun);
         await this._endTrace(toolRun);
     }
     async handleToolError(error, runId) {
@@ -188,8 +215,19 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
         const toolRun = run;
         toolRun.end_time = Date.now();
         toolRun.error = error.message;
+        await this.onToolError?.(toolRun);
         await this._endTrace(toolRun);
     }
+    async handleAgentAction(action, runId) {
+        const run = this.runMap.get(runId);
+        if (!run || run?.type !== "chain") {
+            return;
+        }
+        const agentRun = run;
+        agentRun.actions = agentRun.actions || [];
+        agentRun.actions.push(action);
+        await this.onAgentAction?.(run);
+    }
 }
 exports.BaseTracer = BaseTracer;
 class LangChainTracer extends BaseTracer {
@@ -299,17 +337,5 @@ class LangChainTracer extends BaseTracer {
         this.session = tracerSession;
         return tracerSession;
     }
-    copy() {
-        // TODO: this is a hack to get tracing to work with the current backend
-        // we need to not use execution order, then remove this check
-        if (this.executionOrder === 1) {
-            const copy = new LangChainTracer();
-            copy.session = this.session;
-            copy.runMap = new Map(this.runMap);
-            copy.executionOrder = this.executionOrder;
-            return copy;
-        }
-        return this;
-    }
 }
 exports.LangChainTracer = LangChainTracer;