langchain 0.0.74 → 0.0.76

package/dist/callbacks/handlers/initialize.js

@@ -1,6 +1,7 @@
-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 LangChainTracer();
+    const tracer = new LangChainTracerV1();
     if (session) {
         await tracer.loadSession(session);
     }
@@ -9,3 +10,6 @@ export async function getTracingCallbackHandler(session) {
     }
     return tracer;
 }
+export async function getTracingV2CallbackHandler() {
+    return new LangChainTracer();
+}

package/dist/callbacks/handlers/tracer.cjs

@@ -0,0 +1,193 @@
+"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);
+            }
+        }
+        this.runMap.set(run.id, 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);
+    }
+    _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) {
+        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",
+            extra: extraParams,
+        };
+        this._startTrace(run);
+        await this.onLLMStart?.(run);
+    }
+    async handleChatModelStart(llm, messages, runId, parentRunId, extraParams) {
+        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: { messages },
+            execution_order,
+            child_runs: [],
+            child_execution_order: execution_order,
+            run_type: "llm",
+            extra: extraParams,
+        };
+        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;

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

@@ -0,0 +1,65 @@
+import { AgentAction, BaseChatMessage, ChainValues, LLMResult, RunInputs, RunOutputs } from "../../schema/index.js";
+import { BaseCallbackHandler } from "../base.js";
+export type RunType = "llm" | "chain" | "tool";
+export type Extra = Record<string, any>;
+export interface BaseRun {
+    id: string;
+    name: string;
+    start_time: number;
+    end_time: number;
+    extra?: Extra;
+    error?: string;
+    execution_order: number;
+    serialized: object;
+    inputs: RunInputs;
+    outputs?: RunOutputs;
+    reference_example_id?: string;
+    run_type: RunType;
+}
+export interface Run extends BaseRun {
+    child_runs: this[];
+    child_execution_order: number;
+    parent_run_id?: string;
+}
+export interface AgentRun extends Run {
+    actions: AgentAction[];
+}
+export declare abstract class BaseTracer extends BaseCallbackHandler {
+    protected runMap: Map<string, Run>;
+    constructor();
+    copy(): this;
+    protected abstract persistRun(run: Run): Promise<void>;
+    protected _addChildRun(parentRun: Run, childRun: Run): void;
+    protected _startTrace(run: Run): void;
+    protected _endTrace(run: Run): Promise<void>;
+    protected _getExecutionOrder(parentRunId: string | undefined): number;
+    handleLLMStart(llm: {
+        name: string;
+    }, prompts: string[], runId: string, parentRunId?: string, extraParams?: Record<string, unknown>): Promise<void>;
+    handleChatModelStart(llm: {
+        name: string;
+    }, messages: BaseChatMessage[][], runId: string, parentRunId?: string, extraParams?: Record<string, unknown>): Promise<void>;
+    handleLLMEnd(output: LLMResult, runId: string): Promise<void>;
+    handleLLMError(error: Error, runId: string): Promise<void>;
+    handleChainStart(chain: {
+        name: string;
+    }, inputs: ChainValues, runId: string, parentRunId?: string): Promise<void>;
+    handleChainEnd(outputs: ChainValues, runId: string): Promise<void>;
+    handleChainError(error: Error, runId: string): Promise<void>;
+    handleToolStart(tool: {
+        name: string;
+    }, input: string, runId: string, parentRunId?: string): Promise<void>;
+    handleToolEnd(output: string, runId: string): Promise<void>;
+    handleToolError(error: Error, runId: string): Promise<void>;
+    handleAgentAction(action: AgentAction, runId: string): 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>;
+}

package/dist/callbacks/handlers/tracer.js

@@ -0,0 +1,189 @@
+import { BaseCallbackHandler } from "../base.js";
+export class BaseTracer extends 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);
+            }
+        }
+        this.runMap.set(run.id, 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);
+    }
+    _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) {
+        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",
+            extra: extraParams,
+        };
+        this._startTrace(run);
+        await this.onLLMStart?.(run);
+    }
+    async handleChatModelStart(llm, messages, runId, parentRunId, extraParams) {
+        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: { messages },
+            execution_order,
+            child_runs: [],
+            child_execution_order: execution_order,
+            run_type: "llm",
+            extra: extraParams,
+        };
+        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);
+    }
+}

