@nocobase/plugin-ai 1.6.0-alpha.30

package/dist/node_modules/@langchain/core/dist/tracers/run_collector.js

@@ -0,0 +1,46 @@
+import { BaseTracer } from "./base.js";
+/**
+ * A callback handler that collects traced runs and makes it easy to fetch the traced run object from calls through any langchain object.
+ * For instance, it makes it easy to fetch the run ID and then do things with that, such as log feedback.
+ */
+export class RunCollectorCallbackHandler extends BaseTracer {
+    /**
+     * Creates a new instance of the RunCollectorCallbackHandler class.
+     * @param exampleId The ID of the example.
+     */
+    constructor({ exampleId } = {}) {
+        super({ _awaitHandler: true });
+        /** The name of the callback handler. */
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "run_collector"
+        });
+        /** The ID of the example. */
+        Object.defineProperty(this, "exampleId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** An array of traced runs. */
+        Object.defineProperty(this, "tracedRuns", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.exampleId = exampleId;
+        this.tracedRuns = [];
+    }
+    /**
+     * Persists the given run object.
+     * @param run The run object to persist.
+     */
+    async persistRun(run) {
+        const run_ = { ...run };
+        run_.reference_example_id = this.exampleId;
+        this.tracedRuns.push(run_);
+    }
+}

package/dist/node_modules/@langchain/core/dist/tracers/tracer_langchain.cjs

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LangChainTracer = void 0;
+const run_trees_1 = require("langsmith/run_trees");
+const traceable_1 = require("langsmith/singletons/traceable");
+const env_js_1 = require("../utils/env.cjs");
+const base_js_1 = require("./base.cjs");
+const tracer_js_1 = require("../singletons/tracer.cjs");
+class LangChainTracer extends base_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 ?? (0, tracer_js_1.getDefaultLangChainClientSingleton)();
+        const traceableTree = LangChainTracer.getTraceableRunTree();
+        if (traceableTree) {
+            this.updateFromRunTree(traceableTree);
+        }
+    }
+    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 onRunCreate(run) {
+        const persistedRun = await this._convertToCreate(run, this.exampleId);
+        await this.client.createRun(persistedRun);
+    }
+    async onRunUpdate(run) {
+        const runUpdate = {
+            end_time: run.end_time,
+            error: run.error,
+            outputs: run.outputs,
+            events: run.events,
+            inputs: run.inputs,
+            trace_id: run.trace_id,
+            dotted_order: run.dotted_order,
+            parent_run_id: run.parent_run_id,
+            extra: run.extra,
+        };
+        await this.client.updateRun(run.id, runUpdate);
+    }
+    getRun(id) {
+        return this.runMap.get(id);
+    }
+    updateFromRunTree(runTree) {
+        let rootRun = runTree;
+        const visited = new Set();
+        while (rootRun.parent_run) {
+            if (visited.has(rootRun.id))
+                break;
+            visited.add(rootRun.id);
+            if (!rootRun.parent_run)
+                break;
+            rootRun = rootRun.parent_run;
+        }
+        visited.clear();
+        const queue = [rootRun];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (!current || visited.has(current.id))
+                continue;
+            visited.add(current.id);
+            // @ts-expect-error Types of property 'events' are incompatible.
+            this.runMap.set(current.id, current);
+            if (current.child_runs) {
+                queue.push(...current.child_runs);
+            }
+        }
+        this.client = runTree.client ?? this.client;
+        this.projectName = runTree.project_name ?? this.projectName;
+        this.exampleId = runTree.reference_example_id ?? this.exampleId;
+    }
+    convertToRunTree(id) {
+        const runTreeMap = {};
+        const runTreeList = [];
+        for (const [id, run] of this.runMap) {
+            // by converting the run map to a run tree, we are doing a copy
+            // thus, any mutation performed on the run tree will not be reflected
+            // back in the run map
+            // TODO: Stop using `this.runMap` in favour of LangSmith's `RunTree`
+            const runTree = new run_trees_1.RunTree({
+                ...run,
+                child_runs: [],
+                parent_run: undefined,
+                // inherited properties
+                client: this.client,
+                project_name: this.projectName,
+                reference_example_id: this.exampleId,
+                tracingEnabled: true,
+            });
+            runTreeMap[id] = runTree;
+            runTreeList.push([id, run.dotted_order]);
+        }
+        runTreeList.sort((a, b) => {
+            if (!a[1] || !b[1])
+                return 0;
+            return a[1].localeCompare(b[1]);
+        });
+        for (const [id] of runTreeList) {
+            const run = this.runMap.get(id);
+            const runTree = runTreeMap[id];
+            if (!run || !runTree)
+                continue;
+            if (run.parent_run_id) {
+                const parentRunTree = runTreeMap[run.parent_run_id];
+                if (parentRunTree) {
+                    parentRunTree.child_runs.push(runTree);
+                    runTree.parent_run = parentRunTree;
+                }
+            }
+        }
+        return runTreeMap[id];
+    }
+    static getTraceableRunTree() {
+        try {
+            return (0, traceable_1.getCurrentRunTree)();
+        }
+        catch {
+            return undefined;
+        }
+    }
+}
+exports.LangChainTracer = LangChainTracer;

