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

package/dist/nodes/shared/descriptions.js

@@ -530,6 +530,7 @@ exports.UNIVERSAL_AI_DESCRIPTION = {
             description: 'The resource to operate on',
         },
         universalAiBuilder.addProviderSelector(),
+        universalAiBuilder.addLettaAgentSelector(),
         {
             displayName: 'Operation',
             name: 'operation',
@@ -821,2040 +822,6 @@ exports.UNIVERSAL_AI_DESCRIPTION = {
                                                     name: 'WAV Audio (Audio/wav)',
                                                     value: 'audio/wav',
                                                 },
-                                                {
-                                                    displayName: 'Agent Messages Operation',
-                                                    name: 'agentMessagesOperation',
-                                                    type: 'options',
-                                                    required: true,
-                                                    noDataExpression: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['agentMessages'],
-                                                        },
-                                                    },
-                                                    options: [
-                                                        {
-                                                            name: 'List Messages',
-                                                            value: 'list',
-                                                            description: 'List messages for an agent',
-                                                            action: 'List agent messages',
-                                                        },
-                                                        {
-                                                            name: 'Create Message',
-                                                            value: 'create',
-                                                            description: 'Send a message to an agent',
-                                                            action: 'Create message',
-                                                        },
-                                                        {
-                                                            name: 'Stream Message',
-                                                            value: 'stream',
-                                                            description: 'Stream a message response from an agent',
-                                                            action: 'Stream message',
-                                                        },
-                                                        {
-                                                            name: 'Cancel Message',
-                                                            value: 'cancel',
-                                                            description: 'Cancel a running message',
-                                                            action: 'Cancel message',
-                                                        },
-                                                        {
-                                                            name: 'Create Async Message',
-                                                            value: 'createAsync',
-                                                            description: 'Create a message asynchronously',
-                                                            action: 'Create async message',
-                                                        },
-                                                        {
-                                                            name: 'Reset Messages',
-                                                            value: 'reset',
-                                                            description: 'Reset agent conversation history',
-                                                            action: 'Reset messages',
-                                                        },
-                                                        {
-                                                            name: 'Compact Messages',
-                                                            value: 'compact',
-                                                            description: 'Compact agent message history',
-                                                            action: 'Compact messages',
-                                                        },
-                                                    ],
-                                                    default: 'create',
-                                                    description: 'The agent messages operation to perform',
-                                                },
-                                                {
-                                                    displayName: 'Agent ID',
-                                                    name: 'agentId',
-                                                    type: 'options',
-                                                    required: true,
-                                                    typeOptions: {
-                                                        loadOptionsMethod: 'getLettaAgents',
-                                                    },
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['agentMessages'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The agent to perform the operation on',
-                                                },
-                                                {
-                                                    displayName: 'Input Type',
-                                                    name: 'inputType',
-                                                    type: 'options',
-                                                    required: true,
-                                                    noDataExpression: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['agentMessages'],
-                                                            agentMessagesOperation: ['create', 'stream', 'createAsync'],
-                                                        },
-                                                    },
-                                                    options: [
-                                                        {
-                                                            name: 'Simple Prompt',
-                                                            value: 'prompt',
-                                                            description: 'Use a single prompt',
-                                                        },
-                                                        {
-                                                            name: 'Messages',
-                                                            value: 'messages',
-                                                            description: 'Use a conversation with multiple messages',
-                                                        },
-                                                    ],
-                                                    default: 'prompt',
-                                                    description: 'Choose how you want to provide input to the agent',
-                                                },
-                                                {
-                                                    displayName: 'Prompt',
-                                                    name: 'prompt',
-                                                    type: 'string',
-                                                    typeOptions: {
-                                                        rows: 4,
-                                                    },
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['agentMessages'],
-                                                            agentMessagesOperation: ['create', 'stream', 'createAsync'],
-                                                            inputType: ['prompt'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    required: true,
-                                                    description: 'The single text prompt to send to the agent',
-                                                    requiresDataPath: 'single',
-                                                },
-                                                {
-                                                    displayName: 'Messages',
-                                                    name: 'messages',
-                                                    type: 'fixedCollection',
-                                                    typeOptions: {
-                                                        multipleValues: true,
-                                                        sortable: true,
-                                                        minValue: 1,
-                                                    },
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['agentMessages'],
-                                                            agentMessagesOperation: ['create', 'stream', 'createAsync'],
-                                                            inputType: ['messages'],
-                                                        },
-                                                    },
-                                                    description: 'The messages for the conversation',
-                                                    default: {
-                                                        messagesUi: [
-                                                            {
-                                                                role: 'user',
-                                                                content: 'Hello!',
-                                                            },
-                                                        ],
-                                                    },
-                                                    required: true,
-                                                    options: [
-                                                        {
-                                                            name: 'messagesUi',
-                                                            displayName: 'Message',
-                                                            values: [
-                                                                {
-                                                                    displayName: 'Role',
-                                                                    name: 'role',
-                                                                    type: 'options',
-                                                                    noDataExpression: true,
-                                                                    options: [
-                                                                        {
-                                                                            name: 'Assistant',
-                                                                            value: 'assistant',
-                                                                        },
-                                                                        {
-                                                                            name: 'System',
-                                                                            value: 'system',
-                                                                        },
-                                                                        {
-                                                                            name: 'User',
-                                                                            value: 'user',
-                                                                        },
-                                                                    ],
-                                                                    default: 'user',
-                                                                    required: true,
-                                                                },
-                                                                {
-                                                                    displayName: 'Text Content',
-                                                                    name: 'content',
-                                                                    type: 'string',
-                                                                    typeOptions: {
-                                                                        rows: 4,
-                                                                    },
-                                                                    displayOptions: {
-                                                                        show: {
-                                                                            role: ['assistant', 'user'],
-                                                                        },
-                                                                    },
-                                                                    default: '',
-                                                                    description: 'Primary text content of the message',
-                                                                    required: true,
-                                                                    requiresDataPath: 'single',
-                                                                },
-                                                            ],
-                                                        },
-                                                    ],
-                                                },
-                                                {
-                                                    displayName: 'Stream Tokens',
-                                                    name: 'streamTokens',
-                                                    type: 'boolean',
-                                                    default: false,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['agentMessages'],
-                                                            agentMessagesOperation: ['stream'],
-                                                        },
-                                                    },
-                                                    description: 'Stream individual tokens in the response',
-                                                },
-                                                {
-                                                    displayName: 'Background Processing',
-                                                    name: 'background',
-                                                    type: 'boolean',
-                                                    default: false,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['agentMessages'],
-                                                            agentMessagesOperation: ['create', 'stream', 'createAsync'],
-                                                        },
-                                                    },
-                                                    description: 'Run the message in background mode for long-running tasks',
-                                                },
-                                                {
-                                                    displayName: 'Limit',
-                                                    name: 'limit',
-                                                    type: 'number',
-                                                    default: 50,
-                                                    typeOptions: {
-                                                        minValue: 1,
-                                                        maxValue: 1000,
-                                                    },
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['agentMessages'],
-                                                            agentMessagesOperation: ['list'],
-                                                        },
-                                                    },
-                                                    description: 'Maximum number of messages to return',
-                                                },
-                                                {
-                                                    displayName: 'Before',
-                                                    name: 'before',
-                                                    type: 'string',
-                                                    default: '',
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['agentMessages'],
-                                                            agentMessagesOperation: ['list'],
-                                                        },
-                                                    },
-                                                    description: 'Cursor for pagination (message ID to start before)',
-                                                },
-                                                {
-                                                    displayName: 'Message ID',
-                                                    name: 'messageId',
-                                                    type: 'string',
-                                                    required: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['agentMessages'],
-                                                            agentMessagesOperation: ['cancel'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The ID of the message to cancel',
-                                                },
-                                                {
-                                                    displayName: 'Agent Blocks Operation',
-                                                    name: 'agentBlocksOperation',
-                                                    type: 'options',
-                                                    required: true,
-                                                    noDataExpression: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['agentBlocks'],
-                                                        },
-                                                    },
-                                                    options: [
-                                                        {
-                                                            name: 'Retrieve Block',
-                                                            value: 'retrieve',
-                                                            description: 'Get a specific memory block from an agent',
-                                                            action: 'Retrieve agent block',
-                                                        },
-                                                        {
-                                                            name: 'Update Block',
-                                                            value: 'update',
-                                                            description: 'Update a memory block for an agent',
-                                                            action: 'Update agent block',
-                                                        },
-                                                        {
-                                                            name: 'List Blocks',
-                                                            value: 'list',
-                                                            description: 'List all memory blocks for an agent',
-                                                            action: 'List agent blocks',
-                                                        },
-                                                        {
-                                                            name: 'Attach Block',
-                                                            value: 'attach',
-                                                            description: 'Attach a memory block to an agent',
-                                                            action: 'Attach block to agent',
-                                                        },
-                                                        {
-                                                            name: 'Detach Block',
-                                                            value: 'detach',
-                                                            description: 'Detach a memory block from an agent',
-                                                            action: 'Detach block from agent',
-                                                        },
-                                                    ],
-                                                    default: 'list',
-                                                    description: 'The agent blocks operation to perform',
-                                                },
-                                                {
-                                                    displayName: 'Agent ID',
-                                                    name: 'agentId',
-                                                    type: 'options',
-                                                    required: true,
-                                                    typeOptions: {
-                                                        loadOptionsMethod: 'getLettaAgents',
-                                                    },
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['agentBlocks'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The agent to perform the operation on',
-                                                },
-                                                {
-                                                    displayName: 'Block Label',
-                                                    name: 'blockLabel',
-                                                    type: 'string',
-                                                    required: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['agentBlocks'],
-                                                            agentBlocksOperation: ['retrieve', 'update'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The label of the memory block',
-                                                },
-                                                {
-                                                    displayName: 'Block Value',
-                                                    name: 'blockValue',
-                                                    type: 'string',
-                                                    typeOptions: {
-                                                        rows: 4,
-                                                    },
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['agentBlocks'],
-                                                            agentBlocksOperation: ['update'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    required: true,
-                                                    description: 'The new value for the memory block',
-                                                },
-                                                {
-                                                    displayName: 'Block ID',
-                                                    name: 'blockId',
-                                                    type: 'string',
-                                                    required: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['agentBlocks'],
-                                                            agentBlocksOperation: ['attach', 'detach'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The ID of the memory block to attach/detach',
-                                                },
-                                                {
-                                                    displayName: 'Agent Tools Operation',
-                                                    name: 'agentToolsOperation',
-                                                    type: 'options',
-                                                    required: true,
-                                                    noDataExpression: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['agentTools'],
-                                                        },
-                                                    },
-                                                    options: [
-                                                        {
-                                                            name: 'List Tools',
-                                                            value: 'list',
-                                                            description: 'List tools attached to an agent',
-                                                            action: 'List agent tools',
-                                                        },
-                                                        {
-                                                            name: 'Attach Tool',
-                                                            value: 'attach',
-                                                            description: 'Attach a tool to an agent',
-                                                            action: 'Attach tool to agent',
-                                                        },
-                                                        {
-                                                            name: 'Detach Tool',
-                                                            value: 'detach',
-                                                            description: 'Detach a tool from an agent',
-                                                            action: 'Detach tool from agent',
-                                                        },
-                                                        {
-                                                            name: 'Update Approval',
-                                                            value: 'updateApproval',
-                                                            description: 'Update tool approval settings for an agent',
-                                                            action: 'Update tool approval',
-                                                        },
-                                                    ],
-                                                    default: 'list',
-                                                    description: 'The agent tools operation to perform',
-                                                },
-                                                {
-                                                    displayName: 'Agent ID',
-                                                    name: 'agentId',
-                                                    type: 'options',
-                                                    required: true,
-                                                    typeOptions: {
-                                                        loadOptionsMethod: 'getLettaAgents',
-                                                    },
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['agentTools'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The agent to perform the operation on',
-                                                },
-                                                {
-                                                    displayName: 'Tool ID',
-                                                    name: 'toolId',
-                                                    type: 'string',
-                                                    required: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['agentTools'],
-                                                            agentToolsOperation: ['attach', 'detach', 'updateApproval'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The ID of the tool',
-                                                },
-                                                {
-                                                    displayName: 'Approval Required',
-                                                    name: 'approvalRequired',
-                                                    type: 'boolean',
-                                                    default: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['agentTools'],
-                                                            agentToolsOperation: ['updateApproval'],
-                                                        },
-                                                    },
-                                                    description: 'Whether approval is required for this tool',
-                                                },
-                                                {
-                                                    displayName: 'Agent Folders Operation',
-                                                    name: 'agentFoldersOperation',
-                                                    type: 'options',
-                                                    required: true,
-                                                    noDataExpression: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['agentFolders'],
-                                                        },
-                                                    },
-                                                    options: [
-                                                        {
-                                                            name: 'List Folders',
-                                                            value: 'list',
-                                                            description: 'List folders attached to an agent',
-                                                            action: 'List agent folders',
-                                                        },
-                                                        {
-                                                            name: 'Attach Folder',
-                                                            value: 'attach',
-                                                            description: 'Attach a folder to an agent',
-                                                            action: 'Attach folder to agent',
-                                                        },
-                                                        {
-                                                            name: 'Detach Folder',
-                                                            value: 'detach',
-                                                            description: 'Detach a folder from an agent',
-                                                            action: 'Detach folder from agent',
-                                                        },
-                                                    ],
-                                                    default: 'list',
-                                                    description: 'The agent folders operation to perform',
-                                                },
-                                                {
-                                                    displayName: 'Agent ID',
-                                                    name: 'agentId',
-                                                    type: 'options',
-                                                    required: true,
-                                                    typeOptions: {
-                                                        loadOptionsMethod: 'getLettaAgents',
-                                                    },
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['agentFolders'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The agent to perform the operation on',
-                                                },
-                                                {
-                                                    displayName: 'Folder ID',
-                                                    name: 'folderId',
-                                                    type: 'string',
-                                                    required: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['agentFolders'],
-                                                            agentFoldersOperation: ['attach', 'detach'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The ID of the folder',
-                                                },
-                                                {
-                                                    displayName: 'Agent Files Operation',
-                                                    name: 'agentFilesOperation',
-                                                    type: 'options',
-                                                    required: true,
-                                                    noDataExpression: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['agentFiles'],
-                                                        },
-                                                    },
-                                                    options: [
-                                                        {
-                                                            name: 'List Files',
-                                                            value: 'list',
-                                                            description: 'List files opened by an agent',
-                                                            action: 'List agent files',
-                                                        },
-                                                        {
-                                                            name: 'Open File',
-                                                            value: 'open',
-                                                            description: 'Open a file for an agent',
-                                                            action: 'Open file for agent',
-                                                        },
-                                                        {
-                                                            name: 'Close File',
-                                                            value: 'close',
-                                                            description: 'Close a file for an agent',
-                                                            action: 'Close file for agent',
-                                                        },
-                                                        {
-                                                            name: 'Close All Files',
-                                                            value: 'closeAll',
-                                                            description: 'Close all files for an agent',
-                                                            action: 'Close all files for agent',
-                                                        },
-                                                    ],
-                                                    default: 'list',
-                                                    description: 'The agent files operation to perform',
-                                                },
-                                                {
-                                                    displayName: 'Agent ID',
-                                                    name: 'agentId',
-                                                    type: 'options',
-                                                    required: true,
-                                                    typeOptions: {
-                                                        loadOptionsMethod: 'getLettaAgents',
-                                                    },
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['agentFiles'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The agent to perform the operation on',
-                                                },
-                                                {
-                                                    displayName: 'File Path',
-                                                    name: 'filePath',
-                                                    type: 'string',
-                                                    required: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['agentFiles'],
-                                                            agentFilesOperation: ['open', 'close'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The path of the file to open/close',
-                                                },
-                                                {
-                                                    displayName: 'Agent Archives Operation',
-                                                    name: 'agentArchivesOperation',
-                                                    type: 'options',
-                                                    required: true,
-                                                    noDataExpression: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['agentArchives'],
-                                                        },
-                                                    },
-                                                    options: [
-                                                        {
-                                                            name: 'Attach Archive',
-                                                            value: 'attach',
-                                                            description: 'Attach an archive to an agent',
-                                                            action: 'Attach archive to agent',
-                                                        },
-                                                        {
-                                                            name: 'Detach Archive',
-                                                            value: 'detach',
-                                                            description: 'Detach an archive from an agent',
-                                                            action: 'Detach archive from agent',
-                                                        },
-                                                    ],
-                                                    default: 'attach',
-                                                    description: 'The agent archives operation to perform',
-                                                },
-                                                {
-                                                    displayName: 'Agent ID',
-                                                    name: 'agentId',
-                                                    type: 'options',
-                                                    required: true,
-                                                    typeOptions: {
-                                                        loadOptionsMethod: 'getLettaAgents',
-                                                    },
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['agentArchives'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The agent to perform the operation on',
-                                                },
-                                                {
-                                                    displayName: 'Archive ID',
-                                                    name: 'archiveId',
-                                                    type: 'string',
-                                                    required: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['agentArchives'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The ID of the archive',
-                                                },
-                                                {
-                                                    displayName: 'Agent Identities Operation',
-                                                    name: 'agentIdentitiesOperation',
-                                                    type: 'options',
-                                                    required: true,
-                                                    noDataExpression: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['agentIdentities'],
-                                                        },
-                                                    },
-                                                    options: [
-                                                        {
-                                                            name: 'Attach Identity',
-                                                            value: 'attach',
-                                                            description: 'Attach an identity to an agent',
-                                                            action: 'Attach identity to agent',
-                                                        },
-                                                        {
-                                                            name: 'Detach Identity',
-                                                            value: 'detach',
-                                                            description: 'Detach an identity from an agent',
-                                                            action: 'Detach identity from agent',
-                                                        },
-                                                    ],
-                                                    default: 'attach',
-                                                    description: 'The agent identities operation to perform',
-                                                },
-                                                {
-                                                    displayName: 'Agent ID',
-                                                    name: 'agentId',
-                                                    type: 'options',
-                                                    required: true,
-                                                    typeOptions: {
-                                                        loadOptionsMethod: 'getLettaAgents',
-                                                    },
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['agentIdentities'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The agent to perform the operation on',
-                                                },
-                                                {
-                                                    displayName: 'Identity ID',
-                                                    name: 'identityId',
-                                                    type: 'string',
-                                                    required: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['agentIdentities'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The ID of the identity',
-                                                },
-                                                {
-                                                    displayName: 'Agent ID',
-                                                    name: 'agentId',
-                                                    type: 'options',
-                                                    required: true,
-                                                    typeOptions: {
-                                                        loadOptionsMethod: 'getLettaAgents',
-                                                    },
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['agentGroups'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The agent to list groups for',
-                                                },
-                                                {
-                                                    displayName: 'Tools Operation',
-                                                    name: 'toolsOperation',
-                                                    type: 'options',
-                                                    required: true,
-                                                    noDataExpression: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['tools'],
-                                                        },
-                                                    },
-                                                    options: [
-                                                        {
-                                                            name: 'List Tools',
-                                                            value: 'list',
-                                                            description: 'List all tools',
-                                                            action: 'List tools',
-                                                        },
-                                                        {
-                                                            name: 'Create Tool',
-                                                            value: 'create',
-                                                            description: 'Create a new tool',
-                                                            action: 'Create tool',
-                                                        },
-                                                        {
-                                                            name: 'Get Tool',
-                                                            value: 'retrieve',
-                                                            description: 'Get a specific tool',
-                                                            action: 'Get tool',
-                                                        },
-                                                        {
-                                                            name: 'Update Tool',
-                                                            value: 'update',
-                                                            description: 'Update an existing tool',
-                                                            action: 'Update tool',
-                                                        },
-                                                        {
-                                                            name: 'Delete Tool',
-                                                            value: 'delete',
-                                                            description: 'Delete a tool',
-                                                            action: 'Delete tool',
-                                                        },
-                                                        {
-                                                            name: 'Upsert Tool',
-                                                            value: 'upsert',
-                                                            description: 'Create or update a tool',
-                                                            action: 'Upsert tool',
-                                                        },
-                                                        {
-                                                            name: 'Upsert Base Tools',
-                                                            value: 'upsertBaseTools',
-                                                            description: 'Upsert base tools',
-                                                            action: 'Upsert base tools',
-                                                        },
-                                                    ],
-                                                    default: 'list',
-                                                    description: 'The tools operation to perform',
-                                                },
-                                                {
-                                                    displayName: 'Tool ID',
-                                                    name: 'toolId',
-                                                    type: 'string',
-                                                    required: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['tools'],
-                                                            toolsOperation: ['retrieve', 'update', 'delete'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The ID of the tool',
-                                                },
-                                                {
-                                                    displayName: 'Tool Name',
-                                                    name: 'toolName',
-                                                    type: 'string',
-                                                    required: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['tools'],
-                                                            toolsOperation: ['create', 'update', 'upsert'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The name of the tool',
-                                                },
-                                                {
-                                                    displayName: 'Tool Description',
-                                                    name: 'toolDescription',
-                                                    type: 'string',
-                                                    typeOptions: {
-                                                        rows: 3,
-                                                    },
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['tools'],
-                                                            toolsOperation: ['create', 'update', 'upsert'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'Description of what the tool does',
-                                                },
-                                                {
-                                                    displayName: 'Tool Source Code',
-                                                    name: 'toolSourceCode',
-                                                    type: 'string',
-                                                    typeOptions: {
-                                                        rows: 8,
-                                                    },
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['tools'],
-                                                            toolsOperation: ['create', 'update', 'upsert'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The Python source code for the tool',
-                                                },
-                                                {
-                                                    displayName: 'Tool Tags',
-                                                    name: 'toolTags',
-                                                    type: 'string',
-                                                    default: '',
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['tools'],
-                                                            toolsOperation: ['create', 'update', 'upsert'],
-                                                        },
-                                                    },
-                                                    description: 'Comma-separated tags for the tool',
-                                                },
-                                                {
-                                                    displayName: 'Blocks Operation',
-                                                    name: 'blocksOperation',
-                                                    type: 'options',
-                                                    required: true,
-                                                    noDataExpression: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['blocks'],
-                                                        },
-                                                    },
-                                                    options: [
-                                                        {
-                                                            name: 'List Blocks',
-                                                            value: 'list',
-                                                            description: 'List all memory blocks',
-                                                            action: 'List blocks',
-                                                        },
-                                                        {
-                                                            name: 'Create Block',
-                                                            value: 'create',
-                                                            description: 'Create a new memory block',
-                                                            action: 'Create block',
-                                                        },
-                                                        {
-                                                            name: 'Get Block',
-                                                            value: 'retrieve',
-                                                            description: 'Get a specific memory block',
-                                                            action: 'Get block',
-                                                        },
-                                                        {
-                                                            name: 'Update Block',
-                                                            value: 'update',
-                                                            description: 'Update an existing memory block',
-                                                            action: 'Update block',
-                                                        },
-                                                        {
-                                                            name: 'Delete Block',
-                                                            value: 'delete',
-                                                            description: 'Delete a memory block',
-                                                            action: 'Delete block',
-                                                        },
-                                                    ],
-                                                    default: 'list',
-                                                    description: 'The blocks operation to perform',
-                                                },
-                                                {
-                                                    displayName: 'Block ID',
-                                                    name: 'blockId',
-                                                    type: 'string',
-                                                    required: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['blocks'],
-                                                            blocksOperation: ['retrieve', 'update', 'delete'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The ID of the memory block',
-                                                },
-                                                {
-                                                    displayName: 'Block Label',
-                                                    name: 'blockLabel',
-                                                    type: 'string',
-                                                    required: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['blocks'],
-                                                            blocksOperation: ['create', 'update'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The label for the memory block',
-                                                },
-                                                {
-                                                    displayName: 'Block Value',
-                                                    name: 'blockValue',
-                                                    type: 'string',
-                                                    typeOptions: {
-                                                        rows: 4,
-                                                    },
-                                                    required: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['blocks'],
-                                                            blocksOperation: ['create', 'update'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The content of the memory block',
-                                                },
-                                                {
-                                                    displayName: 'Block Limit',
-                                                    name: 'blockLimit',
-                                                    type: 'number',
-                                                    default: 50,
-                                                    typeOptions: {
-                                                        minValue: 1,
-                                                        maxValue: 1000,
-                                                    },
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['blocks'],
-                                                            blocksOperation: ['list'],
-                                                        },
-                                                    },
-                                                    description: 'Maximum number of blocks to return',
-                                                },
-                                                {
-                                                    displayName: 'Archives Operation',
-                                                    name: 'archivesOperation',
-                                                    type: 'options',
-                                                    required: true,
-                                                    noDataExpression: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['archives'],
-                                                        },
-                                                    },
-                                                    options: [
-                                                        {
-                                                            name: 'List Archives',
-                                                            value: 'list',
-                                                            description: 'List all archives',
-                                                            action: 'List archives',
-                                                        },
-                                                        {
-                                                            name: 'Create Archive',
-                                                            value: 'create',
-                                                            description: 'Create a new archive',
-                                                            action: 'Create archive',
-                                                        },
-                                                        {
-                                                            name: 'Get Archive',
-                                                            value: 'retrieve',
-                                                            description: 'Get a specific archive',
-                                                            action: 'Get archive',
-                                                        },
-                                                        {
-                                                            name: 'Update Archive',
-                                                            value: 'update',
-                                                            description: 'Update an existing archive',
-                                                            action: 'Update archive',
-                                                        },
-                                                        {
-                                                            name: 'Delete Archive',
-                                                            value: 'delete',
-                                                            description: 'Delete an archive',
-                                                            action: 'Delete archive',
-                                                        },
-                                                    ],
-                                                    default: 'list',
-                                                    description: 'The archives operation to perform',
-                                                },
-                                                {
-                                                    displayName: 'Archive ID',
-                                                    name: 'archiveId',
-                                                    type: 'string',
-                                                    required: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['archives'],
-                                                            archivesOperation: ['retrieve', 'update', 'delete'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The ID of the archive',
-                                                },
-                                                {
-                                                    displayName: 'Archive Name',
-                                                    name: 'archiveName',
-                                                    type: 'string',
-                                                    required: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['archives'],
-                                                            archivesOperation: ['create', 'update'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The name of the archive',
-                                                },
-                                                {
-                                                    displayName: 'Archive Description',
-                                                    name: 'archiveDescription',
-                                                    type: 'string',
-                                                    typeOptions: {
-                                                        rows: 3,
-                                                    },
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['archives'],
-                                                            archivesOperation: ['create', 'update'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'Description of the archive',
-                                                },
-                                                {
-                                                    displayName: 'Folders Operation',
-                                                    name: 'foldersOperation',
-                                                    type: 'options',
-                                                    required: true,
-                                                    noDataExpression: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['folders'],
-                                                        },
-                                                    },
-                                                    options: [
-                                                        {
-                                                            name: 'List Folders',
-                                                            value: 'list',
-                                                            description: 'List all folders',
-                                                            action: 'List folders',
-                                                        },
-                                                        {
-                                                            name: 'Create Folder',
-                                                            value: 'create',
-                                                            description: 'Create a new folder',
-                                                            action: 'Create folder',
-                                                        },
-                                                        {
-                                                            name: 'Get Folder',
-                                                            value: 'retrieve',
-                                                            description: 'Get a specific folder',
-                                                            action: 'Get folder',
-                                                        },
-                                                        {
-                                                            name: 'Update Folder',
-                                                            value: 'update',
-                                                            description: 'Update an existing folder',
-                                                            action: 'Update folder',
-                                                        },
-                                                        {
-                                                            name: 'Delete Folder',
-                                                            value: 'delete',
-                                                            description: 'Delete a folder',
-                                                            action: 'Delete folder',
-                                                        },
-                                                    ],
-                                                    default: 'list',
-                                                    description: 'The folders operation to perform',
-                                                },
-                                                {
-                                                    displayName: 'Folder ID',
-                                                    name: 'folderId',
-                                                    type: 'string',
-                                                    required: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['folders'],
-                                                            foldersOperation: ['retrieve', 'update', 'delete'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The ID of the folder',
-                                                },
-                                                {
-                                                    displayName: 'Folder Name',
-                                                    name: 'folderName',
-                                                    type: 'string',
-                                                    required: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['folders'],
-                                                            foldersOperation: ['create', 'update'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The name of the folder',
-                                                },
-                                                {
-                                                    displayName: 'Embedding Config',
-                                                    name: 'embeddingConfig',
-                                                    type: 'string',
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['folders'],
-                                                            foldersOperation: ['create', 'update'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The embedding configuration for the folder',
-                                                },
-                                                {
-                                                    displayName: 'Models Operation',
-                                                    name: 'modelsOperation',
-                                                    type: 'options',
-                                                    required: true,
-                                                    noDataExpression: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['models'],
-                                                        },
-                                                    },
-                                                    options: [
-                                                        {
-                                                            name: 'List Models',
-                                                            value: 'list',
-                                                            description: 'List all available models',
-                                                            action: 'List models',
-                                                        },
-                                                        {
-                                                            name: 'List Embedding Models',
-                                                            value: 'listEmbeddings',
-                                                            description: 'List all available embedding models',
-                                                            action: 'List embedding models',
-                                                        },
-                                                    ],
-                                                    default: 'list',
-                                                    description: 'The models operation to perform',
-                                                },
-                                                {
-                                                    displayName: 'Tools Operation',
-                                                    name: 'toolsOperation',
-                                                    type: 'options',
-                                                    required: true,
-                                                    noDataExpression: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['tools'],
-                                                        },
-                                                    },
-                                                    options: [
-                                                        {
-                                                            name: 'List Tools',
-                                                            value: 'list',
-                                                            description: 'List all tools',
-                                                            action: 'List tools',
-                                                        },
-                                                        {
-                                                            name: 'Create Tool',
-                                                            value: 'create',
-                                                            description: 'Create a new tool',
-                                                            action: 'Create tool',
-                                                        },
-                                                        {
-                                                            name: 'Get Tool',
-                                                            value: 'retrieve',
-                                                            description: 'Get a specific tool',
-                                                            action: 'Get tool',
-                                                        },
-                                                        {
-                                                            name: 'Update Tool',
-                                                            value: 'update',
-                                                            description: 'Update an existing tool',
-                                                            action: 'Update tool',
-                                                        },
-                                                        {
-                                                            name: 'Delete Tool',
-                                                            value: 'delete',
-                                                            description: 'Delete a tool',
-                                                            action: 'Delete tool',
-                                                        },
-                                                        {
-                                                            name: 'Upsert Tool',
-                                                            value: 'upsert',
-                                                            description: 'Create or update a tool',
-                                                            action: 'Upsert tool',
-                                                        },
-                                                        {
-                                                            name: 'Upsert Base Tools',
-                                                            value: 'upsertBaseTools',
-                                                            description: 'Upsert base tools',
-                                                            action: 'Upsert base tools',
-                                                        },
-                                                    ],
-                                                    default: 'list',
-                                                    description: 'The tools operation to perform',
-                                                },
-                                                {
-                                                    displayName: 'Tool ID',
-                                                    name: 'toolId',
-                                                    type: 'string',
-                                                    required: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['tools'],
-                                                            toolsOperation: ['retrieve', 'update', 'delete'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The ID of the tool',
-                                                },
-                                                {
-                                                    displayName: 'Tool Name',
-                                                    name: 'toolName',
-                                                    type: 'string',
-                                                    required: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['tools'],
-                                                            toolsOperation: ['create', 'update', 'upsert'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The name of the tool',
-                                                },
-                                                {
-                                                    displayName: 'Tool Description',
-                                                    name: 'toolDescription',
-                                                    type: 'string',
-                                                    typeOptions: {
-                                                        rows: 3,
-                                                    },
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['tools'],
-                                                            toolsOperation: ['create', 'update', 'upsert'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'Description of what the tool does',
-                                                },
-                                                {
-                                                    displayName: 'Tool Source Code',
-                                                    name: 'toolSourceCode',
-                                                    type: 'string',
-                                                    typeOptions: {
-                                                        rows: 8,
-                                                    },
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['tools'],
-                                                            toolsOperation: ['create', 'update', 'upsert'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The Python source code for the tool',
-                                                },
-                                                {
-                                                    displayName: 'Tool Tags',
-                                                    name: 'toolTags',
-                                                    type: 'string',
-                                                    default: '',
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['tools'],
-                                                            toolsOperation: ['create', 'update', 'upsert'],
-                                                        },
-                                                    },
-                                                    description: 'Comma-separated tags for the tool',
-                                                },
-                                                {
-                                                    displayName: 'Blocks Operation',
-                                                    name: 'blocksOperation',
-                                                    type: 'options',
-                                                    required: true,
-                                                    noDataExpression: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['blocks'],
-                                                        },
-                                                    },
-                                                    options: [
-                                                        {
-                                                            name: 'List Blocks',
-                                                            value: 'list',
-                                                            description: 'List all memory blocks',
-                                                            action: 'List blocks',
-                                                        },
-                                                        {
-                                                            name: 'Create Block',
-                                                            value: 'create',
-                                                            description: 'Create a new memory block',
-                                                            action: 'Create block',
-                                                        },
-                                                        {
-                                                            name: 'Get Block',
-                                                            value: 'retrieve',
-                                                            description: 'Get a specific memory block',
-                                                            action: 'Get block',
-                                                        },
-                                                        {
-                                                            name: 'Update Block',
-                                                            value: 'update',
-                                                            description: 'Update an existing memory block',
-                                                            action: 'Update block',
-                                                        },
-                                                        {
-                                                            name: 'Delete Block',
-                                                            value: 'delete',
-                                                            description: 'Delete a memory block',
-                                                            action: 'Delete block',
-                                                        },
-                                                    ],
-                                                    default: 'list',
-                                                    description: 'The blocks operation to perform',
-                                                },
-                                                {
-                                                    displayName: 'Block ID',
-                                                    name: 'blockId',
-                                                    type: 'string',
-                                                    required: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['blocks'],
-                                                            blocksOperation: ['retrieve', 'update', 'delete'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The ID of the memory block',
-                                                },
-                                                {
-                                                    displayName: 'Block Label',
-                                                    name: 'blockLabel',
-                                                    type: 'string',
-                                                    required: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['blocks'],
-                                                            blocksOperation: ['create', 'update'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The label for the memory block',
-                                                },
-                                                {
-                                                    displayName: 'Block Value',
-                                                    name: 'blockValue',
-                                                    type: 'string',
-                                                    typeOptions: {
-                                                        rows: 4,
-                                                    },
-                                                    required: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['blocks'],
-                                                            blocksOperation: ['create', 'update'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The content of the memory block',
-                                                },
-                                                {
-                                                    displayName: 'Block Limit',
-                                                    name: 'blockLimit',
-                                                    type: 'number',
-                                                    default: 50,
-                                                    typeOptions: {
-                                                        minValue: 1,
-                                                        maxValue: 1000,
-                                                    },
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['blocks'],
-                                                            blocksOperation: ['list'],
-                                                        },
-                                                    },
-                                                    description: 'Maximum number of blocks to return',
-                                                },
-                                                {
-                                                    displayName: 'Folders Operation',
-                                                    name: 'foldersOperation',
-                                                    type: 'options',
-                                                    required: true,
-                                                    noDataExpression: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['folders'],
-                                                        },
-                                                    },
-                                                    options: [
-                                                        {
-                                                            name: 'List Folders',
-                                                            value: 'list',
-                                                            description: 'List all folders',
-                                                            action: 'List folders',
-                                                        },
-                                                        {
-                                                            name: 'Create Folder',
-                                                            value: 'create',
-                                                            description: 'Create a new folder',
-                                                            action: 'Create folder',
-                                                        },
-                                                        {
-                                                            name: 'Get Folder',
-                                                            value: 'retrieve',
-                                                            description: 'Get a specific folder',
-                                                            action: 'Get folder',
-                                                        },
-                                                        {
-                                                            name: 'Update Folder',
-                                                            value: 'update',
-                                                            description: 'Update an existing folder',
-                                                            action: 'Update folder',
-                                                        },
-                                                        {
-                                                            name: 'Delete Folder',
-                                                            value: 'delete',
-                                                            description: 'Delete a folder',
-                                                            action: 'Delete folder',
-                                                        },
-                                                    ],
-                                                    default: 'list',
-                                                    description: 'The folders operation to perform',
-                                                },
-                                                {
-                                                    displayName: 'Folder ID',
-                                                    name: 'folderId',
-                                                    type: 'string',
-                                                    required: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['folders'],
-                                                            foldersOperation: ['retrieve', 'update', 'delete'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The ID of the folder',
-                                                },
-                                                {
-                                                    displayName: 'Folder Name',
-                                                    name: 'folderName',
-                                                    type: 'string',
-                                                    required: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['folders'],
-                                                            foldersOperation: ['create', 'update'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The name of the folder',
-                                                },
-                                                {
-                                                    displayName: 'Embedding Config',
-                                                    name: 'embeddingConfig',
-                                                    type: 'string',
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['folders'],
-                                                            foldersOperation: ['create', 'update'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The embedding configuration for the folder',
-                                                },
-                                                {
-                                                    displayName: 'MCP Servers Operation',
-                                                    name: 'mcpServersOperation',
-                                                    type: 'options',
-                                                    required: true,
-                                                    noDataExpression: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['mcpServers'],
-                                                        },
-                                                    },
-                                                    options: [
-                                                        {
-                                                            name: 'List MCP Servers',
-                                                            value: 'list',
-                                                            description: 'List all MCP servers',
-                                                            action: 'List MCP servers',
-                                                        },
-                                                        {
-                                                            name: 'Create MCP Server',
-                                                            value: 'create',
-                                                            description: 'Create a new MCP server',
-                                                            action: 'Create MCP server',
-                                                        },
-                                                        {
-                                                            name: 'Get MCP Server',
-                                                            value: 'retrieve',
-                                                            description: 'Get a specific MCP server',
-                                                            action: 'Get MCP server',
-                                                        },
-                                                        {
-                                                            name: 'Update MCP Server',
-                                                            value: 'update',
-                                                            description: 'Update an existing MCP server',
-                                                            action: 'Update MCP server',
-                                                        },
-                                                        {
-                                                            name: 'Delete MCP Server',
-                                                            value: 'delete',
-                                                            description: 'Delete an MCP server',
-                                                            action: 'Delete MCP server',
-                                                        },
-                                                        {
-                                                            name: 'Refresh MCP Server',
-                                                            value: 'refresh',
-                                                            description: 'Refresh an MCP server',
-                                                            action: 'Refresh MCP server',
-                                                        },
-                                                    ],
-                                                    default: 'list',
-                                                    description: 'The MCP servers operation to perform',
-                                                },
-                                                {
-                                                    displayName: 'MCP Server ID',
-                                                    name: 'mcpServerId',
-                                                    type: 'string',
-                                                    required: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['mcpServers'],
-                                                            mcpServersOperation: ['retrieve', 'update', 'delete', 'refresh'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The ID of the MCP server',
-                                                },
-                                                {
-                                                    displayName: 'MCP Server Name',
-                                                    name: 'mcpServerName',
-                                                    type: 'string',
-                                                    required: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['mcpServers'],
-                                                            mcpServersOperation: ['create', 'update'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The name of the MCP server',
-                                                },
-                                                {
-                                                    displayName: 'MCP Server Command',
-                                                    name: 'mcpServerCommand',
-                                                    type: 'string',
-                                                    required: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['mcpServers'],
-                                                            mcpServersOperation: ['create', 'update'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The command to run the MCP server',
-                                                },
-                                                {
-                                                    displayName: 'MCP Servers Operation',
-                                                    name: 'mcpServersOperation',
-                                                    type: 'options',
-                                                    required: true,
-                                                    noDataExpression: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['mcpServers'],
-                                                        },
-                                                    },
-                                                    options: [
-                                                        {
-                                                            name: 'List MCP Servers',
-                                                            value: 'list',
-                                                            description: 'List all MCP servers',
-                                                            action: 'List MCP servers',
-                                                        },
-                                                        {
-                                                            name: 'Create MCP Server',
-                                                            value: 'create',
-                                                            description: 'Create a new MCP server',
-                                                            action: 'Create MCP server',
-                                                        },
-                                                        {
-                                                            name: 'Get MCP Server',
-                                                            value: 'retrieve',
-                                                            description: 'Get a specific MCP server',
-                                                            action: 'Get MCP server',
-                                                        },
-                                                        {
-                                                            name: 'Update MCP Server',
-                                                            value: 'update',
-                                                            description: 'Update an existing MCP server',
-                                                            action: 'Update MCP server',
-                                                        },
-                                                        {
-                                                            name: 'Delete MCP Server',
-                                                            value: 'delete',
-                                                            description: 'Delete an MCP server',
-                                                            action: 'Delete MCP server',
-                                                        },
-                                                        {
-                                                            name: 'Refresh MCP Server',
-                                                            value: 'refresh',
-                                                            description: 'Refresh an MCP server',
-                                                            action: 'Refresh MCP server',
-                                                        },
-                                                    ],
-                                                    default: 'list',
-                                                    description: 'The MCP servers operation to perform',
-                                                },
-                                                {
-                                                    displayName: 'MCP Server ID',
-                                                    name: 'mcpServerId',
-                                                    type: 'string',
-                                                    required: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['mcpServers'],
-                                                            mcpServersOperation: ['retrieve', 'update', 'delete', 'refresh'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The ID of the MCP server',
-                                                },
-                                                {
-                                                    displayName: 'MCP Server Name',
-                                                    name: 'mcpServerName',
-                                                    type: 'string',
-                                                    required: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['mcpServers'],
-                                                            mcpServersOperation: ['create', 'update'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The name of the MCP server',
-                                                },
-                                                {
-                                                    displayName: 'MCP Server Command',
-                                                    name: 'mcpServerCommand',
-                                                    type: 'string',
-                                                    required: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['mcpServers'],
-                                                            mcpServersOperation: ['create', 'update'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The command to run the MCP server',
-                                                },
-                                                {
-                                                    displayName: 'Runs Operation',
-                                                    name: 'runsOperation',
-                                                    type: 'options',
-                                                    required: true,
-                                                    noDataExpression: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['runs'],
-                                                        },
-                                                    },
-                                                    options: [
-                                                        {
-                                                            name: 'List Runs',
-                                                            value: 'list',
-                                                            description: 'List all runs',
-                                                            action: 'List runs',
-                                                        },
-                                                        {
-                                                            name: 'Get Run',
-                                                            value: 'retrieve',
-                                                            description: 'Get a specific run',
-                                                            action: 'Get run',
-                                                        },
-                                                    ],
-                                                    default: 'list',
-                                                    description: 'The runs operation to perform',
-                                                },
-                                                {
-                                                    displayName: 'Run ID',
-                                                    name: 'runId',
-                                                    type: 'string',
-                                                    required: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['runs'],
-                                                            runsOperation: ['retrieve'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The ID of the run',
-                                                },
-                                                {
-                                                    displayName: 'Steps Operation',
-                                                    name: 'stepsOperation',
-                                                    type: 'options',
-                                                    required: true,
-                                                    noDataExpression: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['steps'],
-                                                        },
-                                                    },
-                                                    options: [
-                                                        {
-                                                            name: 'List Steps',
-                                                            value: 'list',
-                                                            description: 'List all steps',
-                                                            action: 'List steps',
-                                                        },
-                                                        {
-                                                            name: 'Get Step',
-                                                            value: 'retrieve',
-                                                            description: 'Get a specific step',
-                                                            action: 'Get step',
-                                                        },
-                                                    ],
-                                                    default: 'list',
-                                                    description: 'The steps operation to perform',
-                                                },
-                                                {
-                                                    displayName: 'Step ID',
-                                                    name: 'stepId',
-                                                    type: 'string',
-                                                    required: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['steps'],
-                                                            stepsOperation: ['retrieve'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The ID of the step',
-                                                },
-                                                {
-                                                    displayName: 'Template Operation',
-                                                    name: 'templateOperation',
-                                                    type: 'options',
-                                                    required: true,
-                                                    noDataExpression: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['templates'],
-                                                        },
-                                                    },
-                                                    options: [
-                                                        {
-                                                            name: 'Create Agent from Template',
-                                                            value: 'createAgent',
-                                                            description: 'Create an agent from a template',
-                                                            action: 'Create agent from template',
-                                                        },
-                                                    ],
-                                                    default: 'createAgent',
-                                                    description: 'The template operation to perform',
-                                                },
-                                                {
-                                                    displayName: 'Template ID',
-                                                    name: 'templateId',
-                                                    type: 'string',
-                                                    required: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['templates'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The ID of the template',
-                                                },
-                                                {
-                                                    displayName: 'Identities Operation',
-                                                    name: 'identitiesOperation',
-                                                    type: 'options',
-                                                    required: true,
-                                                    noDataExpression: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['identities'],
-                                                        },
-                                                    },
-                                                    options: [
-                                                        {
-                                                            name: 'List Identities',
-                                                            value: 'list',
-                                                            description: 'List all identities',
-                                                            action: 'List identities',
-                                                        },
-                                                        {
-                                                            name: 'Create Identity',
-                                                            value: 'create',
-                                                            description: 'Create a new identity',
-                                                            action: 'Create identity',
-                                                        },
-                                                        {
-                                                            name: 'Upsert Identity',
-                                                            value: 'upsert',
-                                                            description: 'Create or update an identity',
-                                                            action: 'Upsert identity',
-                                                        },
-                                                        {
-                                                            name: 'Get Identity',
-                                                            value: 'retrieve',
-                                                            description: 'Get a specific identity',
-                                                            action: 'Get identity',
-                                                        },
-                                                        {
-                                                            name: 'Update Identity',
-                                                            value: 'update',
-                                                            description: 'Update an existing identity',
-                                                            action: 'Update identity',
-                                                        },
-                                                        {
-                                                            name: 'Delete Identity',
-                                                            value: 'delete',
-                                                            description: 'Delete an identity',
-                                                            action: 'Delete identity',
-                                                        },
-                                                    ],
-                                                    default: 'list',
-                                                    description: 'The identities operation to perform',
-                                                },
-                                                {
-                                                    displayName: 'Identity ID',
-                                                    name: 'identityId',
-                                                    type: 'string',
-                                                    required: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['identities'],
-                                                            identitiesOperation: ['retrieve', 'update', 'delete'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The ID of the identity',
-                                                },
-                                                {
-                                                    displayName: 'Identity Key',
-                                                    name: 'identityKey',
-                                                    type: 'string',
-                                                    required: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['identities'],
-                                                            identitiesOperation: ['create', 'upsert', 'update'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The unique key for the identity',
-                                                },
-                                                {
-                                                    displayName: 'Identity Name',
-                                                    name: 'identityName',
-                                                    type: 'string',
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['identities'],
-                                                            identitiesOperation: ['create', 'upsert', 'update'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The name of the identity',
-                                                },
-                                                {
-                                                    displayName: 'Identity Type',
-                                                    name: 'identityType',
-                                                    type: 'options',
-                                                    options: [
-                                                        { name: 'User', value: 'user' },
-                                                        { name: 'Organization', value: 'org' },
-                                                        { name: 'Other', value: 'other' },
-                                                    ],
-                                                    default: 'user',
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['identities'],
-                                                            identitiesOperation: ['create', 'upsert', 'update'],
-                                                        },
-                                                    },
-                                                    description: 'The type of identity',
-                                                },
-                                                {
-                                                    displayName: 'Groups Operation',
-                                                    name: 'groupsOperation',
-                                                    type: 'options',
-                                                    required: true,
-                                                    noDataExpression: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['groups'],
-                                                        },
-                                                    },
-                                                    options: [
-                                                        {
-                                                            name: 'List Groups',
-                                                            value: 'list',
-                                                            description: 'List all groups',
-                                                            action: 'List groups',
-                                                        },
-                                                        {
-                                                            name: 'Create Group',
-                                                            value: 'create',
-                                                            description: 'Create a new group',
-                                                            action: 'Create group',
-                                                        },
-                                                        {
-                                                            name: 'Get Group',
-                                                            value: 'retrieve',
-                                                            description: 'Get a specific group',
-                                                            action: 'Get group',
-                                                        },
-                                                        {
-                                                            name: 'Update Group',
-                                                            value: 'update',
-                                                            description: 'Update an existing group',
-                                                            action: 'Update group',
-                                                        },
-                                                        {
-                                                            name: 'Delete Group',
-                                                            value: 'delete',
-                                                            description: 'Delete a group',
-                                                            action: 'Delete group',
-                                                        },
-                                                    ],
-                                                    default: 'list',
-                                                    description: 'The groups operation to perform',
-                                                },
-                                                {
-                                                    displayName: 'Group ID',
-                                                    name: 'groupId',
-                                                    type: 'string',
-                                                    required: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['groups'],
-                                                            groupsOperation: ['retrieve', 'update', 'delete'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The ID of the group',
-                                                },
-                                                {
-                                                    displayName: 'Group Name',
-                                                    name: 'groupName',
-                                                    type: 'string',
-                                                    required: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['groups'],
-                                                            groupsOperation: ['create', 'update'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The name of the group',
-                                                },
-                                                {
-                                                    displayName: 'Batches Operation',
-                                                    name: 'batchesOperation',
-                                                    type: 'options',
-                                                    required: true,
-                                                    noDataExpression: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['batches'],
-                                                        },
-                                                    },
-                                                    options: [
-                                                        {
-                                                            name: 'List Batches',
-                                                            value: 'list',
-                                                            description: 'List all batches',
-                                                            action: 'List batches',
-                                                        },
-                                                        {
-                                                            name: 'Create Batch',
-                                                            value: 'create',
-                                                            description: 'Create a new batch',
-                                                            action: 'Create batch',
-                                                        },
-                                                        {
-                                                            name: 'Get Batch',
-                                                            value: 'retrieve',
-                                                            description: 'Get a specific batch',
-                                                            action: 'Get batch',
-                                                        },
-                                                        {
-                                                            name: 'Cancel Batch',
-                                                            value: 'cancel',
-                                                            description: 'Cancel a batch',
-                                                            action: 'Cancel batch',
-                                                        },
-                                                    ],
-                                                    default: 'list',
-                                                    description: 'The batches operation to perform',
-                                                },
-                                                {
-                                                    displayName: 'Batch ID',
-                                                    name: 'batchId',
-                                                    type: 'string',
-                                                    required: true,
-                                                    displayOptions: {
-                                                        show: {
-                                                            operation: ['batches'],
-                                                            batchesOperation: ['retrieve', 'cancel'],
-                                                        },
-                                                    },
-                                                    default: '',
-                                                    description: 'The ID of the batch',
-                                                },
                                             ],
                                         },
                                         {
@@ -3352,54 +1319,6 @@ exports.UNIVERSAL_AGENT_DESCRIPTION = {
                     description: 'Send a message to an agent and receive a response',
                     action: 'Chat with agent',
                 },
-                {
-                    name: 'Agent Messages',
-                    value: 'agentMessages',
-                    description: 'List, create, stream, or manage agent messages',
-                    action: 'Manage agent messages',
-                },
-                {
-                    name: 'Agent Blocks',
-                    value: 'agentBlocks',
-                    description: 'Manage memory blocks attached to agents',
-                    action: 'Manage agent blocks',
-                },
-                {
-                    name: 'Agent Tools',
-                    value: 'agentTools',
-                    description: 'Manage tools attached to agents',
-                    action: 'Manage agent tools',
-                },
-                {
-                    name: 'Agent Folders',
-                    value: 'agentFolders',
-                    description: 'Manage folders attached to agents',
-                    action: 'Manage agent folders',
-                },
-                {
-                    name: 'Agent Files',
-                    value: 'agentFiles',
-                    description: 'Manage files opened by agents',
-                    action: 'Manage agent files',
-                },
-                {
-                    name: 'Agent Archives',
-                    value: 'agentArchives',
-                    description: 'Manage archives attached to agents',
-                    action: 'Manage agent archives',
-                },
-                {
-                    name: 'Agent Identities',
-                    value: 'agentIdentities',
-                    description: 'Manage identities attached to agents',
-                    action: 'Manage agent identities',
-                },
-                {
-                    name: 'Agent Groups',
-                    value: 'agentGroups',
-                    description: 'List agent groups',
-                    action: 'List agent groups',
-                },
                 {
                     name: 'Create Agent',
                     value: 'createAgent',
@@ -3413,82 +1332,46 @@ exports.UNIVERSAL_AGENT_DESCRIPTION = {
                     action: 'Manage agent',
                 },
                 {
-                    name: 'Tools',
+                    name: 'List Agents',
+                    value: 'listAgents',
+                    description: 'List all available agents',
+                    action: 'List agents',
+                },
+                {
+                    name: 'Manage Identity',
+                    value: 'manageIdentity',
+                    description: 'Create or update a user identity for context isolation',
+                    action: 'Manage identity',
+                },
+                {
+                    name: 'Manage Tools',
                     value: 'tools',
-                    description: 'Create, read, update, delete tools',
+                    description: 'Manage Letta tools',
                     action: 'Manage tools',
                 },
                 {
-                    name: 'Blocks',
+                    name: 'Manage Blocks',
                     value: 'blocks',
-                    description: 'Create, read, update, delete memory blocks',
+                    description: 'Manage Letta memory blocks',
                     action: 'Manage blocks',
                 },
                 {
-                    name: 'Archives',
-                    value: 'archives',
-                    description: 'Create, read, update, delete archives and passages',
-                    action: 'Manage archives',
-                },
-                {
-                    name: 'Folders',
+                    name: 'Manage Folders',
                     value: 'folders',
-                    description: 'Create, read, update, delete folders and manage files',
+                    description: 'Manage Letta folders',
                     action: 'Manage folders',
                 },
                 {
-                    name: 'Models',
-                    value: 'models',
-                    description: 'List available models and embeddings',
-                    action: 'List models',
-                },
-                {
-                    name: 'MCP Servers',
+                    name: 'Manage MCP Servers',
                     value: 'mcpServers',
-                    description: 'Manage Model Context Protocol servers',
-                    action: 'Manage MCP servers',
-                },
-                {
-                    name: 'Runs',
-                    value: 'runs',
-                    description: 'List and retrieve agent runs',
-                    action: 'Manage runs',
-                },
-                {
-                    name: 'Steps',
-                    value: 'steps',
-                    description: 'List and retrieve agent steps',
-                    action: 'Manage steps',
-                },
-                {
-                    name: 'Templates',
-                    value: 'templates',
-                    description: 'Create agents from templates',
-                    action: 'Use templates',
-                },
-                {
-                    name: 'Tags',
-                    value: 'tags',
-                    description: 'List available tags',
-                    action: 'List tags',
-                },
-                {
-                    name: 'Identities',
-                    value: 'identities',
-                    description: 'Create, read, update, delete identities',
-                    action: 'Manage identities',
-                },
-                {
-                    name: 'Groups',
-                    value: 'groups',
-                    description: 'Create, read, update, delete groups and messages',
-                    action: 'Manage groups',
+                    description: 'Manage Letta MCP servers',
+                    action: 'Manage mcp servers',
                 },
                 {
-                    name: 'Batches',
-                    value: 'batches',
-                    description: 'Create, read, update, delete batches and messages',
-                    action: 'Manage batches',
+                    name: 'List Models',
+                    value: 'models',
+                    description: 'List available Letta models',
+                    action: 'List models',
                 },
             ],
             default: 'chat',
@@ -3700,14 +1583,14 @@ exports.UNIVERSAL_AGENT_DESCRIPTION = {
                                     name: 'label',
                                     type: 'string',
                                     default: '',
-                                    description: 'A unique name for the memory block (e.g., "user_preferences", "project_context").',
+                                    description: 'Memory block label',
                                 },
                                 {
                                     displayName: 'Value',
                                     name: 'value',
                                     type: 'string',
                                     default: '',
-                                    description: 'The content to store in the memory block. Can be a simple string, JSON, or any text-based data.',
+                                    description: 'Memory block value',
                                 },
                             ],
                         },
