langchain 0.0.195 → 0.0.196

package/dist/callbacks/handlers/tracer.js

@@ -1,373 +1 @@
-import { BaseCallbackHandler, } from "../base.js";
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function _coerceToDict(value, defaultKey) {
-    return value && !Array.isArray(value) && typeof value === "object"
-        ? value
-        : { [defaultKey]: value };
-}
-export class BaseTracer extends 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;
-    }
-}
+export * from "langchain-core/callbacks/tracers/base";

package/dist/callbacks/handlers/tracer_langchain.cjs

@@ -1,106 +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.LangChainTracer = void 0;
-const langsmith_1 = require("langsmith");
-const env_js_1 = require("../../util/env.cjs");
-const tracer_js_1 = require("./tracer.cjs");
-class LangChainTracer extends tracer_js_1.BaseTracer {
-    constructor(fields = {}) {
-        super(fields);
-        Object.defineProperty(this, "name", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "langchain_tracer"
-        });
-        Object.defineProperty(this, "projectName", {
-            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, "client", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        const { exampleId, projectName, client } = fields;
-        this.projectName =
-            projectName ??
-                (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_PROJECT") ??
-                (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_SESSION");
-        this.exampleId = exampleId;
-        this.client = client ?? new langsmith_1.Client({});
-    }
-    async _convertToCreate(run, example_id = undefined) {
-        return {
-            ...run,
-            extra: {
-                ...run.extra,
-                runtime: await (0, env_js_1.getRuntimeEnvironment)(),
-            },
-            child_runs: undefined,
-            session_name: this.projectName,
-            reference_example_id: run.parent_run_id ? undefined : example_id,
-        };
-    }
-    async persistRun(_run) { }
-    async _persistRunSingle(run) {
-        const persistedRun = await this._convertToCreate(run, this.exampleId);
-        await this.client.createRun(persistedRun);
-    }
-    async _updateRunSingle(run) {
-        const runUpdate = {
-            end_time: run.end_time,
-            error: run.error,
-            outputs: run.outputs,
-            events: run.events,
-            inputs: run.inputs,
-        };
-        await this.client.updateRun(run.id, runUpdate);
-    }
-    async onRetrieverStart(run) {
-        await this._persistRunSingle(run);
-    }
-    async onRetrieverEnd(run) {
-        await this._updateRunSingle(run);
-    }
-    async onRetrieverError(run) {
-        await this._updateRunSingle(run);
-    }
-    async onLLMStart(run) {
-        await this._persistRunSingle(run);
-    }
-    async onLLMEnd(run) {
-        await this._updateRunSingle(run);
-    }
-    async onLLMError(run) {
-        await this._updateRunSingle(run);
-    }
-    async onChainStart(run) {
-        await this._persistRunSingle(run);
-    }
-    async onChainEnd(run) {
-        await this._updateRunSingle(run);
-    }
-    async onChainError(run) {
-        await this._updateRunSingle(run);
-    }
-    async onToolStart(run) {
-        await this._persistRunSingle(run);
-    }
-    async onToolEnd(run) {
-        await this._updateRunSingle(run);
-    }
-    async onToolError(run) {
-        await this._updateRunSingle(run);
-    }
-}
-exports.LangChainTracer = LangChainTracer;
+__exportStar(require("langchain-core/callbacks/tracers/tracer_langchain"), exports);

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

@@ -1,41 +1 @@
-import { Client } from "langsmith";
-import { BaseRun, RunUpdate as BaseRunUpdate, KVMap } from "langsmith/schemas";
-import { BaseTracer } from "./tracer.js";
-import { BaseCallbackHandlerInput } from "../base.js";
-export interface Run extends BaseRun {
-    id: string;
-    child_runs: this[];
-    child_execution_order: number;
-}
-export interface RunUpdate extends BaseRunUpdate {
-    events: BaseRun["events"];
-    inputs: KVMap;
-}
-export interface LangChainTracerFields extends BaseCallbackHandlerInput {
-    exampleId?: string;
-    projectName?: string;
-    client?: Client;
-}
-export declare class LangChainTracer extends BaseTracer implements LangChainTracerFields {
-    name: string;
-    projectName?: string;
-    exampleId?: string;
-    client: Client;
-    constructor(fields?: LangChainTracerFields);
-    private _convertToCreate;
-    protected persistRun(_run: Run): Promise<void>;
-    protected _persistRunSingle(run: Run): Promise<void>;
-    protected _updateRunSingle(run: Run): Promise<void>;
-    onRetrieverStart(run: Run): Promise<void>;
-    onRetrieverEnd(run: Run): Promise<void>;
-    onRetrieverError(run: Run): Promise<void>;
-    onLLMStart(run: Run): Promise<void>;
-    onLLMEnd(run: Run): Promise<void>;
-    onLLMError(run: Run): Promise<void>;
-    onChainStart(run: Run): Promise<void>;
-    onChainEnd(run: Run): Promise<void>;
-    onChainError(run: Run): Promise<void>;
-    onToolStart(run: Run): Promise<void>;
-    onToolEnd(run: Run): Promise<void>;
-    onToolError(run: Run): Promise<void>;
-}
+export * from "langchain-core/callbacks/tracers/tracer_langchain";

package/dist/callbacks/handlers/tracer_langchain.js

@@ -1,102 +1 @@
-import { Client } from "langsmith";
-import { getEnvironmentVariable, getRuntimeEnvironment, } from "../../util/env.js";
-import { BaseTracer } from "./tracer.js";
-export class LangChainTracer extends BaseTracer {
-    constructor(fields = {}) {
-        super(fields);
-        Object.defineProperty(this, "name", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "langchain_tracer"
-        });
-        Object.defineProperty(this, "projectName", {
-            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, "client", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        const { exampleId, projectName, client } = fields;
-        this.projectName =
-            projectName ??
-                getEnvironmentVariable("LANGCHAIN_PROJECT") ??
-                getEnvironmentVariable("LANGCHAIN_SESSION");
-        this.exampleId = exampleId;
-        this.client = client ?? new Client({});
-    }
-    async _convertToCreate(run, example_id = undefined) {
-        return {
-            ...run,
-            extra: {
-                ...run.extra,
-                runtime: await getRuntimeEnvironment(),
-            },
-            child_runs: undefined,
-            session_name: this.projectName,
-            reference_example_id: run.parent_run_id ? undefined : example_id,
-        };
-    }
-    async persistRun(_run) { }
-    async _persistRunSingle(run) {
-        const persistedRun = await this._convertToCreate(run, this.exampleId);
-        await this.client.createRun(persistedRun);
-    }
-    async _updateRunSingle(run) {
-        const runUpdate = {
-            end_time: run.end_time,
-            error: run.error,
-            outputs: run.outputs,
-            events: run.events,
-            inputs: run.inputs,
-        };
-        await this.client.updateRun(run.id, runUpdate);
-    }
-    async onRetrieverStart(run) {
-        await this._persistRunSingle(run);
-    }
-    async onRetrieverEnd(run) {
-        await this._updateRunSingle(run);
-    }
-    async onRetrieverError(run) {
-        await this._updateRunSingle(run);
-    }
-    async onLLMStart(run) {
-        await this._persistRunSingle(run);
-    }
-    async onLLMEnd(run) {
-        await this._updateRunSingle(run);
-    }
-    async onLLMError(run) {
-        await this._updateRunSingle(run);
-    }
-    async onChainStart(run) {
-        await this._persistRunSingle(run);
-    }
-    async onChainEnd(run) {
-        await this._updateRunSingle(run);
-    }
-    async onChainError(run) {
-        await this._updateRunSingle(run);
-    }
-    async onToolStart(run) {
-        await this._persistRunSingle(run);
-    }
-    async onToolEnd(run) {
-        await this._updateRunSingle(run);
-    }
-    async onToolError(run) {
-        await this._updateRunSingle(run);
-    }
-}
+export * from "langchain-core/callbacks/tracers/tracer_langchain";