n8n-nodes-vercel-ai-sdk-universal-temp 0.3.3 → 0.3.4

package/dist/nodes/UniversalAgent/UniversalAgent.node.js

@@ -2,10 +2,24 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UniversalAgent = void 0;
 const n8n_workflow_1 = require("n8n-workflow");
-const descriptions_1 = require("../shared/descriptions");
-const letta_1 = require("../shared/letta");
+const UniversalAgentDescription_1 = require("./UniversalAgentDescription");
 const load_options_1 = require("../shared/letta/load-options");
-const nodeDescription = descriptions_1.UNIVERSAL_AGENT_DESCRIPTION;
+const chat_handler_1 = require("./handlers/chat.handler");
+const agent_handler_1 = require("./handlers/agent.handler");
+const identity_handler_1 = require("./handlers/identity.handler");
+const tools_handler_1 = require("./handlers/tools.handler");
+const blocks_handler_1 = require("./handlers/blocks.handler");
+const folders_handler_1 = require("./handlers/folders.handler");
+const mcp_handler_1 = require("./handlers/mcp.handler");
+const models_handler_1 = require("./handlers/models.handler");
+const archives_handler_1 = require("./handlers/archives.handler");
+const batches_handler_1 = require("./handlers/batches.handler");
+const groups_handler_1 = require("./handlers/groups.handler");
+const runs_handler_1 = require("./handlers/runs.handler");
+const steps_handler_1 = require("./handlers/steps.handler");
+const tags_handler_1 = require("./handlers/tags.handler");
+const templates_handler_1 = require("./handlers/templates.handler");
+const nodeDescription = UniversalAgentDescription_1.UNIVERSAL_AGENT_DESCRIPTION;
 class UniversalAgent {
     constructor() {
         this.description = nodeDescription;
@@ -23,183 +37,20 @@ class UniversalAgent {
             },
         };
     }
