langchain 0.0.195 → 0.0.196

package/dist/callbacks/handlers/tracer.cjs

@@ -1,377 +1,17 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 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);
-        Object.defineProperty(this, "runMap", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Map()
-        });
-    }
-    copy() {
-        return this;
-    }
-    _addChildRun(parentRun, childRun) {
-        parentRun.child_runs.push(childRun);
-    }
-    async _startTrace(run) {
-        if (run.parent_run_id !== undefined) {
-            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);
-        await this.onRunCreate?.(run);
-    }
-    async _endTrace(run) {
-        const parentRun = run.parent_run_id !== undefined && this.runMap.get(run.parent_run_id);
-        if (parentRun) {
-            parentRun.child_execution_order = Math.max(parentRun.child_execution_order, run.child_execution_order);
-        }
-        else {
-            await this.persistRun(run);
-        }
-        this.runMap.delete(run.id);
-        await this.onRunUpdate?.(run);
-    }
-    _getExecutionOrder(parentRunId) {
-        const parentRun = parentRunId !== undefined && this.runMap.get(parentRunId);
-        // If a run has no parent then execution order is 1
-        if (!parentRun) {
-            return 1;
-        }
-        return parentRun.child_execution_order + 1;
-    }
-    async handleLLMStart(llm, prompts, runId, parentRunId, extraParams, tags, metadata, name) {
-        const execution_order = this._getExecutionOrder(parentRunId);
-        const start_time = Date.now();
-        const finalExtraParams = metadata
-            ? { ...extraParams, metadata }
-            : extraParams;
-        const run = {
-            id: runId,
-            name: name ?? llm.id[llm.id.length - 1],
-            parent_run_id: parentRunId,
-            start_time,
-            serialized: llm,
-            events: [
-                {
-                    name: "start",
-                    time: new Date(start_time).toISOString(),
-                },
-            ],
-            inputs: { prompts },
-            execution_order,
-            child_runs: [],
-            child_execution_order: execution_order,
-            run_type: "llm",
-            extra: finalExtraParams ?? {},
-            tags: tags || [],
-        };
-        await this._startTrace(run);
-        await this.onLLMStart?.(run);
-        return run;
-    }
-    async handleChatModelStart(llm, messages, runId, parentRunId, extraParams, tags, metadata, name) {
-        const execution_order = this._getExecutionOrder(parentRunId);
-        const start_time = Date.now();
-        const finalExtraParams = metadata
-            ? { ...extraParams, metadata }
-            : extraParams;
-        const run = {
-            id: runId,
-            name: name ?? llm.id[llm.id.length - 1],
-            parent_run_id: parentRunId,
-            start_time,
-            serialized: llm,
-            events: [
-                {
-                    name: "start",
-                    time: new Date(start_time).toISOString(),
-                },
-            ],
-            inputs: { messages },
-            execution_order,
-            child_runs: [],
-            child_execution_order: execution_order,
-            run_type: "llm",
-            extra: finalExtraParams ?? {},
-            tags: tags || [],
-        };
-        await this._startTrace(run);
-        await this.onLLMStart?.(run);
-        return 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;
-        run.events.push({
-            name: "end",
-            time: new Date(run.end_time).toISOString(),
-        });
-        await this.onLLMEnd?.(run);
-        await this._endTrace(run);
-        return 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;
-        run.events.push({
-            name: "error",
-            time: new Date(run.end_time).toISOString(),
-        });
-        await this.onLLMError?.(run);
-        await this._endTrace(run);
-        return run;
-    }
-    async handleChainStart(chain, inputs, runId, parentRunId, tags, metadata, runType, name) {
-        const execution_order = this._getExecutionOrder(parentRunId);
-        const start_time = Date.now();
-        const run = {
-            id: runId,
-            name: name ?? chain.id[chain.id.length - 1],
-            parent_run_id: parentRunId,
-            start_time,
-            serialized: chain,
-            events: [
-                {
-                    name: "start",
-                    time: new Date(start_time).toISOString(),
-                },
-            ],
-            inputs,
-            execution_order,
-            child_execution_order: execution_order,
-            run_type: runType ?? "chain",
-            child_runs: [],
-            extra: metadata ? { metadata } : {},
-            tags: tags || [],
-        };
-        await this._startTrace(run);
-        await this.onChainStart?.(run);
-        return run;
-    }
-    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 = _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);
-        return run;
-    }
-    async handleChainError(error, 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.error = error.message;
-        run.events.push({
-            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);
-        return run;
-    }
-    async handleToolStart(tool, input, runId, parentRunId, tags, metadata, name) {
-        const execution_order = this._getExecutionOrder(parentRunId);
-        const start_time = Date.now();
-        const run = {
-            id: runId,
-            name: name ?? tool.id[tool.id.length - 1],
-            parent_run_id: parentRunId,
-            start_time,
-            serialized: tool,
-            events: [
-                {
-                    name: "start",
-                    time: new Date(start_time).toISOString(),
-                },
-            ],
-            inputs: { input },
-            execution_order,
-            child_execution_order: execution_order,
-            run_type: "tool",
-            child_runs: [],
-            extra: metadata ? { metadata } : {},
-            tags: tags || [],
-        };
-        await this._startTrace(run);
-        await this.onToolStart?.(run);
-        return 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 };
-        run.events.push({
-            name: "end",
-            time: new Date(run.end_time).toISOString(),
-        });
-        await this.onToolEnd?.(run);
-        await this._endTrace(run);
-        return 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;
-        run.events.push({
-            name: "error",
-            time: new Date(run.end_time).toISOString(),
-        });
-        await this.onToolError?.(run);
-        await this._endTrace(run);
-        return 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);
-        agentRun.events.push({
-            name: "agent_action",
-            time: new Date().toISOString(),
-            kwargs: { action },
-        });
-        await this.onAgentAction?.(run);
-    }
-    async handleAgentEnd(action, runId) {
-        const run = this.runMap.get(runId);
-        if (!run || run?.run_type !== "chain") {
-            return;
-        }
-        run.events.push({
-            name: "agent_end",
-            time: new Date().toISOString(),
-            kwargs: { action },
-        });
-        await this.onAgentEnd?.(run);
-    }
-    async handleRetrieverStart(retriever, query, runId, parentRunId, tags, metadata, name) {
-        const execution_order = this._getExecutionOrder(parentRunId);
-        const start_time = Date.now();
-        const run = {
-            id: runId,
-            name: name ?? retriever.id[retriever.id.length - 1],
-            parent_run_id: parentRunId,
-            start_time,
-            serialized: retriever,
-            events: [
-                {
-                    name: "start",
-                    time: new Date(start_time).toISOString(),
-                },
-            ],
-            inputs: { query },
-            execution_order,
-            child_execution_order: execution_order,
-            run_type: "retriever",
-            child_runs: [],
-            extra: metadata ? { metadata } : {},
-            tags: tags || [],
-        };
-        await this._startTrace(run);
-        await this.onRetrieverStart?.(run);
-        return run;
-    }
-    async handleRetrieverEnd(documents, runId) {
-        const run = this.runMap.get(runId);
-        if (!run || run?.run_type !== "retriever") {
-            throw new Error("No retriever run to end");
-        }
-        run.end_time = Date.now();
-        run.outputs = { documents };
-        run.events.push({
-            name: "end",
-            time: new Date(run.end_time).toISOString(),
-        });
-        await this.onRetrieverEnd?.(run);
-        await this._endTrace(run);
-        return run;
-    }
-    async handleRetrieverError(error, runId) {
-        const run = this.runMap.get(runId);
-        if (!run || run?.run_type !== "retriever") {
-            throw new Error("No retriever run to end");
-        }
-        run.end_time = Date.now();
-        run.error = error.message;
-        run.events.push({
-            name: "error",
-            time: new Date(run.end_time).toISOString(),
-        });
-        await this.onRetrieverError?.(run);
-        await this._endTrace(run);
-        return run;
-    }
-    async handleText(text, runId) {
-        const run = this.runMap.get(runId);
-        if (!run || run?.run_type !== "chain") {
-            return;
-        }
-        run.events.push({
-            name: "text",
-            time: new Date().toISOString(),
-            kwargs: { text },
-        });
-        await this.onText?.(run);
-    }
-    async handleLLMNewToken(token, idx, runId, _parentRunId, _tags, fields) {
-        const run = this.runMap.get(runId);
-        if (!run || run?.run_type !== "llm") {
-            throw new Error(`Invalid "runId" provided to "handleLLMNewToken" callback.`);
-        }
-        run.events.push({
-            name: "new_token",
-            time: new Date().toISOString(),
-            kwargs: { token, idx, chunk: fields?.chunk },
-        });
-        await this.onLLMNewToken?.(run, token);
-        return run;
-    }
-}
-exports.BaseTracer = BaseTracer;
+__exportStar(require("langchain-core/callbacks/tracers/base"), exports);

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

