n8n-nodes-roundrobin
Version:
n8n node to store and retrieve messages in a round-robin fashion, particularly for LLM conversation loops with multiple personas
131 lines • 6.59 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.createStorageManager = exports.ExternalStorageManager = void 0;
const n8n_workflow_1 = require("n8n-workflow");
class ExternalStorageManager {
constructor(executeFunctions, storageType, storageId) {
this.executeFunctions = executeFunctions;
this.storageType = storageType;
this.storageId = storageId;
}
async storeToBinary(messages, roles, spotCount, metrics) {
try {
const storageData = {
messages,
roles,
spotCount,
lastUpdated: Date.now(),
roundCount: (metrics === null || metrics === void 0 ? void 0 : metrics.roundCount) || 0,
maxRounds: (metrics === null || metrics === void 0 ? void 0 : metrics.maxRounds) || 0,
...(metrics || {})
};
const jsonData = JSON.stringify(storageData);
const binaryPropertyName = this.executeFunctions.getNodeParameter('binaryOutputProperty', 0, 'data');
const binaryData = await this.executeFunctions.helpers.prepareBinaryData(Buffer.from(jsonData), `roundrobin_${this.storageId}.json`, 'application/json');
const newItem = {
json: {
success: true,
storageType: 'binary',
storageId: this.storageId,
lastUpdated: new Date().toISOString(),
messageCount: messages.length,
rolesCount: roles.length,
roundCount: (metrics === null || metrics === void 0 ? void 0 : metrics.roundCount) || 0,
maxRounds: (metrics === null || metrics === void 0 ? void 0 : metrics.maxRounds) || 0,
roundsRemaining: (metrics === null || metrics === void 0 ? void 0 : metrics.maxRounds) && (metrics === null || metrics === void 0 ? void 0 : metrics.maxRounds) > 0
? Math.max(0, metrics.maxRounds - (metrics.roundCount || 0))
: null,
},
binary: {
[binaryPropertyName]: binaryData
},
};
return newItem;
}
catch (error) {
throw new n8n_workflow_1.NodeOperationError(this.executeFunctions.getNode(), `Failed to store data in binary: ${error.message}`);
}
}
async loadFromBinary(binaryData) {
try {
const binaryPropertyName = this.executeFunctions.getNodeParameter('binaryInputProperty', 0, 'data');
if (!binaryData || !binaryData[binaryPropertyName]) {
console.log(`[Binary Storage] No binary data found with property name '${binaryPropertyName}'`);
const availableBinaryProperties = Object.keys(binaryData || {});
console.log(`[Binary Storage] Available binary properties: ${availableBinaryProperties.join(', ') || 'none'}`);
if (availableBinaryProperties.length > 0) {
const fallbackProperty = availableBinaryProperties[0];
console.log(`[Binary Storage] Trying fallback binary property: ${fallbackProperty}`);
const fallbackBinaryProperty = binaryData[fallbackProperty];
if (fallbackBinaryProperty && fallbackBinaryProperty.data) {
const fallbackBinaryString = Buffer.from(fallbackBinaryProperty.data, 'base64').toString();
try {
const fallbackData = JSON.parse(fallbackBinaryString);
if (fallbackData.messages) {
console.log(`[Binary Storage] Successfully loaded data from fallback property: ${fallbackProperty}`);
return {
messages: fallbackData.messages || [],
roles: fallbackData.roles || [],
spotCount: fallbackData.spotCount || 0,
lastUpdated: fallbackData.lastUpdated || 0,
roundCount: fallbackData.roundCount || 0,
maxRounds: fallbackData.maxRounds || 0
};
}
}
catch (parseError) {
console.log(`[Binary Storage] Failed to parse JSON from fallback binary property: ${parseError.message}`);
}
}
}
return {
messages: [],
roles: [],
spotCount: 0,
lastUpdated: 0,
roundCount: 0,
maxRounds: 0
};
}
const binaryProperty = binaryData[binaryPropertyName];
if (!binaryProperty || !binaryProperty.data) {
console.log(`[Binary Storage] Binary property exists but contains no data`);
return {
messages: [],
roles: [],
spotCount: 0,
lastUpdated: 0,
roundCount: 0,
maxRounds: 0
};
}
const binaryString = Buffer.from(binaryProperty.data, 'base64').toString();
const storageData = JSON.parse(binaryString);
return {
messages: storageData.messages || [],
roles: storageData.roles || [],
spotCount: storageData.spotCount || 0,
lastUpdated: storageData.lastUpdated || 0,
roundCount: storageData.roundCount || 0,
maxRounds: storageData.maxRounds || 0
};
}
catch (error) {
console.log(`[Binary Storage] Error loading data: ${error.message}`);
return {
messages: [],
roles: [],
spotCount: 0,
lastUpdated: 0,
roundCount: 0,
maxRounds: 0
};
}
}
}
exports.ExternalStorageManager = ExternalStorageManager;
function createStorageManager(executeFunctions, storageType = 'binary', storageId = 'default') {
return new ExternalStorageManager(executeFunctions, storageType, storageId);
}
exports.createStorageManager = createStorageManager;
//# sourceMappingURL=ExternalStorage.js.map