package/dist/callbacks/handlers/tracer_langchain.cjs

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LangChainTracer = void 0;
+const env_js_1 = require("../../util/env.cjs");
+const tracer_js_1 = require("./tracer.cjs");
+class LangChainTracer extends tracer_js_1.BaseTracer {
+    constructor({ exampleId, tenantId, sessionName, sessionExtra, } = {}) {
+        super();
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "langchain_tracer"
+        });
+        Object.defineProperty(this, "endpoint", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (typeof process !== "undefined"
+                ? // eslint-disable-next-line no-process-env
+                    process.env?.LANGCHAIN_ENDPOINT
+                : undefined) || "http://localhost:8000"
+        });
+        Object.defineProperty(this, "headers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {
+                "Content-Type": "application/json",
+            }
+        });
+        Object.defineProperty(this, "sessionName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "sessionExtra", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "session", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "exampleId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "tenantId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // eslint-disable-next-line no-process-env
+        if (typeof process !== "undefined" && process.env?.LANGCHAIN_API_KEY) {
+            // eslint-disable-next-line no-process-env
+            this.headers["x-api-key"] = process.env?.LANGCHAIN_API_KEY;
+        }
+        this.tenantId =
+            tenantId ??
+                (typeof process !== "undefined"
+                    ? // eslint-disable-next-line no-process-env
+                        process.env?.LANGCHAIN_TENANT_ID
+                    : undefined);
+        this.sessionName =
+            sessionName ??
+                (typeof process !== "undefined"
+                    ? // eslint-disable-next-line no-process-env
+                        process.env?.LANGCHAIN_SESSION
+                    : undefined) ??
+                "default";
+        this.sessionExtra = sessionExtra;
+        this.exampleId = exampleId;
+    }
+    async ensureSession() {
+        if (this.session) {
+            return this.session;
+        }
+        const tenantId = await this.ensureTenantId();
+        const endpoint = `${this.endpoint}/sessions?upsert=true`;
+        const res = await fetch(endpoint, {
+            method: "POST",
+            headers: this.headers,
+            body: JSON.stringify({
+                name: this.sessionName,
+                tenant_id: tenantId,
+                extra: this.sessionExtra,
+            }),
+        });
+        if (!res.ok) {
+            const body = await res.text();
+            throw new Error(`Failed to create session: ${res.status} ${res.statusText} ${body}`);
+        }
+        const session = await res.json();
+        this.session = session;
+        return session;
+    }
+    async ensureTenantId() {
+        if (this.tenantId) {
+            return this.tenantId;
+        }
+        const endpoint = `${this.endpoint}/tenants`;
+        const response = await fetch(endpoint, {
+            method: "GET",
+            headers: this.headers,
+        });
+        if (!response.ok) {
+            const body = await response.text();
+            throw new Error(`Failed to fetch tenant ID: ${response.status} ${response.statusText} ${body}`);
+        }
+        const tenants = await response.json();
+        if (!tenants || tenants.length === 0) {
+            throw new Error(`No tenants found for endpoint ${endpoint}`);
+        }
+        const tenantId = tenants[0].id;
+        this.tenantId = tenantId;
+        return tenantId;
+    }
+    async _convertToCreate(run, example_id = undefined) {
+        const session = await this.ensureSession();
+        const runExtra = run.extra ?? {};
+        runExtra.runtime = await (0, env_js_1.getRuntimeEnvironment)();
+        const persistedRun = {
+            id: run.id,
+            name: run.name,
+            start_time: run.start_time,
+            end_time: run.end_time,
+            run_type: run.run_type,
+            reference_example_id: example_id,
+            extra: runExtra,
+            execution_order: run.execution_order,
+            serialized: run.serialized,
+            error: run.error,
+            inputs: run.inputs,
+            outputs: run.outputs ?? {},
+            session_id: session.id,
+            child_runs: await Promise.all(run.child_runs.map((child_run) => this._convertToCreate(child_run))),
+        };
+        return persistedRun;
+    }
+    async persistRun(run) {
+        const persistedRun = await this._convertToCreate(run, this.exampleId);
+        const endpoint = `${this.endpoint}/runs`;
+        const response = await fetch(endpoint, {
+            method: "POST",
+            headers: this.headers,
+            body: JSON.stringify(persistedRun),
+        });
+        if (!response.ok) {
+            const body = await response.text();
+            throw new Error(`Failed to persist run: ${response.status} ${response.statusText} ${body}`);
+        }
+    }
+}
+exports.LangChainTracer = LangChainTracer;

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

@@ -0,0 +1,39 @@
+import { BaseTracer, Run, BaseRun } from "./tracer.js";
+export interface RunCreate extends BaseRun {
+    child_runs: this[];
+    session_id: string;
+}
+export interface BaseTracerSession {
+    start_time: number;
+    name?: string;
+}
+export interface BaseTracerSessionV2 extends BaseTracerSession {
+    tenant_id: string;
+}
+export interface TracerSessionCreateV2 extends BaseTracerSessionV2 {
+    id?: string;
+}
+export interface TracerSession extends BaseTracerSessionV2 {
+    id: string;
+}
+export interface LangChainTracerFields {
+    exampleId?: string;
+    tenantId?: string;
+    sessionName?: string;
+    sessionExtra?: Record<string, unknown>;
+}
+export declare class LangChainTracer extends BaseTracer implements LangChainTracerFields {
+    name: string;
+    protected endpoint: string;
+    protected headers: Record<string, string>;
+    sessionName: string;
+    sessionExtra?: LangChainTracerFields["sessionExtra"];
+    protected session: TracerSession;
+    exampleId?: string;
+    tenantId?: string;
+    constructor({ exampleId, tenantId, sessionName, sessionExtra, }?: LangChainTracerFields);
+    protected ensureSession(): Promise<TracerSession>;
+    protected ensureTenantId(): Promise<string>;
+    private _convertToCreate;
+    protected persistRun(run: Run): Promise<void>;
+}