package/dist/node_modules/@langchain/core/dist/tracers/tracer_langchain.d.ts

@@ -0,0 +1,42 @@
+import type { LangSmithTracingClientInterface } from "langsmith";
+import { RunTree } from "langsmith/run_trees";
+import { BaseRun, RunCreate, RunUpdate as BaseRunUpdate, KVMap } from "langsmith/schemas";
+import { BaseTracer } from "./base.js";
+import { BaseCallbackHandlerInput } from "../callbacks/base.js";
+export interface Run extends BaseRun {
+    id: string;
+    child_runs: this[];
+    child_execution_order: number;
+    dotted_order?: string;
+    trace_id?: string;
+}
+export interface RunCreate2 extends RunCreate {
+    trace_id?: string;
+    dotted_order?: string;
+}
+export interface RunUpdate extends BaseRunUpdate {
+    events: BaseRun["events"];
+    inputs: KVMap;
+    trace_id?: string;
+    dotted_order?: string;
+}
+export interface LangChainTracerFields extends BaseCallbackHandlerInput {
+    exampleId?: string;
+    projectName?: string;
+    client?: LangSmithTracingClientInterface;
+}
+export declare class LangChainTracer extends BaseTracer implements LangChainTracerFields {
+    name: string;
+    projectName?: string;
+    exampleId?: string;
+    client: LangSmithTracingClientInterface;
+    constructor(fields?: LangChainTracerFields);
+    private _convertToCreate;
+    protected persistRun(_run: Run): Promise<void>;
+    onRunCreate(run: Run): Promise<void>;
+    onRunUpdate(run: Run): Promise<void>;
+    getRun(id: string): Run | undefined;
+    updateFromRunTree(runTree: RunTree): void;
+    convertToRunTree(id: string): RunTree | undefined;
+    static getTraceableRunTree(): RunTree | undefined;
+}

package/dist/node_modules/@langchain/core/dist/tracers/tracer_langchain.js

