langchain 0.0.74 → 0.0.76

package/dist/callbacks/handlers/tracer_langchain.js

@@ -0,0 +1,159 @@
+import { getRuntimeEnvironment } from "../../util/env.js";
+import { BaseTracer } from "./tracer.js";
+export class LangChainTracer extends 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 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}`);
+        }
+    }
+}

package/dist/callbacks/handlers/tracer_langchain_v1.cjs

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LangChainTracerV1 = void 0;
+const base_js_1 = require("../../memory/base.cjs");
+const tracer_js_1 = require("./tracer.cjs");
+class LangChainTracerV1 extends tracer_js_1.BaseTracer {
+    constructor() {
+        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, "session", {
+            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;
+        }
+    }
+    async newSession(sessionName) {
+        const sessionCreate = {
+            start_time: Date.now(),
+            name: sessionName,
+        };
+        const session = await this.persistSession(sessionCreate);
+        this.session = session;
+        return session;
+    }
+    async loadSession(sessionName) {
+        const endpoint = `${this.endpoint}/sessions?name=${sessionName}`;
+        return this._handleSessionResponse(endpoint);
+    }
+    async loadDefaultSession() {
+        const endpoint = `${this.endpoint}/sessions?name=default`;
+        return this._handleSessionResponse(endpoint);
+    }
+    async convertV2RunToRun(run) {
+        const session = this.session ?? (await this.loadDefaultSession());
+        const serialized = run.serialized;
+        let runResult;
+        if (run.run_type === "llm") {
+            const prompts = run.inputs.prompts
+                ? run.inputs.prompts
+                : run.inputs.messages.map((x) => (0, base_js_1.getBufferString)(x));
+            const llmRun = {
+                uuid: run.id,
+                start_time: run.start_time,
+                end_time: run.end_time,
+                execution_order: run.execution_order,
+                child_execution_order: run.child_execution_order,
+                serialized,
+                type: run.run_type,
+                session_id: session.id,
+                prompts,
+                response: run.outputs,
+            };
+            runResult = llmRun;
+        }
+        else if (run.run_type === "chain") {
+            const child_runs = await Promise.all(run.child_runs.map((child_run) => this.convertV2RunToRun(child_run)));
+            const chainRun = {
+                uuid: run.id,
+                start_time: run.start_time,
+                end_time: run.end_time,
+                execution_order: run.execution_order,
+                child_execution_order: run.child_execution_order,
+                serialized,
+                type: run.run_type,
+                session_id: session.id,
+                inputs: run.inputs,
+                outputs: run.outputs,
+                child_llm_runs: child_runs.filter((child_run) => child_run.type === "llm"),
+                child_chain_runs: child_runs.filter((child_run) => child_run.type === "chain"),
+                child_tool_runs: child_runs.filter((child_run) => child_run.type === "tool"),
+            };
+            runResult = chainRun;
+        }
+        else if (run.run_type === "tool") {
+            const child_runs = await Promise.all(run.child_runs.map((child_run) => this.convertV2RunToRun(child_run)));
+            const toolRun = {
+                uuid: run.id,
+                start_time: run.start_time,
+                end_time: run.end_time,
+                execution_order: run.execution_order,
+                child_execution_order: run.child_execution_order,
+                serialized,
+                type: run.run_type,
+                session_id: session.id,
+                tool_input: run.inputs.input,
+                output: run.outputs?.output,
+                action: JSON.stringify(serialized),
+                child_llm_runs: child_runs.filter((child_run) => child_run.type === "llm"),
+                child_chain_runs: child_runs.filter((child_run) => child_run.type === "chain"),
+                child_tool_runs: child_runs.filter((child_run) => child_run.type === "tool"),
+            };
+            runResult = toolRun;
+        }
+        else {
+            throw new Error(`Unknown run type: ${run.run_type}`);
+        }
+        return runResult;
+    }
+    async persistRun(run) {
+        let endpoint;
+        let v1Run;
+        if (run.run_type !== undefined) {
+            v1Run = await this.convertV2RunToRun(run);
+        }
+        else {
+            v1Run = run;
+        }
+        if (v1Run.type === "llm") {
+            endpoint = `${this.endpoint}/llm-runs`;
+        }
+        else if (v1Run.type === "chain") {
+            endpoint = `${this.endpoint}/chain-runs`;
+        }
+        else {
+            endpoint = `${this.endpoint}/tool-runs`;
+        }
+        const response = await fetch(endpoint, {
+            method: "POST",
+            headers: this.headers,
+            body: JSON.stringify(v1Run),
+        });
+        if (!response.ok) {
+            console.error(`Failed to persist run: ${response.status} ${response.statusText}`);
+        }
+    }
+    async persistSession(sessionCreate) {
+        const endpoint = `${this.endpoint}/sessions`;
+        const response = await fetch(endpoint, {
+            method: "POST",
+            headers: this.headers,
+            body: JSON.stringify(sessionCreate),
+        });
+        if (!response.ok) {
+            console.error(`Failed to persist session: ${response.status} ${response.statusText}, using default session.`);
+            return {
+                id: 1,
+                ...sessionCreate,
+            };
+        }
+        return {
+            id: (await response.json()).id,
+            ...sessionCreate,
+        };
+    }
+    async _handleSessionResponse(endpoint) {
+        const response = await fetch(endpoint, {
+            method: "GET",
+            headers: this.headers,
+        });
+        let tracerSession;
+        if (!response.ok) {
+            console.error(`Failed to load session: ${response.status} ${response.statusText}`);
+            tracerSession = {
+                id: 1,
+                start_time: Date.now(),
+            };
+            this.session = tracerSession;
+            return tracerSession;
+        }
+        const resp = (await response.json());
+        if (resp.length === 0) {
+            tracerSession = {
+                id: 1,
+                start_time: Date.now(),
+            };
+            this.session = tracerSession;
+            return tracerSession;
+        }
+        [tracerSession] = resp;
+        this.session = tracerSession;
+        return tracerSession;
+    }
+}
+exports.LangChainTracerV1 = LangChainTracerV1;

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

@@ -0,0 +1,57 @@
+import { ChainValues, LLMResult } from "../../schema/index.js";
+import { BaseTracer, RunType, Run } from "./tracer.js";
+export interface BaseRunV1 {
+    uuid: string;
+    parent_uuid?: string;
+    start_time: number;
+    end_time: number;
+    execution_order: number;
+    child_execution_order: number;
+    serialized: {
+        name: string;
+    };
+    session_id: number;
+    error?: string;
+    type: RunType;
+}
+export interface LLMRun extends BaseRunV1 {
+    prompts: string[];
+    response?: LLMResult;
+}
+export interface ChainRun extends BaseRunV1 {
+    inputs: ChainValues;
+    outputs?: ChainValues;
+    child_llm_runs: LLMRun[];
+    child_chain_runs: ChainRun[];
+    child_tool_runs: ToolRun[];
+}
+export interface ToolRun extends BaseRunV1 {
+    tool_input: string;
+    output?: string;
+    action: string;
+    child_llm_runs: LLMRun[];
+    child_chain_runs: ChainRun[];
+    child_tool_runs: ToolRun[];
+}
+export interface BaseTracerSession {
+    start_time: number;
+    name?: string;
+}
+export type TracerSessionCreate = BaseTracerSession;
+export interface TracerSessionV1 extends BaseTracerSession {
+    id: number;
+}
+export declare class LangChainTracerV1 extends BaseTracer {
+    name: string;
+    protected endpoint: string;
+    protected headers: Record<string, string>;
+    protected session: TracerSessionV1;
+    constructor();
+    newSession(sessionName?: string): Promise<TracerSessionV1>;
+    loadSession(sessionName: string): Promise<TracerSessionV1>;
+    loadDefaultSession(): Promise<TracerSessionV1>;
+    protected convertV2RunToRun(run: Run): Promise<LLMRun | ChainRun | ToolRun>;
+    protected persistRun(run: Run | LLMRun | ChainRun | ToolRun): Promise<void>;
+    protected persistSession(sessionCreate: BaseTracerSession): Promise<TracerSessionV1>;
+    protected _handleSessionResponse(endpoint: string): Promise<TracerSessionV1>;
+}

package/dist/callbacks/handlers/tracer_langchain_v1.js

@@ -0,0 +1,198 @@
+import { getBufferString } from "../../memory/base.js";
+import { BaseTracer } from "./tracer.js";
+export class LangChainTracerV1 extends BaseTracer {
+    constructor() {
+        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, "session", {
+            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;
+        }
+    }
+    async newSession(sessionName) {
+        const sessionCreate = {
+            start_time: Date.now(),
+            name: sessionName,
+        };
+        const session = await this.persistSession(sessionCreate);
+        this.session = session;
+        return session;
+    }
+    async loadSession(sessionName) {
+        const endpoint = `${this.endpoint}/sessions?name=${sessionName}`;
+        return this._handleSessionResponse(endpoint);
+    }
+    async loadDefaultSession() {
+        const endpoint = `${this.endpoint}/sessions?name=default`;
+        return this._handleSessionResponse(endpoint);
+    }
+    async convertV2RunToRun(run) {
+        const session = this.session ?? (await this.loadDefaultSession());
+        const serialized = run.serialized;
+        let runResult;
+        if (run.run_type === "llm") {
+            const prompts = run.inputs.prompts
+                ? run.inputs.prompts
+                : run.inputs.messages.map((x) => getBufferString(x));
+            const llmRun = {
+                uuid: run.id,
+                start_time: run.start_time,
+                end_time: run.end_time,
+                execution_order: run.execution_order,
+                child_execution_order: run.child_execution_order,
+                serialized,
+                type: run.run_type,
+                session_id: session.id,
+                prompts,
+                response: run.outputs,
+            };
+            runResult = llmRun;
+        }
+        else if (run.run_type === "chain") {
+            const child_runs = await Promise.all(run.child_runs.map((child_run) => this.convertV2RunToRun(child_run)));
+            const chainRun = {
+                uuid: run.id,
+                start_time: run.start_time,
+                end_time: run.end_time,
+                execution_order: run.execution_order,
+                child_execution_order: run.child_execution_order,
+                serialized,
+                type: run.run_type,
+                session_id: session.id,
+                inputs: run.inputs,
+                outputs: run.outputs,
+                child_llm_runs: child_runs.filter((child_run) => child_run.type === "llm"),
+                child_chain_runs: child_runs.filter((child_run) => child_run.type === "chain"),
+                child_tool_runs: child_runs.filter((child_run) => child_run.type === "tool"),
+            };
+            runResult = chainRun;
+        }
+        else if (run.run_type === "tool") {
+            const child_runs = await Promise.all(run.child_runs.map((child_run) => this.convertV2RunToRun(child_run)));
+            const toolRun = {
+                uuid: run.id,
+                start_time: run.start_time,
+                end_time: run.end_time,
+                execution_order: run.execution_order,
+                child_execution_order: run.child_execution_order,
+                serialized,
+                type: run.run_type,
+                session_id: session.id,
+                tool_input: run.inputs.input,
+                output: run.outputs?.output,
+                action: JSON.stringify(serialized),
+                child_llm_runs: child_runs.filter((child_run) => child_run.type === "llm"),
+                child_chain_runs: child_runs.filter((child_run) => child_run.type === "chain"),
+                child_tool_runs: child_runs.filter((child_run) => child_run.type === "tool"),
+            };
+            runResult = toolRun;
+        }
+        else {
+            throw new Error(`Unknown run type: ${run.run_type}`);
+        }
+        return runResult;
+    }
+    async persistRun(run) {
+        let endpoint;
+        let v1Run;
+        if (run.run_type !== undefined) {
+            v1Run = await this.convertV2RunToRun(run);
+        }
+        else {
+            v1Run = run;
+        }
+        if (v1Run.type === "llm") {
+            endpoint = `${this.endpoint}/llm-runs`;
+        }
+        else if (v1Run.type === "chain") {
+            endpoint = `${this.endpoint}/chain-runs`;
+        }
+        else {
+            endpoint = `${this.endpoint}/tool-runs`;
+        }
+        const response = await fetch(endpoint, {
+            method: "POST",
+            headers: this.headers,
+            body: JSON.stringify(v1Run),
+        });
+        if (!response.ok) {
+            console.error(`Failed to persist run: ${response.status} ${response.statusText}`);
+        }
+    }
+    async persistSession(sessionCreate) {
+        const endpoint = `${this.endpoint}/sessions`;
+        const response = await fetch(endpoint, {
+            method: "POST",
+            headers: this.headers,
+            body: JSON.stringify(sessionCreate),
+        });
+        if (!response.ok) {
+            console.error(`Failed to persist session: ${response.status} ${response.statusText}, using default session.`);
+            return {
+                id: 1,
+                ...sessionCreate,
+            };
+        }
+        return {
+            id: (await response.json()).id,
+            ...sessionCreate,
+        };
+    }
+    async _handleSessionResponse(endpoint) {
+        const response = await fetch(endpoint, {
+            method: "GET",
+            headers: this.headers,
+        });
+        let tracerSession;
+        if (!response.ok) {
+            console.error(`Failed to load session: ${response.status} ${response.statusText}`);
+            tracerSession = {
+                id: 1,
+                start_time: Date.now(),
+            };
+            this.session = tracerSession;
+            return tracerSession;
+        }
+        const resp = (await response.json());
+        if (resp.length === 0) {
+            tracerSession = {
+                id: 1,
+                start_time: Date.now(),
+            };
+            this.session = tracerSession;
+            return tracerSession;
+        }
+        [tracerSession] = resp;
+        this.session = tracerSession;
+        return tracerSession;
+    }
+}

package/dist/callbacks/index.cjs

@@ -1,16 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConsoleCallbackHandler = exports.CallbackManagerForToolRun = exports.CallbackManagerForLLMRun = exports.CallbackManagerForChainRun = exports.CallbackManager = exports.getTracingCallbackHandler = exports.LangChainTracer = exports.BaseCallbackHandler = void 0;
+exports.CallbackManagerForToolRun = exports.CallbackManagerForLLMRun = exports.CallbackManagerForChainRun = exports.CallbackManager = exports.getTracingV2CallbackHandler = exports.getTracingCallbackHandler = exports.LangChainTracerV1 = exports.LangChainTracer = exports.ConsoleCallbackHandler = exports.BaseTracer = exports.BaseCallbackHandler = void 0;
 var base_js_1 = require("./base.cjs");
 Object.defineProperty(exports, "BaseCallbackHandler", { enumerable: true, get: function () { return base_js_1.BaseCallbackHandler; } });
-var tracers_js_1 = require("./handlers/tracers.cjs");
-Object.defineProperty(exports, "LangChainTracer", { enumerable: true, get: function () { return tracers_js_1.LangChainTracer; } });
+var tracer_js_1 = require("./handlers/tracer.cjs");
+Object.defineProperty(exports, "BaseTracer", { enumerable: true, get: function () { return tracer_js_1.BaseTracer; } });
+var console_js_1 = require("./handlers/console.cjs");
+Object.defineProperty(exports, "ConsoleCallbackHandler", { enumerable: true, get: function () { return console_js_1.ConsoleCallbackHandler; } });
+var tracer_langchain_js_1 = require("./handlers/tracer_langchain.cjs");
+Object.defineProperty(exports, "LangChainTracer", { enumerable: true, get: function () { return tracer_langchain_js_1.LangChainTracer; } });
+var tracer_langchain_v1_js_1 = require("./handlers/tracer_langchain_v1.cjs");
+Object.defineProperty(exports, "LangChainTracerV1", { enumerable: true, get: function () { return tracer_langchain_v1_js_1.LangChainTracerV1; } });
 var initialize_js_1 = require("./handlers/initialize.cjs");
 Object.defineProperty(exports, "getTracingCallbackHandler", { enumerable: true, get: function () { return initialize_js_1.getTracingCallbackHandler; } });
+Object.defineProperty(exports, "getTracingV2CallbackHandler", { enumerable: true, get: function () { return initialize_js_1.getTracingV2CallbackHandler; } });
 var manager_js_1 = require("./manager.cjs");
 Object.defineProperty(exports, "CallbackManager", { enumerable: true, get: function () { return manager_js_1.CallbackManager; } });
 Object.defineProperty(exports, "CallbackManagerForChainRun", { enumerable: true, get: function () { return manager_js_1.CallbackManagerForChainRun; } });
 Object.defineProperty(exports, "CallbackManagerForLLMRun", { enumerable: true, get: function () { return manager_js_1.CallbackManagerForLLMRun; } });
 Object.defineProperty(exports, "CallbackManagerForToolRun", { enumerable: true, get: function () { return manager_js_1.CallbackManagerForToolRun; } });
-var console_js_1 = require("./handlers/console.cjs");
-Object.defineProperty(exports, "ConsoleCallbackHandler", { enumerable: true, get: function () { return console_js_1.ConsoleCallbackHandler; } });

package/dist/callbacks/index.d.ts

@@ -1,5 +1,7 @@
 export { BaseCallbackHandler, CallbackHandlerMethods, BaseCallbackHandlerInput, } from "./base.js";
-export { LangChainTracer, BaseRun, LLMRun, ChainRun, ToolRun, } from "./handlers/tracers.js";
-export { getTracingCallbackHandler } from "./handlers/initialize.js";
-export { CallbackManager, CallbackManagerForChainRun, CallbackManagerForLLMRun, CallbackManagerForToolRun, CallbackManagerOptions, Callbacks, } from "./manager.js";
+export { Run, RunType, BaseRun, BaseTracer } from "./handlers/tracer.js";
 export { ConsoleCallbackHandler } from "./handlers/console.js";
+export { LangChainTracer } from "./handlers/tracer_langchain.js";
+export { LangChainTracerV1 } from "./handlers/tracer_langchain_v1.js";
+export { getTracingCallbackHandler, getTracingV2CallbackHandler, } from "./handlers/initialize.js";
+export { CallbackManager, CallbackManagerForChainRun, CallbackManagerForLLMRun, CallbackManagerForToolRun, CallbackManagerOptions, Callbacks, } from "./manager.js";

package/dist/callbacks/index.js

@@ -1,5 +1,7 @@
 export { BaseCallbackHandler, } from "./base.js";
-export { LangChainTracer, } from "./handlers/tracers.js";
-export { getTracingCallbackHandler } from "./handlers/initialize.js";
-export { CallbackManager, CallbackManagerForChainRun, CallbackManagerForLLMRun, CallbackManagerForToolRun, } from "./manager.js";
+export { BaseTracer } from "./handlers/tracer.js";
 export { ConsoleCallbackHandler } from "./handlers/console.js";
+export { LangChainTracer } from "./handlers/tracer_langchain.js";
+export { LangChainTracerV1 } from "./handlers/tracer_langchain_v1.js";
+export { getTracingCallbackHandler, getTracingV2CallbackHandler, } from "./handlers/initialize.js";
+export { CallbackManager, CallbackManagerForChainRun, CallbackManagerForLLMRun, CallbackManagerForToolRun, } from "./manager.js";