@@ -1,70 +1 @@
-import { KVMap, BaseRun } from "langsmith/schemas";
-import { AgentAction, AgentFinish, BaseMessage, ChainValues, LLMResult } from "../../schema/index.js";
-import { Serialized } from "../../load/serializable.js";
-import { BaseCallbackHandler, BaseCallbackHandlerInput, HandleLLMNewTokenCallbackFields, NewTokenIndices } from "../base.js";
-import { Document } from "../../document.js";
-export type RunType = string;
-export 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>;
-    }>;
-}
-export interface AgentRun extends Run {
-    actions: AgentAction[];
-}
-export declare abstract class BaseTracer extends BaseCallbackHandler {
-    protected runMap: Map<string, Run>;
-    constructor(_fields?: BaseCallbackHandlerInput);
-    copy(): this;
-    protected abstract persistRun(run: Run): Promise<void>;
-    protected _addChildRun(parentRun: Run, childRun: Run): void;
-    protected _startTrace(run: Run): Promise<void>;
-    protected _endTrace(run: Run): Promise<void>;
-    protected _getExecutionOrder(parentRunId: string | undefined): number;
-    handleLLMStart(llm: Serialized, prompts: string[], runId: string, parentRunId?: string, extraParams?: KVMap, tags?: string[], metadata?: KVMap, name?: string): Promise<Run>;
-    handleChatModelStart(llm: Serialized, messages: BaseMessage[][], runId: string, parentRunId?: string, extraParams?: KVMap, tags?: string[], metadata?: KVMap, name?: string): Promise<Run>;
-    handleLLMEnd(output: LLMResult, runId: string): Promise<Run>;
-    handleLLMError(error: Error, runId: string): Promise<Run>;
-    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: Error, runId: string, _parentRunId?: string, _tags?: string[], kwargs?: {
-        inputs?: Record<string, unknown>;
-    }): Promise<Run>;
-    handleToolStart(tool: Serialized, input: string, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, name?: string): Promise<Run>;
-    handleToolEnd(output: string, runId: string): Promise<Run>;
-    handleToolError(error: Error, runId: string): Promise<Run>;
-    handleAgentAction(action: AgentAction, runId: string): Promise<void>;
-    handleAgentEnd(action: AgentFinish, runId: string): Promise<void>;
-    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: Error, 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): void | Promise<void>;
-}
+export * from "langchain-core/callbacks/tracers/base";