@n8n/n8n-nodes-langchain
Version:
381 lines • 14.2 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.MlflowSpanCollector = void 0;
const base_1 = require("@langchain/core/callbacks/base");
const messages_1 = require("@langchain/core/messages");
const is_record_1 = require("@n8n/utils/is-record");
const sanitize_error_detail_1 = require("@n8n/utils/redaction/sanitize-error-detail");
const scrub_secrets_1 = require("@n8n/utils/scrub-secrets");
const node_crypto_1 = require("node:crypto");
const tool_error_result_1 = require("../../../../utils/tool-error-result");
const types_1 = require("./types");
const MAX_ATTRIBUTE_CHARS = 100_000;
const MAX_STRING_CHARS = 4_000;
const MAX_ERROR_CHARS = 2_000;
const TRACE_ID_BYTES = 16;
const SPAN_ID_BYTES = 8;
const UNINTERESTING_INPUT_KEYS = [
'formatting_instructions',
'agent_scratchpad',
'chat_history',
'steps',
];
const ECHOED_OUTPUT_KEYS = [...UNINTERESTING_INPUT_KEYS, 'input', 'system_message'];
function randomTraceId() {
const raw = (0, node_crypto_1.randomBytes)(TRACE_ID_BYTES);
return { traceId: `tr-${raw.toString('hex')}`, spanTraceId: raw.toString('base64') };
}
function randomSpanId() {
return (0, node_crypto_1.randomBytes)(SPAN_ID_BYTES).toString('base64');
}
function toNanos(ms) {
return `${ms}000000`;
}
function serializedName(serialized, fallback) {
const id = serialized?.id;
return (Array.isArray(id) ? id.at(-1) : undefined) ?? fallback;
}
function stringifySafely(value) {
const ancestors = [];
const json = JSON.stringify(value, function (_key, raw) {
if (raw === null || typeof raw !== 'object')
return raw;
while (ancestors.length > 0 && ancestors.at(-1) !== this)
ancestors.pop();
if (ancestors.includes(raw))
return '[circular]';
ancestors.push(raw);
return raw;
});
return json ?? 'null';
}
function capStrings(value, seen) {
if (typeof value === 'string') {
return value.length > MAX_STRING_CHARS
? `${value.slice(0, MAX_STRING_CHARS)}…[truncated ${value.length} chars]`
: value;
}
if (value === null || typeof value !== 'object')
return value;
if (seen.has(value))
return '[circular]';
seen.add(value);
try {
if (Array.isArray(value))
return value.map((entry) => capStrings(entry, seen));
return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, capStrings(entry, seen)]));
}
finally {
seen.delete(value);
}
}
function toAttributeJson(value) {
const full = (0, scrub_secrets_1.scrubSecretsInText)(stringifySafely(value));
if (full.length <= MAX_ATTRIBUTE_CHARS)
return full;
const capped = (0, scrub_secrets_1.scrubSecretsInText)(stringifySafely(capStrings(value, new Set())));
if (capped.length <= MAX_ATTRIBUTE_CHARS)
return capped;
return JSON.stringify({ truncated: true, original_size_chars: full.length });
}
function errorMessage(error) {
const raw = error instanceof Error ? error.message : String(error);
return (0, sanitize_error_detail_1.sanitizeErrorDetail)(raw, MAX_ERROR_CHARS);
}
function firstNumber(...candidates) {
return candidates.find((c) => typeof c === 'number' && Number.isFinite(c));
}
function readUsage(raw) {
if (!(0, is_record_1.isRecord)(raw))
return undefined;
const input = firstNumber(raw.promptTokens, raw.input_tokens, raw.prompt_tokens);
const output = firstNumber(raw.completionTokens, raw.output_tokens, raw.completion_tokens);
if (input === undefined && output === undefined)
return undefined;
const inputTokens = input ?? 0;
const outputTokens = output ?? 0;
return {
inputTokens,
outputTokens,
totalTokens: firstNumber(raw.totalTokens, raw.total_tokens) ?? inputTokens + outputTokens,
};
}
function extractTokenUsage(output) {
const fromLlmOutput = readUsage(output.llmOutput?.tokenUsage) ?? readUsage(output.llmOutput?.usage);
if (fromLlmOutput)
return fromLlmOutput;
for (const generation of output.generations.flat()) {
const usage = readUsage(generation.generationInfo?.usage);
if (usage)
return usage;
}
return undefined;
}
function toOpenAiRole(type) {
switch (type) {
case 'human':
return 'user';
case 'ai':
return 'assistant';
default:
return type;
}
}
function toChatMessage(message) {
const converted = {
role: toOpenAiRole(message.type),
content: message.content,
};
if ('tool_calls' in message && Array.isArray(message.tool_calls)) {
converted.tool_calls = message.tool_calls.map((call) => ({
id: call.id,
type: 'function',
function: { name: call.name, arguments: JSON.stringify(call.args ?? {}) },
}));
}
if ('tool_call_id' in message && typeof message.tool_call_id === 'string') {
converted.tool_call_id = message.tool_call_id;
}
return converted;
}
function toChatCompletion(output) {
return {
choices: output.generations.flat().map((generation) => {
const message = (0, is_record_1.isRecord)(generation) ? generation.message : undefined;
return {
message: messages_1.BaseMessage.isInstance(message)
? toChatMessage(message)
: { role: 'assistant', content: generation.text },
finish_reason: generation.generationInfo?.finish_reason,
};
}),
};
}
function withoutKeys(values, drop) {
return Object.fromEntries(Object.entries(values).filter(([key]) => !drop.includes(key)));
}
class MlflowSpanCollector extends base_1.BaseCallbackHandler {
constructor() {
super();
this.name = 'MlflowSpanCollector';
this.awaitHandlers = true;
this.spans = new Map();
this.parentOf = new Map();
this.runOrder = [];
this.openRuns = new Set();
this.lastActivityMs = 0;
const ids = randomTraceId();
this.traceId = ids.traceId;
this.spanTraceId = ids.spanTraceId;
}
nearestKeptAncestor(runId) {
let cursor = runId;
const guard = new Set();
while (cursor !== undefined && !guard.has(cursor)) {
guard.add(cursor);
const span = this.spans.get(cursor);
if (span)
return span;
cursor = this.parentOf.get(cursor);
}
return undefined;
}
captureRunMetadata(metadata) {
if (!(0, is_record_1.isRecord)(metadata))
return;
if (typeof metadata.execution_id === 'string')
this.executionId ??= metadata.execution_id;
if (typeof metadata.node === 'string')
this.nodeName ??= metadata.node;
if ((0, is_record_1.isRecord)(metadata.workflow) && typeof metadata.workflow.id === 'string') {
this.workflowId ??= metadata.workflow.id;
}
}
startSpan(params) {
const { runId, parentRunId, name, spanType, inputs } = params;
if (this.spans.has(runId))
return;
const startTimeMs = Date.now();
this.startedAtMs ??= startTimeMs;
this.lastActivityMs = startTimeMs;
const span = {
trace_id: this.spanTraceId,
span_id: randomSpanId(),
parent_span_id: this.nearestKeptAncestor(parentRunId)?.span_id,
name,
start_time_unix_nano: toNanos(startTimeMs),
end_time_unix_nano: toNanos(startTimeMs),
status: { code: 'OK' },
attributes: {
[types_1.MLFLOW_ATTRIBUTE.SpanType]: toAttributeJson(spanType),
[types_1.MLFLOW_ATTRIBUTE.TraceRequestId]: toAttributeJson(this.traceId),
[types_1.MLFLOW_ATTRIBUTE.SpanInputs]: toAttributeJson(inputs),
...(params.messageFormat && {
[types_1.MLFLOW_ATTRIBUTE.MessageFormat]: types_1.MLFLOW_MESSAGE_FORMAT,
}),
},
};
this.spans.set(runId, span);
this.runOrder.push(runId);
this.openRuns.add(runId);
}
closeSpan(runId) {
const span = this.spans.get(runId);
if (!span)
return undefined;
const now = Date.now();
this.lastActivityMs = now;
span.end_time_unix_nano = toNanos(now);
this.openRuns.delete(runId);
return span;
}
endSpan(runId, outputs, tokenUsage) {
const span = this.closeSpan(runId);
if (!span)
return;
span.attributes[types_1.MLFLOW_ATTRIBUTE.SpanOutputs] = toAttributeJson(outputs);
if (tokenUsage) {
this.addTokenUsage(tokenUsage);
span.attributes[types_1.MLFLOW_ATTRIBUTE.TokenUsage] = toAttributeJson({
input_tokens: tokenUsage.inputTokens,
output_tokens: tokenUsage.outputTokens,
total_tokens: tokenUsage.totalTokens,
});
}
}
addTokenUsage(usage) {
this.tokenUsage = {
inputTokens: (this.tokenUsage?.inputTokens ?? 0) + usage.inputTokens,
outputTokens: (this.tokenUsage?.outputTokens ?? 0) + usage.outputTokens,
totalTokens: (this.tokenUsage?.totalTokens ?? 0) + usage.totalTokens,
};
}
failSpan(runId, error) {
const span = this.closeSpan(runId);
if (!span)
return;
span.status = { code: 'ERROR', message: errorMessage(error) };
}
handleChainStart(_chain, inputs, runId, parentRunId, _tags, metadata, _runType, runName) {
this.parentOf.set(runId, parentRunId);
this.captureRunMetadata(metadata);
if (this.rootRunId !== undefined)
return;
this.rootRunId = runId;
this.startSpan({
runId,
parentRunId: undefined,
name: runName ?? 'Agent',
spanType: types_1.MLFLOW_SPAN_TYPE.Agent,
inputs: withoutKeys(inputs, UNINTERESTING_INPUT_KEYS),
});
if (typeof inputs.input === 'string')
this.requestPreview = inputs.input;
}
handleChainEnd(outputs, runId) {
if (runId !== this.rootRunId)
return;
if (typeof outputs.output === 'string')
this.responsePreview = outputs.output;
this.endSpan(runId, withoutKeys(outputs, ECHOED_OUTPUT_KEYS));
}
handleChainError(error, runId) {
this.failSpan(runId, error);
}
handleChatModelStart(llm, messages, runId, parentRunId, _extraParams, _tags, metadata, runName) {
this.parentOf.set(runId, parentRunId);
this.captureRunMetadata(metadata);
this.startSpan({
runId,
parentRunId,
name: runName ?? serializedName(llm, 'chat model'),
spanType: types_1.MLFLOW_SPAN_TYPE.ChatModel,
inputs: { messages: messages.flat().map(toChatMessage) },
messageFormat: true,
});
}
handleLLMStart(llm, prompts, runId, parentRunId, _extraParams, _tags, metadata, runName) {
this.parentOf.set(runId, parentRunId);
this.captureRunMetadata(metadata);
this.startSpan({
runId,
parentRunId,
name: runName ?? serializedName(llm, 'model'),
spanType: types_1.MLFLOW_SPAN_TYPE.Llm,
inputs: prompts,
});
}
handleLLMEnd(output, runId) {
this.endSpan(runId, toChatCompletion(output), extractTokenUsage(output));
}
handleLLMError(error, runId) {
this.failSpan(runId, error);
}
handleToolStart(tool, input, runId, parentRunId, _tags, metadata, runName) {
this.parentOf.set(runId, parentRunId);
this.captureRunMetadata(metadata);
this.startSpan({
runId,
parentRunId,
name: runName ?? serializedName(tool, 'tool'),
spanType: types_1.MLFLOW_SPAN_TYPE.Tool,
inputs: input,
});
}
handleToolEnd(output, runId) {
this.endSpan(runId, output);
if (typeof output === 'string' && (0, tool_error_result_1.isToolErrorResult)(output))
this.failSpan(runId, output);
}
handleToolError(error, runId) {
this.failSpan(runId, error);
}
handleRetrieverStart(retriever, query, runId, parentRunId, _tags, metadata, name) {
this.parentOf.set(runId, parentRunId);
this.captureRunMetadata(metadata);
this.startSpan({
runId,
parentRunId,
name: name ?? serializedName(retriever, 'retriever'),
spanType: types_1.MLFLOW_SPAN_TYPE.Retriever,
inputs: query,
});
}
handleRetrieverEnd(documents, runId) {
this.endSpan(runId, documents);
}
handleRetrieverError(error, runId) {
this.failSpan(runId, error);
}
finish() {
const root = this.rootRunId === undefined ? undefined : this.spans.get(this.rootRunId);
if (!root || this.startedAtMs === undefined)
return undefined;
const spans = this.runOrder
.map((runId) => this.spans.get(runId))
.filter((span) => span !== undefined);
const endTimeMs = Math.max(this.lastActivityMs, this.startedAtMs);
const endNanos = toNanos(endTimeMs);
for (const runId of this.openRuns) {
const span = this.spans.get(runId);
if (span)
span.end_time_unix_nano = endNanos;
}
return {
traceId: this.traceId,
rootSpanId: root.span_id,
spans,
startTimeMs: this.startedAtMs,
endTimeMs,
state: root.status.code,
tokenUsage: this.tokenUsage,
executionId: this.executionId,
workflowId: this.workflowId,
nodeName: this.nodeName,
requestPreview: this.requestPreview,
responsePreview: this.responsePreview,
};
}
}
exports.MlflowSpanCollector = MlflowSpanCollector;
//# sourceMappingURL=span-collector.js.map