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

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

@@ -168,8 +168,8 @@ class UniversalAgent {
             throw new Error('No response received from Letta API');
         }
         let text = '';
-        let finishReason = response.stopReason || response.stop_reason;
-        let usage = response.usage;
+        const finishReason = response.stopReason || response.stop_reason;
+        const usage = response.usage;
         if (response.messages) {
             text = UniversalAgent.extractTextFromLettaMessages(response.messages);
         }
@@ -193,20 +193,13 @@ class UniversalAgent {
             },
         ];
     }
-    static async processStreamedChatResponse(stream, index) {
-        const chunks = [];
-        for await (const chunk of stream) {
-            chunks.push({ json: chunk, pairedItem: { item: index } });
-        }
-        return chunks;
-    }
     async execute() {
         const items = this.getInputData();
         const returnData = [];
         const operation = this.getNodeParameter('operation', 0);
         for (let i = 0; i < items.length; i++) {
             try {
-                const result = await UniversalAgent.processItem(this, i, operation);
+                const result = await UniversalAgent.processItem(this, i, operation, items[i]);
                 returnData.push(...result);
             }
             catch (error) {
@@ -221,25 +214,37 @@ class UniversalAgent {
         }
         return [returnData];
     }
-    static async processItem(exec, index, operation) {
+    static async processItem(exec, index, operation, item) {
         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) {
             case 'chat':
-                return await UniversalAgent.handleChatOperation(exec, index);
+                return await UniversalAgent.handleChatOperation(exec, index, item);
             case 'createAgent':
-                return await UniversalAgent.handleCreateAgentOperation(exec, index);
+                return await UniversalAgent.handleCreateAgentOperation(exec, index, item);
             case 'manageAgent':
-                return await UniversalAgent.handleManageAgentOperation(exec, index);
+                return await UniversalAgent.handleManageAgentOperation(exec, index, item);
+            case 'listAgents':
+                return await UniversalAgent.handleListAgentsOperation(exec, index, item);
             case 'manageIdentity':
-                return await UniversalAgent.handleManageIdentityOperation(exec, index);
+                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(), `Unsupported operation: ${operation}`);
+                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) {
+    static async handleChatOperation(exec, index, item) {
         const client = await (0, letta_1.getLettaProvider)(exec, index);
         const message = UniversalAgent.extractMessageFromInput(exec, index);
         if (!message) {
@@ -251,16 +256,10 @@ class UniversalAgent {
         if (chatOptions.background) {
             throw new n8n_workflow_1.NodeOperationError(exec.getNode(), 'Background mode is not supported for chat operations. Please disable background processing.');
         }
-        if (chatOptions.streamTokens) {
-            const stream = await client.sendMessage(agentIds, message, identity, chatOptions);
-            return await UniversalAgent.processStreamedChatResponse(stream, index);
-        }
-        else {
-            const response = await client.sendMessage(agentIds, message, identity, chatOptions);
-            return UniversalAgent.processChatResponse(response, index);
-        }
+        const response = await client.sendMessage(agentIds, message, identity, chatOptions);
+        return UniversalAgent.processChatResponse(response, index);
     }
-    static async handleCreateAgentOperation(exec, 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;
@@ -321,7 +320,7 @@ class UniversalAgent {
             },
         ];
     }
-    static async handleManageAgentOperation(exec, 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);
@@ -329,7 +328,7 @@ class UniversalAgent {
             throw new n8n_workflow_1.NodeOperationError(exec.getNode(), 'Agent ID is required for manage agent operation');
         }
         switch (operation) {
-            case 'get':
+            case 'get': {
                 const agent = await client.getAgent(agentId);
                 return [
                     {
@@ -345,7 +344,7 @@ class UniversalAgent {
                         pairedItem: { item: index },
                     },
                 ];
-            case 'update':
+            }
             case 'update': {
                 const useJson = exec.getNodeParameter('updateAgentJsonConfigMode', index, false);
                 let updateConfig;
@@ -361,37 +360,24 @@ class UniversalAgent {
                 else {
                     const simpleConfig = exec.getNodeParameter('updateAgentConfig', index);
                     updateConfig = {
-                        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,
+                        ...(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 }),
+                            })),
+                        }),
                     };
-                    updateConfig = Object.fromEntries(Object.entries(updateConfig).filter(([, v]) => v !== '' && v !== undefined && (!Array.isArray(v) || v.length > 0)));
                 }
                 const updatedAgent = await client.updateAgent(agentId, updateConfig);
                 return [
@@ -407,14 +393,51 @@ class UniversalAgent {
                     },
                 ];
             }
-            case 'delete':
+            case 'delete': {
                 await client.deleteAgent(agentId);
-                return [{ json: { agentId, deleted: true }, pairedItem: { item: index } }];
+                return [
+                    {
+                        json: {
+                            deleted: true,
+                            agentId,
+                        },
+                        pairedItem: { item: index },
+                    },
+                ];
+            }
             default:
                 throw new n8n_workflow_1.NodeOperationError(exec.getNode(), `Unsupported manage agent operation: ${operation}`);
         }
     }
-    static async handleManageIdentityOperation(exec, index) {
+    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);
@@ -458,6 +481,501 @@ class UniversalAgent {
         }
         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 },
+                    },
+                ];
+            }
+            default:
+                throw new n8n_workflow_1.NodeOperationError(exec.getNode(), `Unsupported models operation: ${operation}`);
+        }
+    }
 }
 exports.UniversalAgent = UniversalAgent;
 //# sourceMappingURL=UniversalAgent.node.js.map