langchain 0.0.74 → 0.0.75

package/client.cjs

@@ -0,0 +1 @@
+module.exports = require('./dist/client/index.cjs');

package/client.d.ts

@@ -0,0 +1 @@
+export * from './dist/client/index.js'

package/client.js

@@ -0,0 +1 @@
+export * from './dist/client/index.js'

package/dist/base_language/index.cjs

@@ -33,6 +33,12 @@ exports.BaseLangChain = BaseLangChain;
  * Base class for language models.
  */
 class BaseLanguageModel extends BaseLangChain {
+    /**
+     * Keys that the language model accepts as call options.
+     */
+    get callKeys() {
+        return ["stop", "timeout", "signal"];
+    }
     constructor(params) {
         super({
             verbose: params.verbose,

package/dist/base_language/index.d.ts

@@ -32,19 +32,37 @@ export interface BaseLanguageModelParams extends AsyncCallerParams, BaseLangChai
     callbackManager?: CallbackManager;
 }
 export interface BaseLanguageModelCallOptions {
+    /**
+     * Stop tokens to use for this call.
+     * If not provided, the default stop tokens for the model will be used.
+     */
+    stop?: string[];
+    /**
+     * 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.
+     */
+    signal?: AbortSignal;
 }
 /**
  * Base class for language models.
  */
 export declare abstract class BaseLanguageModel extends BaseLangChain implements BaseLanguageModelParams {
     CallOptions: BaseLanguageModelCallOptions;
+    /**
+     * Keys that the language model accepts as call options.
+     */
+    get callKeys(): string[];
     /**
      * The async caller should be used by subclasses to make any async calls,
      * which will thus benefit from the concurrency and retry logic.
      */
     caller: AsyncCaller;
     constructor(params: BaseLanguageModelParams);
-    abstract generatePrompt(promptValues: BasePromptValue[], stop?: string[] | this["CallOptions"], callbacks?: Callbacks): Promise<LLMResult>;
+    abstract generatePrompt(promptValues: BasePromptValue[], options?: string[] | this["CallOptions"], callbacks?: Callbacks): Promise<LLMResult>;
     abstract _modelType(): string;
     abstract _llmType(): string;
     private _encoding?;

package/dist/base_language/index.js

@@ -29,6 +29,12 @@ export class BaseLangChain {
  * Base class for language models.
  */
 export class BaseLanguageModel extends BaseLangChain {
+    /**
+     * Keys that the language model accepts as call options.
+     */
+    get callKeys() {
+        return ["stop", "timeout", "signal"];
+    }
     constructor(params) {
         super({
             verbose: params.verbose,

package/dist/callbacks/base.d.ts

@@ -1,4 +1,4 @@
-import { AgentAction, AgentFinish, ChainValues, LLMResult } from "../schema/index.js";
+import { AgentAction, AgentFinish, BaseChatMessage, ChainValues, LLMResult } from "../schema/index.js";
 type Error = any;
 export interface BaseCallbackHandlerInput {
     ignoreLLM?: boolean;
@@ -25,6 +25,13 @@ declare abstract class BaseCallbackHandlerMethodsClass {
      * Called at the end of an LLM/ChatModel run, with the output and the run ID.
      */
     handleLLMEnd?(output: LLMResult, runId: string, parentRunId?: string): Promise<void> | void;
+    /**
+     * Called at the start of a Chat Model run, with the prompt(s)
+     * and the run ID.
+     */
+    handleChatModelStart?(llm: {
+        name: string;
+    }, messages: BaseChatMessage[][], runId: string, parentRunId?: string): Promise<void> | void;
     /**
      * Called at the start of a Chain run, with the chain name and inputs
      * and the run ID.
@@ -109,6 +116,13 @@ export declare abstract class BaseCallbackHandler extends BaseCallbackHandlerMet
          * Called at the end of an LLM/ChatModel run, with the output and the run ID.
          */
         handleLLMEnd?(output: LLMResult, runId: string, parentRunId?: string | undefined): void | Promise<void>;
+        /**
+         * Called at the start of a Chat Model run, with the prompt(s)
+         * and the run ID.
+         */
+        handleChatModelStart?(llm: {
+            name: string;
+        }, messages: BaseChatMessage[][], runId: string, parentRunId?: string | undefined): void | Promise<void>;
         /**
          * Called at the start of a Chain run, with the chain name and inputs
          * and the run ID.

package/dist/callbacks/handlers/console.cjs

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConsoleCallbackHandler = void 0;
 const ansi_styles_1 = __importDefault(require("ansi-styles"));
-const tracers_js_1 = require("./tracers.cjs");
+const tracer_js_1 = require("./tracer.cjs");
 function wrap(style, text) {
     return `${style.open}${text}${style.close}`;
 }
@@ -25,42 +25,25 @@ function elapsed(run) {
     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
+class ConsoleCallbackHandler extends tracer_js_1.BaseTracer {
     constructor() {
-        super();
+        super(...arguments);
         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);
+        while (currentRun.parent_run_id) {
+            const parent = this.runMap.get(currentRun.parent_run_id);
             if (parent) {
                 parents.push(parent);
                 currentRun = parent;
@@ -75,7 +58,7 @@ class ConsoleCallbackHandler extends tracers_js_1.BaseTracer {
         const parents = this.getParents(run).reverse();
         const string = [...parents, run]
             .map((parent, i, arr) => {
-            const name = `${parent.execution_order}:${parent.type}:${parent.serialized?.name}`;
+            const name = `${parent.execution_order}:${parent.run_type}:${parent.name}`;
             return i === arr.length - 1 ? wrap(ansi_styles_1.default.bold, name) : name;
         })
             .join(" > ");
@@ -96,11 +79,14 @@ class ConsoleCallbackHandler extends tracers_js_1.BaseTracer {
     }
     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]")}`);
+        const inputs = "prompts" in run.inputs
+            ? { prompts: run.inputs.prompts.map((p) => p.trim()) }
+            : run.inputs;
+        console.log(`${wrap(color.green, "[llm/start]")} [${crumbs}] Entering LLM run with input: ${tryJsonStringify(inputs, "[inputs]")}`);
     }
     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]")}`);
+        console.log(`${wrap(color.cyan, "[llm/end]")} [${crumbs}] [${elapsed(run)}] Exiting LLM run with output: ${tryJsonStringify(run.outputs, "[response]")}`);
     }
     onLLMError(run) {
         const crumbs = this.getBreadcrumbs(run);
@@ -108,19 +94,20 @@ class ConsoleCallbackHandler extends tracers_js_1.BaseTracer {
     }
     onToolStart(run) {
         const crumbs = this.getBreadcrumbs(run);
-        console.log(`${wrap(color.green, "[tool/start]")} [${crumbs}] Entering Tool run with input: "${run.tool_input?.trim()}"`);
+        console.log(`${wrap(color.green, "[tool/start]")} [${crumbs}] Entering Tool run with input: "${run.inputs.input?.trim()}"`);
     }
     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()}"`);
+        console.log(`${wrap(color.cyan, "[tool/end]")} [${crumbs}] [${elapsed(run)}] Exiting Tool run with output: "${run.outputs?.output?.trim()}"`);
     }
     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]")}`);
     }
     onAgentAction(run) {
+        const agentRun = 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]")}`);
+        console.log(`${wrap(color.blue, "[agent/action]")} [${crumbs}] Agent selected action: ${tryJsonStringify(agentRun.actions[agentRun.actions.length - 1], "[action]")}`);
     }
 }
 exports.ConsoleCallbackHandler = ConsoleCallbackHandler;

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

@@ -1,26 +1,17 @@
-import { AgentRun, BaseTracer, BaseTracerSession, ChainRun, LLMRun, Run, ToolRun } from "./tracers.js";
+import { BaseTracer, Run } from "./tracer.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;
+    onChainStart(run: Run): void;
+    onChainEnd(run: Run): void;
+    onChainError(run: Run): void;
+    onLLMStart(run: Run): void;
+    onLLMEnd(run: Run): void;
+    onLLMError(run: Run): void;
+    onToolStart(run: Run): void;
+    onToolEnd(run: Run): void;
+    onToolError(run: Run): void;
+    onAgentAction(run: Run): void;
 }

package/dist/callbacks/handlers/console.js

@@ -1,5 +1,5 @@
 import styles from "ansi-styles";
-import { BaseTracer, } from "./tracers.js";
+import { BaseTracer } from "./tracer.js";
 function wrap(style, text) {
     return `${style.open}${text}${style.close}`;
 }
@@ -20,41 +20,24 @@ function elapsed(run) {
 }
 const { color } = styles;
 export class ConsoleCallbackHandler extends BaseTracer {
-    // boilerplate to work with the base tracer class
     constructor() {
-        super();
+        super(...arguments);
         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);
+        while (currentRun.parent_run_id) {
+            const parent = this.runMap.get(currentRun.parent_run_id);
             if (parent) {
                 parents.push(parent);
                 currentRun = parent;
@@ -69,7 +52,7 @@ export class ConsoleCallbackHandler extends BaseTracer {
         const parents = this.getParents(run).reverse();
         const string = [...parents, run]
             .map((parent, i, arr) => {
-            const name = `${parent.execution_order}:${parent.type}:${parent.serialized?.name}`;
+            const name = `${parent.execution_order}:${parent.run_type}:${parent.name}`;
             return i === arr.length - 1 ? wrap(styles.bold, name) : name;
         })
             .join(" > ");
@@ -90,11 +73,14 @@ export class ConsoleCallbackHandler extends BaseTracer {
     }
     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]")}`);
+        const inputs = "prompts" in run.inputs
+            ? { prompts: run.inputs.prompts.map((p) => p.trim()) }
+            : run.inputs;
+        console.log(`${wrap(color.green, "[llm/start]")} [${crumbs}] Entering LLM run with input: ${tryJsonStringify(inputs, "[inputs]")}`);
     }
     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]")}`);
+        console.log(`${wrap(color.cyan, "[llm/end]")} [${crumbs}] [${elapsed(run)}] Exiting LLM run with output: ${tryJsonStringify(run.outputs, "[response]")}`);
     }
     onLLMError(run) {
         const crumbs = this.getBreadcrumbs(run);
@@ -102,18 +88,19 @@ export class ConsoleCallbackHandler extends BaseTracer {
     }
     onToolStart(run) {
         const crumbs = this.getBreadcrumbs(run);
-        console.log(`${wrap(color.green, "[tool/start]")} [${crumbs}] Entering Tool run with input: "${run.tool_input?.trim()}"`);
+        console.log(`${wrap(color.green, "[tool/start]")} [${crumbs}] Entering Tool run with input: "${run.inputs.input?.trim()}"`);
     }
     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()}"`);
+        console.log(`${wrap(color.cyan, "[tool/end]")} [${crumbs}] [${elapsed(run)}] Exiting Tool run with output: "${run.outputs?.output?.trim()}"`);
     }
     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]")}`);
     }
     onAgentAction(run) {
+        const agentRun = 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]")}`);
+        console.log(`${wrap(color.blue, "[agent/action]")} [${crumbs}] Agent selected action: ${tryJsonStringify(agentRun.actions[agentRun.actions.length - 1], "[action]")}`);
     }
 }

package/dist/callbacks/handlers/initialize.cjs

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTracingCallbackHandler = void 0;
-const tracers_js_1 = require("./tracers.cjs");
+exports.getTracingV2CallbackHandler = exports.getTracingCallbackHandler = void 0;
+const tracer_langchain_js_1 = require("./tracer_langchain.cjs");
+const tracer_langchain_v1_js_1 = require("./tracer_langchain_v1.cjs");
 async function getTracingCallbackHandler(session) {
-    const tracer = new tracers_js_1.LangChainTracer();
+    const tracer = new tracer_langchain_v1_js_1.LangChainTracerV1();
     if (session) {
         await tracer.loadSession(session);
     }
@@ -13,3 +14,14 @@ async function getTracingCallbackHandler(session) {
     return tracer;
 }
 exports.getTracingCallbackHandler = getTracingCallbackHandler;
+async function getTracingV2CallbackHandler(session) {
+    const tracer = new tracer_langchain_js_1.LangChainTracer();
+    if (session) {
+        await tracer.loadSession(session);
+    }
+    else {
+        await tracer.loadDefaultSession();
+    }
+    return tracer;
+}
+exports.getTracingV2CallbackHandler = getTracingV2CallbackHandler;

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

@@ -1,2 +1,4 @@
-import { LangChainTracer } from "./tracers.js";
-export declare function getTracingCallbackHandler(session?: string): Promise<LangChainTracer>;
+import { LangChainTracer } from "./tracer_langchain.js";
+import { LangChainTracerV1 } from "./tracer_langchain_v1.js";
+export declare function getTracingCallbackHandler(session?: string): Promise<LangChainTracerV1>;
+export declare function getTracingV2CallbackHandler(session?: string): Promise<LangChainTracer>;

package/dist/callbacks/handlers/initialize.js

@@ -1,5 +1,16 @@
-import { LangChainTracer } from "./tracers.js";
+import { LangChainTracer } from "./tracer_langchain.js";
+import { LangChainTracerV1 } from "./tracer_langchain_v1.js";
 export async function getTracingCallbackHandler(session) {
+    const tracer = new LangChainTracerV1();
+    if (session) {
+        await tracer.loadSession(session);
+    }
+    else {
+        await tracer.loadDefaultSession();
+    }
+    return tracer;
+}
+export async function getTracingV2CallbackHandler(session) {
     const tracer = new LangChainTracer();
     if (session) {
         await tracer.loadSession(session);

package/dist/callbacks/handlers/tracer.cjs

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseTracer = void 0;
+const base_js_1 = require("../base.cjs");
+class BaseTracer extends base_js_1.BaseCallbackHandler {
+    constructor() {
+        super();
+        Object.defineProperty(this, "runMap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+    }
+    copy() {
+        return this;
+    }
+    _addChildRun(parentRun, childRun) {
+        parentRun.child_runs.push(childRun);
+    }
+    _startTrace(run) {
+        if (run.parent_run_id !== undefined) {
+            const parentRun = this.runMap.get(run.parent_run_id);
+            if (parentRun) {
+                this._addChildRun(parentRun, run);
+            }
+            else {
+                throw new Error(`Caller run ${run.parent_run_id} not found`);
+            }
+        }
+        this.runMap.set(run.id, run);
+    }
+    async _endTrace(run) {
+        if (!run.parent_run_id) {
+            await this.persistRun(run);
+        }
+        else {
+            const parentRun = this.runMap.get(run.parent_run_id);
+            if (parentRun === undefined) {
+                throw new Error(`Parent run ${run.parent_run_id} not found`);
+            }
+            parentRun.child_execution_order = Math.max(parentRun.child_execution_order, run.child_execution_order);
+        }
+        this.runMap.delete(run.id);
+    }
+    _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) {
+        const execution_order = this._getExecutionOrder(parentRunId);
+        const run = {
+            id: runId,
+            name: llm.name,
+            parent_run_id: parentRunId,
+            start_time: Date.now(),
+            end_time: 0,
+            serialized: llm,
+            inputs: { prompts },
+            execution_order,
+            child_runs: [],
+            child_execution_order: execution_order,
+            run_type: "llm",
+        };
+        this._startTrace(run);
+        await this.onLLMStart?.(run);
+    }
+    async handleChatModelStart(llm, messages, runId, parentRunId) {
+        const execution_order = this._getExecutionOrder(parentRunId);
+        const convertedMessages = messages.map((batch) => batch.map((message) => ({
+            _type: message._getType(),
+            content: message.text, // TODO: Unify serialization btwn languages
+        })));
+        const run = {
+            id: runId,
+            name: llm.name,
+            parent_run_id: parentRunId,
+            start_time: Date.now(),
+            end_time: 0,
+            serialized: llm,
+            inputs: { messages: convertedMessages },
+            execution_order,
+            child_runs: [],
+            child_execution_order: execution_order,
+            run_type: "llm",
+        };
+        this._startTrace(run);
+        await this.onLLMStart?.(run);
+    }
+    async handleLLMEnd(output, runId) {
+        const run = this.runMap.get(runId);
+        if (!run || run?.run_type !== "llm") {
+            throw new Error("No LLM run to end.");
+        }
+        run.end_time = Date.now();
+        run.outputs = output;
+        await this.onLLMEnd?.(run);
+        await this._endTrace(run);
+    }
+    async handleLLMError(error, runId) {
+        const run = this.runMap.get(runId);
+        if (!run || run?.run_type !== "llm") {
+            throw new Error("No LLM run to end.");
+        }
+        run.end_time = Date.now();
+        run.error = error.message;
+        await this.onLLMError?.(run);
+        await this._endTrace(run);
+    }
+    async handleChainStart(chain, inputs, runId, parentRunId) {
+        const execution_order = this._getExecutionOrder(parentRunId);
+        const run = {
+            id: runId,
+            name: chain.name,
+            parent_run_id: parentRunId,
+            start_time: Date.now(),
+            end_time: 0,
+            serialized: chain,
+            inputs,
+            execution_order,
+            child_execution_order: execution_order,
+            run_type: "chain",
+            child_runs: [],
+        };
+        this._startTrace(run);
+        await this.onChainStart?.(run);
+    }
+    async handleChainEnd(outputs, runId) {
+        const run = this.runMap.get(runId);
+        if (!run || run?.run_type !== "chain") {
+            throw new Error("No chain run to end.");
+        }
+        run.end_time = Date.now();
+        run.outputs = outputs;
+        await this.onChainEnd?.(run);
+        await this._endTrace(run);
+    }
+    async handleChainError(error, runId) {
+        const run = this.runMap.get(runId);
+        if (!run || run?.run_type !== "chain") {
+            throw new Error("No chain run to end.");
+        }
+        run.end_time = Date.now();
+        run.error = error.message;
+        await this.onChainError?.(run);
+        await this._endTrace(run);
+    }
+    async handleToolStart(tool, input, runId, parentRunId) {
+        const execution_order = this._getExecutionOrder(parentRunId);
+        const run = {
+            id: runId,
+            name: tool.name,
+            parent_run_id: parentRunId,
+            start_time: Date.now(),
+            end_time: 0,
+            serialized: tool,
+            inputs: { input },
+            execution_order,
+            child_execution_order: execution_order,
+            run_type: "tool",
+            child_runs: [],
+        };
+        this._startTrace(run);
+        await this.onToolStart?.(run);
+    }
+    async handleToolEnd(output, runId) {
+        const run = this.runMap.get(runId);
+        if (!run || run?.run_type !== "tool") {
+            throw new Error("No tool run to end");
+        }
+        run.end_time = Date.now();
+        run.outputs = { output };
+        await this.onToolEnd?.(run);
+        await this._endTrace(run);
+    }
+    async handleToolError(error, runId) {
+        const run = this.runMap.get(runId);
+        if (!run || run?.run_type !== "tool") {
+            throw new Error("No tool run to end");
+        }
+        run.end_time = Date.now();
+        run.error = error.message;
+        await this.onToolError?.(run);
+        await this._endTrace(run);
+    }
+    async handleAgentAction(action, runId) {
+        const run = this.runMap.get(runId);
+        if (!run || run?.run_type !== "chain") {
+            return;
+        }
+        const agentRun = run;
+        agentRun.actions = agentRun.actions || [];
+        agentRun.actions.push(action);
+        await this.onAgentAction?.(run);
+    }
+}
+exports.BaseTracer = BaseTracer;