@@ -4049,14 +1932,12 @@ exports.UNIVERSAL_AGENT_DESCRIPTION = {
                                     name: 'label',
                                     type: 'string',
                                     default: '',
-                                    description: 'A unique name for the memory block (e.g., "user_preferences", "project_context").',
                                 },
                                 {
                                     displayName: 'Value',
                                     name: 'value',
                                     type: 'string',
                                     default: '',
-                                    description: 'The content to store in the memory block. Can be a simple string, JSON, or any text-based data.',
                                 },
                             ],
                         },
@@ -4098,18 +1979,10 @@ exports.UNIVERSAL_AGENT_DESCRIPTION = {
                             displayName: 'Secret',
                             values: [
                                 {
-                                    displayName: 'Value',
-                                    name: 'value',
-                                    type: 'string',
-                                    default: '',
-                                    description: 'The content to store in the memory block. Can be a simple string, JSON, or any text-based data.',
-                                },
-                                {
-                                    displayName: 'Description',
-                                    name: 'description',
+                                    displayName: 'Key',
+                                    name: 'key',
                                     type: 'string',
                                     default: '',
-                                    description: 'A description of what this memory block contains and how it should be used.',
                                 },
                                 {
                                     displayName: 'Value',
@@ -4296,32 +2169,18 @@ exports.UNIVERSAL_AGENT_DESCRIPTION = {
                     description: 'A new description for the agent.',
                 },
                 {
-                    displayName: 'Value',
-                    name: 'value',
-                    type: 'string',
-                    default: '',
-                    description: 'The content to store in the memory block. Can be a simple string, JSON, or any text-based data.',
-                },
-                {
-                    displayName: 'Description',
-                    name: 'description',
-                    type: 'string',
-                    default: '',
-                    description: 'A description of what this memory block contains and how it should be used.',
-                },
-                {
-                    displayName: 'Value',
-                    name: 'value',
+                    displayName: 'Tool IDs',
+                    name: 'tool_ids',
                     type: 'string',
                     default: '',
-                    description: 'The content to store in the memory block. Can be a simple string, JSON, or any text-based data.',
+                    description: 'Comma-separated IDs of tools to attach. This will overwrite existing tools.',
                 },
                 {
-                    displayName: 'Description',
-                    name: 'description',
+                    displayName: 'Source IDs',
+                    name: 'source_ids',
                     type: 'string',
                     default: '',
-                    description: 'A description of what this memory block contains and how it should be used.',
+                    description: 'Comma-separated IDs of data sources to attach. This will overwrite existing sources.',
                 },
             ],
         },
@@ -4454,6 +2313,335 @@ exports.UNIVERSAL_AGENT_DESCRIPTION = {
                 },
             ],
         },
