@n8n/n8n-nodes-langchain
Version:
203 lines • 8.56 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.DatabricksAiAgent = void 0;
const sanitize_error_detail_1 = require("@n8n/utils/redaction/sanitize-error-detail");
const n8n_workflow_1 = require("n8n-workflow");
const descriptions_1 = require("../../../utils/descriptions");
const description_1 = require("../../agents/Agent/agents/ToolsAgent/V2/description");
const execute_1 = require("../../agents/Agent/agents/ToolsAgent/V2/execute");
const utils_1 = require("../../agents/Agent/utils");
const span_collector_1 = require("./mlflow/span-collector");
const trace_writer_1 = require("./mlflow/trace-writer");
const transport_1 = require("./mlflow/transport");
const MAX_LOGGED_ERROR_CHARS = 1_000;
function sanitizedErrorMessage(error) {
const message = error instanceof Error ? error.message : String(error);
return (0, sanitize_error_detail_1.sanitizeErrorDetail)(message, MAX_LOGGED_ERROR_CHARS);
}
const exportTracesField = {
displayName: 'Export Traces to MLflow',
name: 'exportTraces',
type: 'boolean',
default: false,
noDataExpression: true,
description: 'Whether to send each run to MLflow Tracing in your Databricks workspace. Needs the Databricks credential above. Traces include prompts, model outputs and tool results.',
};
const experimentField = {
displayName: 'Experiment',
name: 'experiment',
type: 'resourceLocator',
default: { mode: 'name', value: '' },
displayOptions: { show: { exportTraces: [true] } },
description: 'Where traces are stored. Leave the name empty to create one for this workflow automatically.',
modes: [
{
displayName: 'By Name',
name: 'name',
type: 'string',
placeholder: '/Shared/my-agent-traces',
hint: 'Created if it does not exist. Empty means /Shared/n8n-workflows-<workflow ID>.',
},
{
displayName: 'By ID',
name: 'id',
type: 'string',
placeholder: '822142731468161',
},
],
};
async function prepareTraceExport(ctx) {
try {
const credential = await ctx.getCredentials('databricksOAuth2Api');
const { request, upload } = (0, transport_1.createMlflowTransport)(ctx, credential);
const experiment = ctx.getNodeParameter('experiment', 0, { mode: 'name', value: '' });
if (experiment.mode === 'id' && experiment.value) {
return { request, upload, experimentId: experiment.value };
}
const name = experiment.value || (0, trace_writer_1.defaultExperimentName)(ctx.getWorkflow().id ?? 'unknown');
return { request, upload, experimentId: await (0, trace_writer_1.ensureExperiment)(request, name) };
}
catch (error) {
ctx.logger.warn(`Databricks AI Agent: could not prepare MLflow trace export: ${sanitizedErrorMessage(error)}`);
return undefined;
}
}
async function flushTrace(ctx, exporter, collector) {
const trace = collector.finish();
if (!trace)
return;
try {
await (0, trace_writer_1.writeTrace)(exporter, trace);
}
catch (error) {
ctx.logger.warn(`Databricks AI Agent: MLflow trace export failed: ${sanitizedErrorMessage(error)}`);
}
}
class DatabricksAiAgent {
constructor() {
this.description = {
displayName: 'Databricks AI Agent',
name: 'databricksAiAgent',
icon: { light: 'file:databricks.svg', dark: 'file:databricks.dark.svg' },
group: ['transform'],
version: [2.2],
description: 'An AI agent that exports its runs to MLflow Tracing in Databricks',
defaults: {
name: 'Databricks AI Agent',
},
codex: {
categories: ['AI'],
subcategories: {
AI: ['Agents', 'Root Nodes'],
},
resources: {
primaryDocumentation: [
{
url: 'https://docs.n8n.io/integrations/builtin/cluster-nodes/root-nodes/n8n-nodes-langchain.databricksaiagent/',
},
],
},
},
inputs: `={{
((hasOutputParser, needsFallback) => {
${utils_1.getInputs.toString()};
return getInputs(true, hasOutputParser, needsFallback);
})($parameter.hasOutputParser === undefined || $parameter.hasOutputParser === true, $parameter.needsFallback !== undefined && $parameter.needsFallback === true)
}}`,
outputs: [n8n_workflow_1.NodeConnectionTypes.Main],
credentials: [
{
name: 'databricksOAuth2Api',
required: false,
},
],
properties: [
descriptions_1.promptTypeOptions,
{
...descriptions_1.textFromPreviousNode,
displayOptions: { show: { promptType: ['auto'] } },
},
{
...descriptions_1.textInput,
displayOptions: { show: { promptType: ['define'] } },
},
{
displayName: 'Require Specific Output Format',
name: 'hasOutputParser',
type: 'boolean',
default: false,
noDataExpression: true,
},
{
displayName: `Connect an <a data-action='openSelectiveNodeCreator' data-action-parameter-connectiontype='${n8n_workflow_1.NodeConnectionTypes.AiOutputParser}'>output parser</a> on the canvas to specify the output format you require`,
name: 'notice',
type: 'notice',
default: '',
displayOptions: {
show: {
hasOutputParser: [true],
},
},
},
{
displayName: 'Enable Fallback Model',
name: 'needsFallback',
type: 'boolean',
default: false,
noDataExpression: true,
displayOptions: {
show: {
'@version': [{ _cnd: { gte: 2.1 } }],
},
},
},
{
displayName: 'Connect an additional language model on the canvas to use it as a fallback if the main model fails',
name: 'fallbackNotice',
type: 'notice',
default: '',
displayOptions: {
show: {
needsFallback: [true],
},
},
},
exportTracesField,
experimentField,
...(0, description_1.getToolsAgentProperties)({ withStreaming: true }),
],
};
}
async execute() {
const exportTraces = this.getNodeParameter('exportTraces', 0, false);
if (!exportTraces) {
return await execute_1.toolsAgentExecute.call(this);
}
if (!this.getNode().credentials?.databricksOAuth2Api) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Select a Databricks credential to export traces to MLflow', {
description: '"Export Traces to MLflow" is on, but this node has no credential selected.',
});
}
const exporter = await prepareTraceExport(this);
if (!exporter) {
return await execute_1.toolsAgentExecute.call(this);
}
const collectors = new Map();
return await execute_1.toolsAgentExecute.call(this, {
createCallbacks: (itemIndex) => {
const collector = new span_collector_1.MlflowSpanCollector();
collectors.set(itemIndex, collector);
return [collector];
},
onItemFinished: async (itemIndex) => {
const collector = collectors.get(itemIndex);
if (!collector)
return;
collectors.delete(itemIndex);
await flushTrace(this, exporter, collector);
},
});
}
}
exports.DatabricksAiAgent = DatabricksAiAgent;
//# sourceMappingURL=DatabricksAiAgent.node.js.map