@langchain/core
Version:
Core LangChain.js abstractions and schemas
197 lines (196 loc) • 7.17 kB
JavaScript
import { getBufferString } from "../messages/utils.js";
import { getEnvironmentVariable } from "../utils/env.js";
import { BaseTracer } from "./base.js";
/** @deprecated Use LangChainTracer instead. */
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;
}
}