-    static extractTextFromLettaMessages(messages) {
-        if (!messages)
-            return '';
-        if (!Array.isArray(messages)) {
-            return UniversalAgent.extractTextFromLettaMessage(messages);
-        }
-        const assistantMessages = messages.filter((msg) => msg.role === 'assistant');
-        const messagesToProcess = assistantMessages.length > 0 ? assistantMessages : messages;
-        return messagesToProcess
-            .map((msg) => UniversalAgent.extractTextFromLettaMessage(msg))
-            .filter((text) => text.length > 0)
-            .join(' ')
-            .trim();
-    }
-    static extractTextFromLettaMessage(message) {
-        if (!message)
-            return '';
-        if (typeof message === 'string') {
-            return message;
-        }
-        if (typeof message.content === 'string') {
-            return message.content;
-        }
-        if (Array.isArray(message.content)) {
-            return message.content
-                .map((item) => {
-                if (typeof item === 'string')
-                    return item;
-                if (item && typeof item === 'object') {
-                    if ('text' in item)
-                        return item.text;
-                    if ('content' in item)
-                        return item.content;
-                    if ('type' in item && item.type === 'text' && 'text' in item)
-                        return item.text;
-                }
-                return typeof item === 'object' ? JSON.stringify(item) : String(item);
-            })
-                .join(' ');
-        }
-        if (message.text) {
-            return message.text;
-        }
-        return JSON.stringify(message.content || message);
-    }
-    static extractMessageFromInput(exec, index) {
-        const inputType = exec.getNodeParameter('inputType', index);
-        if (inputType === 'prompt') {
-            return exec.getNodeParameter('prompt', index, '');
-        }
-        else {
-            const messages = exec.getNodeParameter('messages.messagesUi', index, []);
-            const userMessages = messages.filter((m) => m.role === 'user' && m.content);
-            return userMessages.length > 0 ? (userMessages[userMessages.length - 1].content ?? '') : '';
-        }
-    }
-    static buildIdentityConfig(exec, index) {
-        if (!exec.getNodeParameter('lettaMultiUserMode', index, false)) {
-            return undefined;
-        }
-        const identityKey = exec.getNodeParameter('lettaIdentityKey', index, '');
-        const evaluatedIdentifierKey = exec.evaluateExpression(identityKey, index);
-        if (!evaluatedIdentifierKey) {
-            return undefined;
-        }
-        return {
-            identifierKey: evaluatedIdentifierKey,
-            identityType: exec.getNodeParameter('lettaIdentityType', index, 'user'),
-            name: exec.getNodeParameter('lettaIdentityName', index) ||
-                evaluatedIdentifierKey,
-            properties: exec.getNodeParameter('lettaIdentityProperties.property', index, []),
-        };
-    }
-    static async buildAgentIds(exec, index, client) {
-        if (exec.getNodeParameter('lettaCreateNewAgent', index, false)) {
-            const useJson = exec.getNodeParameter('lettaNewAgentJsonConfigMode', index, false);
-            let agentConfig;
-            if (useJson) {
-                const jsonConfig = exec.getNodeParameter('lettaNewAgentJsonConfig', index, '{}');
-                try {
-                    agentConfig = JSON.parse(jsonConfig);
-                }
-                catch (e) {
-                    throw new n8n_workflow_1.NodeOperationError(exec.getNode(), 'Invalid JSON in New Agent Configuration');
-                }
-            }
-            else {
-                const simpleConfig = exec.getNodeParameter('lettaNewAgentConfig', index);
-                agentConfig = {
-                    name: simpleConfig.name,
-                    model: simpleConfig.model,
-                    embedding: simpleConfig.embedding,
-                    system: simpleConfig.system,
-                    tags: simpleConfig.tags
-                        ?.split(',')
-                        .map((t) => t.trim())
-                        .filter(Boolean) || [],
-                    memory_blocks: simpleConfig.memoryBlocks?.block?.map((b) => ({
-                        label: b.label,
-                        value: b.value,
-                    })) || [],
-                };
-            }
-            const newAgent = await client.createAgent(agentConfig);
-            return [newAgent.id];
-        }
-        else {
-            if (exec.getNodeParameter('lettaMultiAgentMode', index, false)) {
-                const agentIds = exec.getNodeParameter('lettaAgentIds', index, []);
-                if (agentIds.length === 0) {
-                    throw new n8n_workflow_1.NodeOperationError(exec.getNode(), 'At least one Agent ID is required for multi-agent mode');
-                }
-                return agentIds;
-            }
-            else {
-                const agentId = exec.getNodeParameter('lettaAgentId', index, '');
-                if (!agentId) {
-                    throw new n8n_workflow_1.NodeOperationError(exec.getNode(), 'Agent ID is required');
-                }
-                return [agentId];
-            }
-        }
-    }
-    static buildChatOptions(exec, index) {
-        const maxSteps = exec.getNodeParameter('lettaMaxSteps', index, 100);
-        const background = exec.getNodeParameter('lettaBackground', index, false);
-        const streamTokens = exec.getNodeParameter('lettaStreamTokens', index, false);
-        const multiAgentMode = exec.getNodeParameter('lettaMultiAgentType', index, 'sequential');
-        return {
-            ...(maxSteps > 0 && { maxSteps }),
-            ...(background && { background }),
-            ...(streamTokens && { streamTokens }),
-            multiAgentMode: exec.getNodeParameter('lettaMultiAgentMode', index, false)
-                ? multiAgentMode
-                : undefined,
-        };
-    }
-    static processChatResponse(response, index) {
-        if (Array.isArray(response)) {
-            return [{ json: { responses: response }, pairedItem: { item: index } }];
-        }
-        if (!response) {
-            throw new Error('No response received from Letta API');
-        }
-        let text = '';
-        const finishReason = response.stopReason || response.stop_reason;
-        const usage = response.usage;
-        if (response.messages) {
-            text = UniversalAgent.extractTextFromLettaMessages(response.messages);
-        }
-        else if (response.content) {
-            text =
-                typeof response.content === 'string' ? response.content : JSON.stringify(response.content);
-        }
-        else if (response.text) {
-            text = response.text;
-        }
-        else if (response.message) {
-            text = UniversalAgent.extractTextFromLettaMessage(response.message);
-        }
-        else {
-            text = UniversalAgent.extractTextFromLettaMessages(response);
-        }
-        return [
-            {
-                json: { text, finishReason, usage, rawResponse: response },
-                pairedItem: { item: index },
-            },
-        ];
-    }
     async execute() {
         const items = this.getInputData();
         const returnData = [];
-        const operation = this.getNodeParameter('operation', 0);
+        const resource = this.getNodeParameter('resource', 0);
+        let operation = '';
+        if (resource === 'tool') {
+            operation = this.getNodeParameter('toolsOperation', 0);
+        }
+        else {
+            operation = this.getNodeParameter('operation', 0);
+        }
         for (let i = 0; i < items.length; i++) {
             try {
-                const result = await UniversalAgent.processItem(this, i, operation, items[i]);
+                const result = await UniversalAgent.processItem(this, i, resource, operation);
                 returnData.push(...result);
             }
             catch (error) {
@@ -214,766 +65,44 @@ class UniversalAgent {
         }
         return [returnData];
     }
-    static async processItem(exec, index, operation, item) {
+    static async processItem(exec, index, resource, operation) {
         const provider = exec.getNodeParameter('provider', index);
         if (provider !== 'letta') {
             throw new n8n_workflow_1.NodeOperationError(exec.getNode(), 'UniversalAgent node only supports Letta provider');
         }
-        switch (operation) {
+        switch (resource) {
             case 'chat':
-                return await UniversalAgent.handleChatOperation(exec, index, item);
-            case 'createAgent':
-                return await UniversalAgent.handleCreateAgentOperation(exec, index, item);
-            case 'manageAgent':
-                return await UniversalAgent.handleManageAgentOperation(exec, index, item);
-            case 'listAgents':
-                return await UniversalAgent.handleListAgentsOperation(exec, index, item);
-            case 'manageIdentity':
-                return await UniversalAgent.handleManageIdentityOperation(exec, index, item);
-            case 'tools':
-                return await UniversalAgent.handleToolsOperation(exec, index, item);
-            case 'blocks':
-                return await UniversalAgent.handleBlocksOperation(exec, index, item);
-            case 'folders':
-                return await UniversalAgent.handleFoldersOperation(exec, index, item);
-            case 'mcpServers':
-                return await UniversalAgent.handleMcpServersOperation(exec, index, item);
-            case 'models':
-                return await UniversalAgent.handleModelsOperation(exec, index, item);
-            default:
-                throw new n8n_workflow_1.NodeOperationError(exec.getNode(), `Operation not yet implemented: ${operation}. Currently supported: chat, createAgent, manageAgent, listAgents, manageIdentity, tools, blocks, folders, mcpServers, models`);
-        }
-    }
-    static async handleChatOperation(exec, index, item) {
-        const client = await (0, letta_1.getLettaProvider)(exec, index);
-        const message = UniversalAgent.extractMessageFromInput(exec, index);
-        if (!message) {
-            throw new n8n_workflow_1.NodeOperationError(exec.getNode(), 'Message is required for chat operation');
-        }
-        const identity = UniversalAgent.buildIdentityConfig(exec, index);
-        const agentIds = await UniversalAgent.buildAgentIds(exec, index, client);
-        const chatOptions = UniversalAgent.buildChatOptions(exec, index);
-        if (chatOptions.background) {
-            throw new n8n_workflow_1.NodeOperationError(exec.getNode(), 'Background mode is not supported for chat operations. Please disable background processing.');
-        }
-        const response = await client.sendMessage(agentIds, message, identity, chatOptions);
-        return UniversalAgent.processChatResponse(response, index);
-    }
-    static async handleCreateAgentOperation(exec, index, item) {
-        const client = await (0, letta_1.getLettaProvider)(exec, index);
-        const useJson = exec.getNodeParameter('createAgentJsonConfigMode', index, false);
-        let agentConfig;
-        if (useJson) {
-            const jsonConfig = exec.getNodeParameter('createAgentJsonConfig', index, '{}');
-            try {
-                agentConfig = JSON.parse(jsonConfig);
-            }
-            catch (e) {
-                throw new n8n_workflow_1.NodeOperationError(exec.getNode(), 'Invalid JSON in Agent Configuration');
-            }
-        }
-        else {
-            const simpleConfig = exec.getNodeParameter('createAgentConfig', index);
-            agentConfig = {
-                name: simpleConfig.name,
-                model: simpleConfig.model,
-                embedding: simpleConfig.embedding,
-                system: simpleConfig.system,
-                agent_type: simpleConfig.agent_type,
-                description: simpleConfig.description,
-                include_base_tools: simpleConfig.include_base_tools,
-                tags: simpleConfig.tags
-                    ?.split(',')
-                    .map((t) => t.trim())
-                    .filter(Boolean) || undefined,
-                tool_ids: simpleConfig.tool_ids
-                    ?.split(',')
-                    .map((t) => t.trim())
-                    .filter(Boolean) || undefined,
-                source_ids: simpleConfig.source_ids
-                    ?.split(',')
-                    .map((s) => s.trim())
-                    .filter(Boolean) || undefined,
-                memory_blocks: simpleConfig.memoryBlocks?.block?.map((b) => ({
-                    label: b.label,
-                    value: b.value,
-                })) || undefined,
-                secrets: simpleConfig.secrets?.secret?.reduce((acc, s) => {
-                    if (s.key) {
-                        acc[s.key] = s.value;
-                    }
-                    return acc;
-                }, {}) || undefined,
-            };
-        }
-        const agent = await client.createAgent(agentConfig);
-        return [
-            {
-                json: {
-                    agentId: agent.id,
-                    name: agent.name,
-                    model: agent.llmConfig?.model,
-                    embedding: agent.embeddingConfig?.embeddingModel,
-                    tags: agent.tags,
-                },
-                pairedItem: { item: index },
-            },
-        ];
-    }
-    static async handleManageAgentOperation(exec, index, item) {
-        const client = await (0, letta_1.getLettaProvider)(exec, index);
-        const operation = exec.getNodeParameter('manageAgentOperation', index);
-        const agentId = exec.getNodeParameter('manageAgentId', index);
-        if (!agentId) {
-            throw new n8n_workflow_1.NodeOperationError(exec.getNode(), 'Agent ID is required for manage agent operation');
-        }
-        switch (operation) {
-            case 'get': {
-                const agent = await client.getAgent(agentId);
-                return [
-                    {
-                        json: {
-                            agentId: agent.id,
-                            name: agent.name,
-                            model: agent.llmConfig?.model,
-                            embedding: agent.embeddingConfig?.embeddingModel,
-                            tags: agent.tags,
-                            createdAt: agent.createdAt,
-                            updatedAt: agent.updatedAt,
-                        },
-                        pairedItem: { item: index },
-                    },
-                ];
-            }
-            case 'update': {
-                const useJson = exec.getNodeParameter('updateAgentJsonConfigMode', index, false);
-                let updateConfig;
-                if (useJson) {
-                    const jsonConfig = exec.getNodeParameter('updateAgentJsonConfig', index, '{}');
-                    try {
-                        updateConfig = JSON.parse(jsonConfig);
-                    }
-                    catch (e) {
-                        throw new n8n_workflow_1.NodeOperationError(exec.getNode(), 'Invalid JSON in Update Agent Configuration');
-                    }
-                }
-                else {
-                    const simpleConfig = exec.getNodeParameter('updateAgentConfig', index);
-                    updateConfig = {
-                        ...(simpleConfig.name && { name: simpleConfig.name }),
-                        ...(simpleConfig.model && { model: simpleConfig.model }),
-                        ...(simpleConfig.embedding && { embedding: simpleConfig.embedding }),
-                        ...(simpleConfig.system && { system: simpleConfig.system }),
-                        ...(simpleConfig.tags && {
-                            tags: simpleConfig.tags
-                                .split(',')
-                                .map((t) => t.trim())
-                                .filter(Boolean),
-                        }),
-                        ...(simpleConfig.memoryBlocks?.block && {
-                            memory_blocks: simpleConfig.memoryBlocks.block.map((b) => ({
-                                label: b.label,
-                                value: b.value,
-                                ...(b.description && { description: b.description }),
-                            })),
-                        }),
-                    };
-                }
-                const updatedAgent = await client.updateAgent(agentId, updateConfig);
-                return [
-                    {
-                        json: {
-                            agentId: updatedAgent.id,
-                            name: updatedAgent.name,
-                            model: updatedAgent.llmConfig?.model,
-                            embedding: updatedAgent.embeddingConfig?.embeddingModel,
-                            tags: updatedAgent.tags,
-                        },
-                        pairedItem: { item: index },
-                    },
-                ];
-            }
-            case 'delete': {
-                await client.deleteAgent(agentId);
-                return [
-                    {
-                        json: {
-                            deleted: true,
-                            agentId,
-                        },
-                        pairedItem: { item: index },
-                    },
-                ];
-            }
-            default:
-                throw new n8n_workflow_1.NodeOperationError(exec.getNode(), `Unsupported manage agent operation: ${operation}`);
-        }
-    }
-    static async handleListAgentsOperation(exec, index, item) {
-        const client = await (0, letta_1.getLettaProvider)(exec, index);
-        const tags = exec.getNodeParameter('listAgentsTags', index, '');
-        const tagArray = tags
-            ? tags
-                .split(',')
-                .map((t) => t.trim())
-                .filter(Boolean)
-            : undefined;
-        const agents = await client.listAgents(tagArray);
-        return [
-            {
-                json: {
-                    agents: agents.map((agent) => ({
-                        id: agent.id,
-                        name: agent.name,
-                        model: agent.llmConfig?.model,
-                        embedding: agent.embeddingConfig?.embeddingModel,
-                        tags: agent.tags,
-                        createdAt: agent.createdAt,
-                        updatedAt: agent.updatedAt,
-                    })),
-                    total: agents.length,
-                },
-                pairedItem: { item: index },
-            },
-        ];
-    }
-    static async handleManageIdentityOperation(exec, index, item) {
-        const client = await (0, letta_1.getLettaProvider)(exec, index);
-        const operation = exec.getNodeParameter('manageIdentityOperation', index);
-        const identifierKey = exec.getNodeParameter('identityKey', index);
-        if (!identifierKey) {
-            throw new n8n_workflow_1.NodeOperationError(exec.getNode(), 'Identifier Key is required for manage identity operation');
-        }
-        if (operation === 'upsert') {
-            const name = exec.getNodeParameter('identityName', index);
-            const properties = exec.getNodeParameter('identityProperties.property', index, []);
-            const identityType = exec.getNodeParameter('identityType', index);
-            const identity = await client.upsertIdentity(identifierKey, name, properties, [], identityType);
-            return [
-                {
-                    json: {
-                        identityId: identity.id,
-                        identifierKey: identity.identifierKey,
-                        name: identity.name,
-                    },
-                    pairedItem: { item: index },
-                },
-            ];
-        }
-        else if (operation === 'upsertProperties') {
-            const properties = exec.getNodeParameter('identityProperties.property', index, []);
-            if (properties.length === 0) {
-                throw new n8n_workflow_1.NodeOperationError(exec.getNode(), 'Properties are required for upsert properties operation');
-            }
-            const name = exec.getNodeParameter('identityName', index);
-            const identityType = exec.getNodeParameter('identityType', index, 'user');
-            const identity = await client.upsertPropertiesByIdentifierKey(identifierKey, properties, name, identityType);
-            const identityId = identity?.id;
-            return [
-                {
-                    json: {
-                        identityId,
-                        propertiesUpserted: true,
-                    },
-                    pairedItem: { item: index },
-                },
-            ];
-        }
-        return [];
-    }
-    static async handleToolsOperation(exec, index, item) {
-        const client = await (0, letta_1.getLettaProvider)(exec, index);
-        const operation = exec.getNodeParameter('toolsOperation', index);
-        switch (operation) {
-            case 'list': {
-                const tools = await client.listTools();
-                return [
-                    {
-                        json: {
-                            tools: tools.map((tool) => ({
-                                id: tool.id,
-                                name: tool.name,
-                                description: tool.description,
-                                sourceCode: tool.source_code,
-                                tags: tool.tags,
-                            })),
-                            total: tools.length,
-                        },
-                        pairedItem: { item: index },
-                    },
-                ];
-            }
-            case 'create': {
-                const name = exec.getNodeParameter('toolName', index);
-                const description = exec.getNodeParameter('toolDescription', index);
-                const sourceCode = exec.getNodeParameter('toolSourceCode', index);
-                const tags = exec.getNodeParameter('toolTags', index, '');
-                const tagArray = tags
-                    ? tags
-                        .split(',')
-                        .map((t) => t.trim())
-                        .filter(Boolean)
-                    : [];
-                const tool = await client.createTool({
-                    name,
-                    description,
-                    source_code: sourceCode,
-                    tags: tagArray,
-                });
-                return [
-                    {
-                        json: {
-                            toolId: tool.id,
-                            name: tool.name,
-                            description: tool.description,
-                            tags: tool.tags,
-                        },
-                        pairedItem: { item: index },
-                    },
-                ];
-            }
-            case 'get': {
-                const toolId = exec.getNodeParameter('toolId', index);
-                const tool = await client.getTool(toolId);
-                return [
-                    {
-                        json: {
-                            toolId: tool.id,
-                            name: tool.name,
-                            description: tool.description,
-                            sourceCode: tool.source_code,
-                            tags: tool.tags,
-                        },
-                        pairedItem: { item: index },
-                    },
-                ];
-            }
-            case 'update': {
-                const toolId = exec.getNodeParameter('toolId', index);
-                const name = exec.getNodeParameter('toolName', index);
-                const description = exec.getNodeParameter('toolDescription', index);
-                const sourceCode = exec.getNodeParameter('toolSourceCode', index);
-                const tags = exec.getNodeParameter('toolTags', index, '');
-                const tagArray = tags
-                    ? tags
-                        .split(',')
-                        .map((t) => t.trim())
-                        .filter(Boolean)
-                    : [];
-                const tool = await client.updateTool(toolId, {
-                    name,
-                    description,
-                    source_code: sourceCode,
-                    tags: tagArray,
-                });
-                return [
-                    {
-                        json: {
-                            toolId: tool.id,
-                            name: tool.name,
-                            description: tool.description,
-                            tags: tool.tags,
-                        },
-                        pairedItem: { item: index },
-                    },
-                ];
-            }
-            case 'delete': {
-                const toolId = exec.getNodeParameter('toolId', index);
-                await client.deleteTool(toolId);
-                return [
-                    {
-                        json: {
-                            deleted: true,
-                            toolId,
-                        },
-                        pairedItem: { item: index },
-                    },
-                ];
-            }
-            case 'upsert': {
-                const name = exec.getNodeParameter('toolName', index);
-                const description = exec.getNodeParameter('toolDescription', index);
-                const sourceCode = exec.getNodeParameter('toolSourceCode', index);
-                const tags = exec.getNodeParameter('toolTags', index, '');
-                const tagArray = tags
-                    ? tags
-                        .split(',')
-                        .map((t) => t.trim())
-                        .filter(Boolean)
-                    : [];
-                const tool = await client.upsertTool({
-                    name,
-                    description,
-                    source_code: sourceCode,
-                    tags: tagArray,
-                });
-                return [
-                    {
-                        json: {
-                            toolId: tool.id,
-                            name: tool.name,
-                            description: tool.description,
-                            tags: tool.tags,
-                            created: tool.created,
-                        },
-                        pairedItem: { item: index },
-                    },
-                ];
-            }
-            case 'upsertBase': {
-                const result = await client.upsertBaseTools();
-                return [
-                    {
-                        json: {
-                            baseToolsUpserted: true,
-                            result,
-                        },
-                        pairedItem: { item: index },
-                    },
-                ];
-            }
-            default:
-                throw new n8n_workflow_1.NodeOperationError(exec.getNode(), `Unsupported tools operation: ${operation}`);
-        }
-    }
-    static async handleBlocksOperation(exec, index, item) {
-        const client = await (0, letta_1.getLettaProvider)(exec, index);
-        const operation = exec.getNodeParameter('blocksOperation', index);
-        switch (operation) {
-            case 'list': {
-                const limit = exec.getNodeParameter('limit', index, 100);
-                const blocks = await client.listBlocks(limit);
-                return [
-                    {
-                        json: {
-                            blocks: blocks.map((block) => ({
-                                id: block.id,
-                                label: block.label,
-                                value: block.value,
-                                description: block.description,
-                                limit: block.limit,
-                            })),
-                            total: blocks.length,
-                        },
-                        pairedItem: { item: index },
-                    },
-                ];
-            }
-            case 'create': {
-                const label = exec.getNodeParameter('blockLabel', index);
-                const value = exec.getNodeParameter('blockValue', index);
-                const description = exec.getNodeParameter('blockDescription', index, '');
-                const block = await client.createBlock({
-                    label,
-                    value,
-                    description: description || undefined,
-                });
-                return [
-                    {
-                        json: {
-                            blockId: block.id,
-                            label: block.label,
-                            value: block.value,
-                            description: block.description,
-                        },
-                        pairedItem: { item: index },
-                    },
-                ];
-            }
-            case 'get': {
-                const blockId = exec.getNodeParameter('blockId', index);
-                const block = await client.getBlock(blockId);
-                return [
-                    {
-                        json: {
-                            blockId: block.id,
-                            label: block.label,
-                            value: block.value,
-                            description: block.description,
-                            limit: block.limit,
-                        },
-                        pairedItem: { item: index },
-                    },
-                ];
-            }
-            case 'update': {
-                const blockId = exec.getNodeParameter('blockId', index);
-                const label = exec.getNodeParameter('blockLabel', index);
-                const value = exec.getNodeParameter('blockValue', index);
-                const description = exec.getNodeParameter('blockDescription', index, '');
-                const block = await client.updateBlock(blockId, {
-                    label,
-                    value,
-                    description: description || undefined,
-                });
-                return [
-                    {
-                        json: {
-                            blockId: block.id,
-                            label: block.label,
-                            value: block.value,
-                            description: block.description,
-                        },
-                        pairedItem: { item: index },
-                    },
-                ];
-            }
-            case 'delete': {
-                const blockId = exec.getNodeParameter('blockId', index);
-                await client.deleteBlock(blockId);
-                return [
-                    {
-                        json: {
-                            deleted: true,
-                            blockId,
-                        },
-                        pairedItem: { item: index },
-                    },
-                ];
-            }
-            default:
-                throw new n8n_workflow_1.NodeOperationError(exec.getNode(), `Unsupported blocks operation: ${operation}`);
-        }
-    }
-    static async handleFoldersOperation(exec, index, item) {
-        const client = await (0, letta_1.getLettaProvider)(exec, index);
-        const operation = exec.getNodeParameter('foldersOperation', index);
-        switch (operation) {
-            case 'list': {
-                const folders = await client.listFolders();
-                return [
-                    {
-                        json: {
-                            folders: folders.map((folder) => ({
-                                id: folder.id,
-                                name: folder.name,
-                                embeddingConfig: folder.embedding_config,
-                            })),
-                            total: folders.length,
-                        },
-                        pairedItem: { item: index },
-                    },
-                ];
-            }
-            case 'create': {
-                const name = exec.getNodeParameter('folderName', index);
-                const embeddingConfig = exec.getNodeParameter('embeddingConfig', index, {});
-                const folder = await client.createFolder({
-                    name,
-                    embedding_config: embeddingConfig,
-                });
-                return [
-                    {
-                        json: {
-                            folderId: folder.id,
-                            name: folder.name,
-                            embeddingConfig: folder.embedding_config,
-                        },
-                        pairedItem: { item: index },
-                    },
-                ];
-            }
-            case 'get': {
-                const folderId = exec.getNodeParameter('folderId', index);
-                const folder = await client.getFolder(folderId);
-                return [
-                    {
-                        json: {
-                            folderId: folder.id,
-                            name: folder.name,
-                            embeddingConfig: folder.embedding_config,
-                        },
-                        pairedItem: { item: index },
-                    },
-                ];
-            }
-            case 'update': {
-                const folderId = exec.getNodeParameter('folderId', index);
-                const name = exec.getNodeParameter('folderName', index);
-                const embeddingConfig = exec.getNodeParameter('embeddingConfig', index, {});
-                const folder = await client.updateFolder(folderId, {
-                    name,
-                    embedding_config: embeddingConfig,
-                });
-                return [
-                    {
-                        json: {
-                            folderId: folder.id,
-                            name: folder.name,
-                            embeddingConfig: folder.embedding_config,
-                        },
-                        pairedItem: { item: index },
-                    },
-                ];
-            }
-            case 'delete': {
-                const folderId = exec.getNodeParameter('folderId', index);
-                await client.deleteFolder(folderId);
-                return [
-                    {
-                        json: {
-                            deleted: true,
-                            folderId,
-                        },
-                        pairedItem: { item: index },
-                    },
-                ];
-            }
-            default:
-                throw new n8n_workflow_1.NodeOperationError(exec.getNode(), `Unsupported folders operation: ${operation}`);
-        }
-    }
-    static async handleMcpServersOperation(exec, index, item) {
-        const client = await (0, letta_1.getLettaProvider)(exec, index);
-        const operation = exec.getNodeParameter('mcpServersOperation', index);
-        switch (operation) {
-            case 'list': {
-                const servers = await client.listMcpServers();
-                return [
-                    {
-                        json: {
-                            servers: servers.map((server) => ({
-                                id: server.id,
-                                name: server.name,
-                                command: server.command,
-                                status: server.status,
-                            })),
-                            total: servers.length,
-                        },
-                        pairedItem: { item: index },
-                    },
-                ];
-            }
-            case 'create': {
-                const name = exec.getNodeParameter('serverName', index);
-                const command = exec.getNodeParameter('serverCommand', index);
-                const server = await client.createMcpServer({
-                    name,
-                    command,
-                });
-                return [
-                    {
-                        json: {
-                            serverId: server.id,
-                            name: server.name,
-                            command: server.command,
-                            status: server.status,
-                        },
-                        pairedItem: { item: index },
-                    },
-                ];
-            }
-            case 'get': {
-                const serverId = exec.getNodeParameter('serverId', index);
-                const server = await client.getMcpServer(serverId);
-                return [
-                    {
-                        json: {
-                            serverId: server.id,
-                            name: server.name,
-                            command: server.command,
-                            status: server.status,
-                        },
-                        pairedItem: { item: index },
-                    },
-                ];
-            }
-            case 'update': {
-                const serverId = exec.getNodeParameter('serverId', index);
-                const name = exec.getNodeParameter('serverName', index);
-                const command = exec.getNodeParameter('serverCommand', index);
-                const server = await client.updateMcpServer(serverId, {
-                    name,
-                    command,
-                });
-                return [
-                    {
-                        json: {
-                            serverId: server.id,
-                            name: server.name,
-                            command: server.command,
-                            status: server.status,
-                        },
-                        pairedItem: { item: index },
-                    },
-                ];
-            }
-            case 'delete': {
-                const serverId = exec.getNodeParameter('serverId', index);
-                await client.deleteMcpServer(serverId);
-                return [
-                    {
-                        json: {
-                            deleted: true,
-                            serverId,
-                        },
-                        pairedItem: { item: index },
-                    },
-                ];
-            }
-            case 'refresh': {
-                const serverId = exec.getNodeParameter('serverId', index);
-                const server = await client.refreshMcpServer(serverId);
-                return [
-                    {
-                        json: {
-                            serverId: server.id,
-                            name: server.name,
-                            command: server.command,
-                            status: server.status,
-                            refreshed: true,
-                        },
-                        pairedItem: { item: index },
-                    },
-                ];
-            }
-            default:
-                throw new n8n_workflow_1.NodeOperationError(exec.getNode(), `Unsupported MCP servers operation: ${operation}`);
-        }
-    }
-    static async handleModelsOperation(exec, index, item) {
-        const client = await (0, letta_1.getLettaProvider)(exec, index);
-        const operation = exec.getNodeParameter('modelsOperation', index);
-        switch (operation) {
-            case 'llm': {
-                const models = await client.listLlmModels();
-                return [
-                    {
-                        json: {
-                            models: models.map((model) => ({
-                                id: model.id,
-                                name: model.name,
-                                contextWindow: model.context_window,
-                                maxOutputLength: model.max_output_length,
-                            })),
-                            total: models.length,
-                            type: 'llm',
-                        },
-                        pairedItem: { item: index },
-                    },
-                ];
-            }
-            case 'embedding': {
-                const models = await client.listEmbeddingModels();
-                return [
-                    {
-                        json: {
-                            models: models.map((model) => ({
-                                id: model.id,
-                                name: model.name,
-                                dimensions: model.dimensions,
-                                maxInputLength: model.max_input_length,
-                            })),
-                            total: models.length,
-                            type: 'embedding',
-                        },
-                        pairedItem: { item: index },
-                    },
-                ];
-            }
+                return await (0, chat_handler_1.handleChatOperation)(exec, index);
+            case 'agent':
+                return await (0, agent_handler_1.handleAgentOperation)(exec, index);
+            case 'identity':
+                return await (0, identity_handler_1.handleManageIdentityOperation)(exec, index);
+            case 'tool':
+                return await (0, tools_handler_1.handleToolsOperation)(exec, index);
+            case 'block':
+                return await (0, blocks_handler_1.handleBlocksOperation)(exec, index);
+            case 'folder':
+                return await (0, folders_handler_1.handleFoldersOperation)(exec, index);
+            case 'mcpServer':
+                return await (0, mcp_handler_1.handleMcpServersOperation)(exec, index);
+            case 'model':
+                return await (0, models_handler_1.handleModelsOperation)(exec, index);
+            case 'archive':
+                return await (0, archives_handler_1.handleArchivesOperation)(exec, index);
+            case 'batch':
+                return await (0, batches_handler_1.handleBatchesOperation)(exec, index);
+            case 'group':
+                return await (0, groups_handler_1.handleGroupsOperation)(exec, index);
+            case 'run':
+                return await (0, runs_handler_1.handleRunsOperation)(exec, index);
+            case 'step':
+                return await (0, steps_handler_1.handleStepsOperation)(exec, index);
+            case 'tag':
+                return await (0, tags_handler_1.handleTagsOperation)(exec, index);
+            case 'template':
+                return await (0, templates_handler_1.handleTemplatesOperation)(exec, index);
             default:
-                throw new n8n_workflow_1.NodeOperationError(exec.getNode(), `Unsupported models operation: ${operation}`);
+                throw new n8n_workflow_1.NodeOperationError(exec.getNode(), `Resource not yet implemented: ${resource}`);
         }
     }
 }