@@ -0,0 +1,156 @@
+import { RunTree } from "langsmith/run_trees";
+import { getCurrentRunTree } from "langsmith/singletons/traceable";
+import { getEnvironmentVariable, getRuntimeEnvironment } from "../utils/env.js";
+import { BaseTracer } from "./base.js";
+import { getDefaultLangChainClientSingleton } from "../singletons/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 ?? getDefaultLangChainClientSingleton();
+        const traceableTree = LangChainTracer.getTraceableRunTree();
+        if (traceableTree) {
+            this.updateFromRunTree(traceableTree);
+        }
+    }
+    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 onRunCreate(run) {
+        const persistedRun = await this._convertToCreate(run, this.exampleId);
+        await this.client.createRun(persistedRun);
+    }
+    async onRunUpdate(run) {
+        const runUpdate = {
+            end_time: run.end_time,
+            error: run.error,
+            outputs: run.outputs,
+            events: run.events,
+            inputs: run.inputs,
+            trace_id: run.trace_id,
+            dotted_order: run.dotted_order,
+            parent_run_id: run.parent_run_id,
+            extra: run.extra,
+        };
+        await this.client.updateRun(run.id, runUpdate);
+    }
+    getRun(id) {
+        return this.runMap.get(id);
+    }
+    updateFromRunTree(runTree) {
+        let rootRun = runTree;
+        const visited = new Set();
+        while (rootRun.parent_run) {
+            if (visited.has(rootRun.id))
+                break;
+            visited.add(rootRun.id);
+            if (!rootRun.parent_run)
+                break;
+            rootRun = rootRun.parent_run;
+        }
+        visited.clear();
+        const queue = [rootRun];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (!current || visited.has(current.id))
+                continue;
+            visited.add(current.id);
+            // @ts-expect-error Types of property 'events' are incompatible.
+            this.runMap.set(current.id, current);
+            if (current.child_runs) {
+                queue.push(...current.child_runs);
+            }
+        }
+        this.client = runTree.client ?? this.client;
+        this.projectName = runTree.project_name ?? this.projectName;
+        this.exampleId = runTree.reference_example_id ?? this.exampleId;
+    }
+    convertToRunTree(id) {
+        const runTreeMap = {};
+        const runTreeList = [];
+        for (const [id, run] of this.runMap) {
+            // by converting the run map to a run tree, we are doing a copy
+            // thus, any mutation performed on the run tree will not be reflected
+            // back in the run map
+            // TODO: Stop using `this.runMap` in favour of LangSmith's `RunTree`
+            const runTree = new RunTree({
+                ...run,
+                child_runs: [],
+                parent_run: undefined,
+                // inherited properties
+                client: this.client,
+                project_name: this.projectName,
+                reference_example_id: this.exampleId,
+                tracingEnabled: true,
+            });
+            runTreeMap[id] = runTree;
+            runTreeList.push([id, run.dotted_order]);
+        }
+        runTreeList.sort((a, b) => {
+            if (!a[1] || !b[1])
+                return 0;
+            return a[1].localeCompare(b[1]);
+        });
+        for (const [id] of runTreeList) {
+            const run = this.runMap.get(id);
+            const runTree = runTreeMap[id];
+            if (!run || !runTree)
+                continue;
+            if (run.parent_run_id) {
+                const parentRunTree = runTreeMap[run.parent_run_id];
+                if (parentRunTree) {
+                    parentRunTree.child_runs.push(runTree);
+                    runTree.parent_run = parentRunTree;
+                }
+            }
+        }
+        return runTreeMap[id];
+    }
+    static getTraceableRunTree() {
+        try {
+            return getCurrentRunTree();
+        }
+        catch {
+            return undefined;
+        }
+    }
+}

package/dist/node_modules/@langchain/core/dist/tracers/tracer_langchain_v1.cjs

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LangChainTracerV1 = void 0;
+const utils_js_1 = require("../messages/utils.cjs");
+const env_js_1 = require("../utils/env.cjs");
+const base_js_1 = require("./base.cjs");
+/** @deprecated Use LangChainTracer instead. */
+class LangChainTracerV1 extends base_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, utils_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/node_modules/@langchain/core/dist/tracers/tracer_langchain_v1.d.ts

@@ -0,0 +1,59 @@
+import type { ChainValues } from "../utils/types/index.js";
+import type { LLMResult } from "../outputs.js";
+import { BaseTracer, type RunType, type Run } from "./base.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;
+}
+/** @deprecated Use LangChainTracer instead. */
+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>;
+}