@n8n/n8n-nodes-langchain
Version:
201 lines • 9.27 kB
JavaScript
;
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.hasGatedToolNodeName = hasGatedToolNodeName;
exports.extractHitlMetadata = extractHitlMetadata;
exports.buildHitlNodeInput = buildHitlNodeInput;
exports.createEngineRequests = createEngineRequests;
const is_record_1 = require("@n8n/utils/is-record");
const isObject_1 = __importDefault(require("lodash/isObject"));
const pick_1 = __importDefault(require("lodash/pick"));
const n8n_workflow_1 = require("n8n-workflow");
const types_1 = require("./types");
function hasGatedToolNodeName(metadata) {
return ((0, isObject_1.default)(metadata) &&
typeof metadata.gatedToolNodeName === 'string');
}
function extractHitlMetadata(metadata, toolName, toolInput) {
if (!hasGatedToolNodeName(metadata))
return undefined;
return {
gatedToolNodeName: metadata.gatedToolNodeName,
toolName,
originalInput: toolInput.toolParameters,
};
}
function getSchemaKeys(schema) {
if (!(0, is_record_1.isRecord)(schema))
return undefined;
if ((0, is_record_1.isRecord)(schema.shape))
return Object.keys(schema.shape);
if ((0, is_record_1.isRecord)(schema.properties))
return Object.keys(schema.properties);
return undefined;
}
function getDeclaredHitlKeys(schema) {
if (!(0, is_record_1.isRecord)(schema))
return undefined;
const fields = (0, is_record_1.isRecord)(schema.shape) ? schema.shape : schema.properties;
return (0, is_record_1.isRecord)(fields) ? getSchemaKeys(fields.hitlParameters) : undefined;
}
function buildHitlNodeInput(tool, hitlParameters, toolName, toolParameters) {
const declaredKeys = getDeclaredHitlKeys(tool.schema);
const declared = (0, isObject_1.default)(hitlParameters)
? declaredKeys
? (0, pick_1.default)(hitlParameters, declaredKeys)
: { ...hitlParameters }
: {};
if ((0, isObject_1.default)(declared.query))
delete declared.query;
return { ...declared, tool: toolName, toolParameters };
}
function extractThinkingMetadata(toolCall, sharedMessageLog, sharedAdditionalKwargs) {
const result = {};
const effectiveAdditionalKwargs = toolCall.additionalKwargs ?? sharedAdditionalKwargs;
const effectiveMessageLog = toolCall.messageLog && toolCall.messageLog.length > 0 ? toolCall.messageLog : sharedMessageLog;
let thoughtSignature;
if (effectiveAdditionalKwargs) {
const geminiSignatures = effectiveAdditionalKwargs['__gemini_function_call_thought_signatures__'];
if (geminiSignatures && typeof geminiSignatures === 'object') {
thoughtSignature =
geminiSignatures[toolCall.toolCallId] || Object.values(geminiSignatures)[0];
}
if (!thoughtSignature) {
const signatures = effectiveAdditionalKwargs.signatures;
if (signatures && Array.isArray(signatures) && signatures.length > 0) {
thoughtSignature = signatures.find((s) => s && s.length > 0);
}
}
}
let reasoningContent;
if (effectiveAdditionalKwargs) {
const rc = effectiveAdditionalKwargs.reasoning_content;
if (typeof rc === 'string' && rc.length > 0)
reasoningContent = rc;
}
let thinkingContent;
let thinkingType;
let thinkingSignature;
if (effectiveMessageLog && Array.isArray(effectiveMessageLog)) {
for (const message of effectiveMessageLog) {
if (message && typeof message === 'object' && 'content' in message) {
const content = message.content;
if (Array.isArray(content)) {
for (const block of content) {
if (!thoughtSignature && (0, types_1.isGeminiThoughtSignatureBlock)(block)) {
thoughtSignature = block.thoughtSignature;
}
if ((0, types_1.isThinkingBlock)(block)) {
thinkingContent = block.thinking;
thinkingType = 'thinking';
thinkingSignature = block.signature;
}
else if ((0, types_1.isRedactedThinkingBlock)(block)) {
thinkingContent = block.data;
thinkingType = 'redacted_thinking';
}
}
}
if (!thoughtSignature && 'additional_kwargs' in message) {
const msgAdditionalKwargs = message.additional_kwargs;
if (msgAdditionalKwargs) {
const geminiSignatures = msgAdditionalKwargs['__gemini_function_call_thought_signatures__'];
if (geminiSignatures && typeof geminiSignatures === 'object') {
thoughtSignature =
geminiSignatures[toolCall.toolCallId] || Object.values(geminiSignatures)[0];
}
if (!thoughtSignature) {
const signatures = msgAdditionalKwargs.signatures;
const msgToolCalls = 'tool_calls' in message
? message.tool_calls
: undefined;
if (signatures && Array.isArray(signatures)) {
if (msgToolCalls && Array.isArray(msgToolCalls)) {
const toolCallIndex = msgToolCalls.findIndex((tc) => tc.id === toolCall.toolCallId);
if (toolCallIndex > 0 && toolCallIndex < signatures.length) {
thoughtSignature = signatures[toolCallIndex];
}
}
thoughtSignature ??= signatures.find((s) => s && s.length > 0);
}
}
}
}
if (!reasoningContent && 'additional_kwargs' in message) {
const msgAdditionalKwargs = message.additional_kwargs;
const rc = msgAdditionalKwargs?.reasoning_content;
if (typeof rc === 'string' && rc.length > 0)
reasoningContent = rc;
}
if (thoughtSignature || thinkingContent !== undefined || reasoningContent)
break;
}
}
}
if (thoughtSignature) {
result.google = { thoughtSignature };
}
if (thinkingContent !== undefined && thinkingType) {
result.anthropic = {
thinkingContent,
thinkingType,
...(thinkingSignature ? { thinkingSignature } : {}),
};
}
if (reasoningContent) {
result.deepseek = { reasoningContent };
}
return result;
}
function createEngineRequests(toolCalls, itemIndex, tools) {
const sharedMessageLog = toolCalls.find((tc) => tc.messageLog && tc.messageLog.length > 0)?.messageLog;
const sharedAdditionalKwargs = toolCalls.find((tc) => tc.additionalKwargs)?.additionalKwargs;
return toolCalls
.map((toolCall) => {
const foundTool = tools.find((tool) => tool.name === toolCall.tool);
if (!foundTool)
return undefined;
const nodeName = foundTool.metadata?.sourceNodeName;
if (typeof nodeName !== 'string')
return undefined;
const metadata = (foundTool.metadata ?? {});
const toolInput = toolCall.toolInput;
const hitlMetadata = extractHitlMetadata(metadata, toolCall.tool, toolInput);
let input = toolInput;
if (metadata.isFromToolkit) {
input = { ...input };
delete input[types_1.INTERNAL_TOOL_ARG_STASH_KEY];
if (metadata.isMcpTool) {
const stashedArguments = {};
if ('tool' in input)
stashedArguments.tool = input.tool;
if ('toolCallId' in input)
stashedArguments.toolCallId = input.toolCallId;
if (Object.keys(stashedArguments).length > 0) {
input[types_1.INTERNAL_TOOL_ARG_STASH_KEY] = stashedArguments;
}
}
input.tool = toolCall.tool;
}
if (hitlMetadata) {
input = buildHitlNodeInput(foundTool, toolInput.hitlParameters, toolCall.tool, hitlMetadata.originalInput);
}
return {
actionType: 'ExecutionNodeAction',
nodeName,
input,
type: n8n_workflow_1.NodeConnectionTypes.AiTool,
id: toolCall.toolCallId,
metadata: {
itemIndex,
hitl: hitlMetadata,
toolName: toolCall.tool,
...extractThinkingMetadata(toolCall, sharedMessageLog, sharedAdditionalKwargs),
},
};
})
.filter((item) => item !== undefined);
}
//# sourceMappingURL=createEngineRequests.js.map