+        {
+            displayName: 'Tags',
+            name: 'listAgentsTags',
+            type: 'string',
+            default: '',
+            displayOptions: {
+                show: {
+                    operation: ['listAgents'],
+                },
+            },
+            description: 'Comma-separated tags to filter agents by',
+        },
+        {
+            displayName: 'Tools Operation',
+            name: 'toolsOperation',
+            type: 'options',
+            required: true,
+            displayOptions: {
+                show: {
+                    operation: ['tools'],
+                },
+            },
+            options: [
+                { name: 'List', value: 'list' },
+                { name: 'Create', value: 'create' },
+                { name: 'Get', value: 'get' },
+                { name: 'Update', value: 'update' },
+                { name: 'Delete', value: 'delete' },
+                { name: 'Upsert', value: 'upsert' },
+                { name: 'Upsert Base Tools', value: 'upsertBase' },
+            ],
+            default: 'list',
+            description: 'The specific operation to perform on tools',
+        },
+        {
+            displayName: 'Tool ID',
+            name: 'toolId',
+            type: 'string',
+            default: '',
+            required: true,
+            displayOptions: {
+                show: {
+                    '/operation': ['tools'],
+                    '/toolsOperation': ['get', 'update', 'delete'],
+                },
+            },
+            description: 'ID of the tool to manage',
+        },
+        {
+            displayName: 'Name',
+            name: 'toolName',
+            type: 'string',
+            default: '',
+            required: true,
+            displayOptions: {
+                show: {
+                    '/operation': ['tools'],
+                    '/toolsOperation': ['create', 'update', 'upsert'],
+                },
+            },
+            description: 'Name for the tool',
+        },
+        {
+            displayName: 'Description',
+            name: 'toolDescription',
+            type: 'string',
+            default: '',
+            required: true,
+            displayOptions: {
+                show: {
+                    '/operation': ['tools'],
+                    '/toolsOperation': ['create', 'update', 'upsert'],
+                },
+            },
+            description: 'Description for the tool',
+        },
+        {
+            displayName: 'Source Code',
+            name: 'toolSourceCode',
+            type: 'string',
+            typeOptions: { rows: 8 },
+            default: '',
+            required: true,
+            displayOptions: {
+                show: {
+                    '/operation': ['tools'],
+                    '/toolsOperation': ['create', 'update', 'upsert'],
+                },
+            },
+            description: 'Python source code for the tool',
+        },
+        {
+            displayName: 'Tags',
+            name: 'toolTags',
+            type: 'string',
+            default: '',
+            displayOptions: {
+                show: {
+                    '/operation': ['tools'],
+                    '/toolsOperation': ['create', 'update', 'upsert'],
+                },
+            },
+            description: 'Comma-separated tags for the tool',
+        },
+        {
+            displayName: 'Blocks Operation',
+            name: 'blocksOperation',
+            type: 'options',
+            required: true,
+            displayOptions: {
+                show: {
+                    operation: ['blocks'],
+                },
+            },
+            options: [
+                { name: 'List', value: 'list' },
+                { name: 'Create', value: 'create' },
+                { name: 'Get', value: 'get' },
+                { name: 'Update', value: 'update' },
+                { name: 'Delete', value: 'delete' },
+            ],
+            default: 'list',
+            description: 'The specific operation to perform on memory blocks',
+        },
+        {
+            displayName: 'Limit',
+            name: 'limit',
+            type: 'number',
+            default: 100,
+            displayOptions: { show: { operation: ['blocks'], '/blocksOperation': ['list'] } },
+            description: 'Maximum number of blocks to return',
+        },
+        {
+            displayName: 'Block ID',
+            name: 'blockId',
+            type: 'string',
+            default: '',
+            required: true,
+            displayOptions: {
+                show: {
+                    '/operation': ['blocks'],
+                    '/blocksOperation': ['get', 'update', 'delete'],
+                },
+            },
+            description: 'ID of the memory block to manage',
+        },
+        {
+            displayName: 'Label',
+            name: 'blockLabel',
+            type: 'string',
+            default: '',
+            required: true,
+            displayOptions: {
+                show: {
+                    '/operation': ['blocks'],
+                    '/blocksOperation': ['create', 'update'],
+                },
+            },
+            description: 'Label for the memory block',
+        },
+        {
+            displayName: 'Value',
+            name: 'blockValue',
+            type: 'string',
+            typeOptions: { rows: 4 },
+            default: '',
+            required: true,
+            displayOptions: {
+                show: {
+                    '/operation': ['blocks'],
+                    '/blocksOperation': ['create', 'update'],
+                },
+            },
+            description: 'Value for the memory block',
+        },
+        {
+            displayName: 'Description',
+            name: 'blockDescription',
+            type: 'string',
+            default: '',
+            displayOptions: {
+                show: {
+                    '/operation': ['blocks'],
+                    '/blocksOperation': ['create', 'update'],
+                },
+            },
+            description: 'Description for the memory block',
+        },
+        {
+            displayName: 'Folders Operation',
+            name: 'foldersOperation',
+            type: 'options',
+            required: true,
+            displayOptions: {
+                show: {
+                    operation: ['folders'],
+                },
+            },
+            options: [
+                { name: 'List', value: 'list' },
+                { name: 'Create', value: 'create' },
+                { name: 'Get', value: 'get' },
+                { name: 'Update', value: 'update' },
+                { name: 'Delete', value: 'delete' },
+            ],
+            default: 'list',
+            description: 'The specific operation to perform on folders',
+        },
+        {
+            displayName: 'Folder ID',
+            name: 'folderId',
+            type: 'string',
+            default: '',
+            required: true,
+            displayOptions: {
+                show: {
+                    '/operation': ['folders'],
+                    '/foldersOperation': ['get', 'update', 'delete'],
+                },
+            },
+            description: 'ID of the folder to manage',
+        },
+        {
+            displayName: 'Folder Name',
+            name: 'folderName',
+            type: 'string',
+            default: '',
+            required: true,
+            displayOptions: {
+                show: {
+                    '/operation': ['folders'],
+                    '/foldersOperation': ['create', 'update'],
+                },
+            },
+            description: 'Name for the folder',
+        },
+        {
+            displayName: 'Embedding Config',
+            name: 'embeddingConfig',
+            type: 'json',
+            default: '{}',
+            displayOptions: {
+                show: {
+                    '/operation': ['folders'],
+                    '/foldersOperation': ['create', 'update'],
+                },
+            },
+            description: 'JSON configuration for folder embedding',
+        },
+        {
+            displayName: 'MCP Servers Operation',
+            name: 'mcpServersOperation',
+            type: 'options',
+            required: true,
+            displayOptions: {
+                show: {
+                    operation: ['mcpServers'],
+                },
+            },
+            options: [
+                { name: 'List', value: 'list' },
+                { name: 'Create', value: 'create' },
+                { name: 'Get', value: 'get' },
+                { name: 'Update', value: 'update' },
+                { name: 'Delete', value: 'delete' },
+                { name: 'Refresh', value: 'refresh' },
+            ],
+            default: 'list',
+            description: 'The specific operation to perform on MCP servers',
+        },
+        {
+            displayName: 'Server ID',
+            name: 'serverId',
+            type: 'string',
+            default: '',
+            required: true,
+            displayOptions: {
+                show: {
+                    '/operation': ['mcpServers'],
+                    '/mcpServersOperation': ['get', 'update', 'delete', 'refresh'],
+                },
+            },
+            description: 'ID of the MCP server to manage',
+        },
+        {
+            displayName: 'Server Name',
+            name: 'serverName',
+            type: 'string',
+            default: '',
+            required: true,
+            displayOptions: {
+                show: {
+                    '/operation': ['mcpServers'],
+                    '/mcpServersOperation': ['create', 'update'],
+                },
+            },
+            description: 'Name for the MCP server',
+        },
+        {
+            displayName: 'Server Command',
+            name: 'serverCommand',
+            type: 'string',
+            default: '',
+            required: true,
+            displayOptions: {
+                show: {
+                    '/operation': ['mcpServers'],
+                    '/mcpServersOperation': ['create', 'update'],
+                },
+            },
+            description: 'Command to run the MCP server',
+        },
+        {
+            displayName: 'Models Operation',
+            name: 'modelsOperation',
+            type: 'options',
+            required: true,
+            displayOptions: {
+                show: {
+                    operation: ['models'],
+                },
+            },
+            options: [
+                { name: 'List LLM Models', value: 'llm' },
+                { name: 'List Embedding Models', value: 'embedding' },
+            ],
+            default: 'llm',
+            description: 'The specific operation to perform on models',
+        },
     ],
 };
 exports.UNIVERSAL_TRANSCRIPTION_DESCRIPTION = {