langchain 0.0.194 → 0.0.196

package/dist/callbacks/handlers/tracer_langchain_v1.cjs

@@ -1,199 +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.LangChainTracerV1 = void 0;
-const base_js_1 = require("../../memory/base.cjs");
-const env_js_1 = require("../../util/env.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: (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_ENDPOINT") || "http://localhost:1984"
-        });
-        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
-        });
-        const apiKey = (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_API_KEY");
-        if (apiKey) {
-            this.headers["x-api-key"] = apiKey;
-        }
-    }
-    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;
+__exportStar(require("langchain-core/callbacks/tracers/tracer_langchain_v1"), exports);

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

@@ -1,57 +1 @@
-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>;
-}
+export * from "langchain-core/callbacks/tracers/tracer_langchain_v1";

package/dist/callbacks/handlers/tracer_langchain_v1.js

@@ -1,195 +1 @@
-import { getBufferString } from "../../memory/base.js";
-import { getEnvironmentVariable } from "../../util/env.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: getEnvironmentVariable("LANGCHAIN_ENDPOINT") || "http://localhost:1984"
-        });
-        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
-        });
-        const apiKey = getEnvironmentVariable("LANGCHAIN_API_KEY");
-        if (apiKey) {
-            this.headers["x-api-key"] = apiKey;
-        }
-    }
-    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;
-    }
-}
+export * from "langchain-core/callbacks/tracers/tracer_langchain_v1";