secondbrainos-mcp-server 1.1.0 → 1.2.0

package/build/index.js

@@ -30,19 +30,24 @@ class SecondBrainOSServer {
                 this.functionMap.set(operation.operationId, func);
             }
         });
-        // Initialize workflow name-to-ID map
+        // Initialize maps and cache
         this.workflowNameToId = new Map();
-        // Discover runPromptChain path from the OpenAPI schema
+        this.agentNameToId = new Map();
+        this.cachedAgents = null;
+        // Discover service paths from the OpenAPI schema
         this.runPromptChainPath = null;
+        this.getAIAgentsSchemaPath = null;
         if (initialSchema.paths) {
             for (const [path, pathItem] of Object.entries(initialSchema.paths)) {
                 for (const operation of Object.values(pathItem)) {
                     if (operation.operationId === 'runPromptChain') {
                         this.runPromptChainPath = path;
-                        break;
+                    }
+                    if (operation.operationId === 'getAIAgentsSchema') {
+                        this.getAIAgentsSchemaPath = path;
                     }
                 }
-                if (this.runPromptChainPath)
+                if (this.runPromptChainPath && this.getAIAgentsSchemaPath)
                     break;
             }
         }
@@ -181,66 +186,112 @@ class SecondBrainOSServer {
                 throw error;
             }
         });
-        // List available prompts (user's workflows)
+        // List available prompts (user's workflows + agents)
         this.server.setRequestHandler(ListPromptsRequestSchema, async () => {
-            if (!this.runPromptChainPath) {
-                return { prompts: [] };
-            }
-            try {
-                const data = await this.callRunPromptChain('', '');
-                const workflows = data.workflows || [];
-                // Populate name-to-ID map
-                this.workflowNameToId.clear();
-                for (const wf of workflows) {
-                    if (wf.name && wf.workflow_id) {
-                        this.workflowNameToId.set(wf.name, wf.workflow_id);
+            const prompts = [];
+            // Fetch workflows as prompts
+            if (this.runPromptChainPath) {
+                try {
+                    const data = await this.callRunPromptChain('', '');
+                    const workflows = data.workflows || [];
+                    this.workflowNameToId.clear();
+                    for (const wf of workflows) {
+                        if (wf.name && wf.workflow_id) {
+                            this.workflowNameToId.set(wf.name, wf.workflow_id);
+                        }
+                    }
+                    for (const wf of workflows) {
+                        prompts.push({
+                            name: wf.name || wf.workflow_id,
+                            description: wf.description || wf.name,
+                            arguments: [
+                                {
+                                    name: "user_input",
+                                    description: "Optional context or input to guide the workflow execution",
+                                    required: false
+                                }
+                            ]
+                        });
                     }
                 }
-                return {
-                    prompts: workflows.map((wf) => ({
-                        name: wf.name || wf.workflow_id,
-                        description: wf.description || wf.name,
-                        arguments: [
-                            {
-                                name: "user_input",
-                                description: "Optional context or input to guide the workflow execution",
-                                required: false
-                            }
-                        ]
-                    }))
-                };
+                catch (error) {
+                    console.error('Failed to fetch workflows for prompts/list:', error);
+                }
             }
-            catch (error) {
-                console.error('Failed to fetch workflows for prompts/list:', error);
-                return { prompts: [] };
+            // Fetch agents as prompts
+            if (this.getAIAgentsSchemaPath) {
+                try {
+                    const agents = await this.fetchAndEnrichAgents();
+                    this.agentNameToId.clear();
+                    for (const agent of agents) {
+                        if (agent.name && agent.id) {
+                            const agentPromptName = `[Agent] ${agent.name}`;
+                            this.agentNameToId.set(agentPromptName, agent.id);
+                            prompts.push({
+                                name: agentPromptName,
+                                description: agent.description || agent.name,
+                                arguments: [
+                                    {
+                                        name: "user_input",
+                                        description: "Optional context or input to guide the agent",
+                                        required: false
+                                    }
+                                ]
+                            });
+                        }
+                    }
+                }
+                catch (error) {
+                    console.error('Failed to fetch agents for prompts/list:', error);
+                }
             }
+            return { prompts };
         });
-        // Get a specific prompt (workflow's prompt chain)
+        // Get a specific prompt (workflow prompt chain or agent document)
         this.server.setRequestHandler(GetPromptRequestSchema, async (request) => {
             const promptName = request.params.name;
-            const workflowId = this.workflowNameToId.get(promptName) || promptName;
             const userInput = request.params.arguments?.user_input;
-            // Fetch workflow details to get prompt IDs
-            const workflowData = await this.callRunPromptChain('workflow', workflowId);
-            const promptIds = workflowData.prompt_id || [];
+            // Check if this is an agent prompt
+            const agentId = this.agentNameToId.get(promptName);
+            if (agentId) {
+                return this.buildAgentPrompt(agentId, userInput);
+            }
+            // Otherwise treat as a workflow prompt
+            const workflowId = this.workflowNameToId.get(promptName) || promptName;
+            // Fetch workflow metadata from the workflows list
+            const workflowsData = await this.callRunPromptChain('', '');
+            const workflowMeta = (workflowsData.workflows || []).find((wf) => wf.workflow_id === workflowId);
+            const workflowDetail = await this.callRunPromptChain('workflow', workflowId);
+            const promptIds = workflowDetail.prompt_id || [];
             if (promptIds.length === 0) {
                 throw new McpError(ErrorCode.InvalidRequest, `No prompts found for workflow: ${workflowId}`);
             }
-            // Fetch each prompt's instructions
-            const promptResults = await Promise.all(promptIds.map((promptId) => this.callRunPromptChain('prompt', promptId)));
-            // Sort by order and build messages
+            // Fetch prompt metadata (no instructions)
+            const promptResults = await Promise.all(promptIds.map(async (promptId) => {
+                const promptData = await this.callRunPromptChain('prompt', promptId);
+                return {
+                    id: promptId,
+                    name: promptData.name,
+                    order: promptData.order,
+                    description: promptData.description || ''
+                };
+            }));
             const sortedPrompts = promptResults.sort((a, b) => (a.order || 0) - (b.order || 0));
-            const messages = [];
-            for (const prompt of sortedPrompts) {
-                messages.push({
+            const workflowDocument = {
+                workflow_id: workflowId,
+                name: workflowMeta?.name || promptName,
+                description: workflowMeta?.description || '',
+                prompts: sortedPrompts
+            };
+            const messages = [
+                {
                     role: "user",
                     content: {
                         type: "text",
-                        text: prompt.instructions
+                        text: JSON.stringify(workflowDocument, null, 2)
                     }
-                });
-            }
-            // If user provided input, append it as the final message
+                }
+            ];
             if (userInput) {
                 messages.push({
                     role: "user",
@@ -251,11 +302,58 @@ class SecondBrainOSServer {
                 });
             }
             return {
-                description: `Workflow prompt chain (${sortedPrompts.length} steps)`,
+                description: `Workflow: ${workflowDocument.name} (${sortedPrompts.length} prompts)`,
                 messages
             };
         });
     }
+    async buildAgentPrompt(agentId, userInput) {
+        const agents = await this.fetchAndEnrichAgents();
+        const agent = agents.find((a) => a.id === agentId);
+        if (!agent) {
+            throw new McpError(ErrorCode.InvalidRequest, `Agent not found: ${agentId}`);
+        }
+        // Build the agent document as a structured JSON object
+        const agentDocument = {
+            name: agent.name,
+            description: agent.description || '',
+            behaviour_and_instructions: agent.behaviour_and_instructions || '',
+            actions: agent.actions || [],
+            workflows: (agent.workflows || []).map((wf) => ({
+                id: wf.id,
+                name: wf.name,
+                prompts: (wf.prompts || []).map((p) => ({
+                    id: p.id,
+                    name: p.name,
+                    order: p.order,
+                    description: p.description
+                }))
+            }))
+        };
+        const messages = [
+            {
+                role: "user",
+                content: {
+                    type: "text",
+                    text: JSON.stringify(agentDocument, null, 2)
+                }
+            }
+        ];
+        if (userInput) {
+            messages.push({
+                role: "user",
+                content: {
+                    type: "text",
+                    text: userInput
+                }
+            });
+        }
+        const skillCount = agentDocument.workflows.length;
+        return {
+            description: `Agent: ${agent.name} (${skillCount} skill${skillCount !== 1 ? 's' : ''})`,
+            messages
+        };
+    }
     async callRunPromptChain(entity, entityId) {
         if (!this.runPromptChainPath) {
             throw new McpError(ErrorCode.InternalError, 'runPromptChain service not available for this user');
@@ -272,6 +370,54 @@ class SecondBrainOSServer {
         });
         return response.data;
     }
+    async callGetAIAgentsSchema() {
+        if (!this.getAIAgentsSchemaPath) {
+            throw new McpError(ErrorCode.InternalError, 'getAIAgentsSchema service not available for this user');
+        }
+        const url = `${this.baseUrl}${this.getAIAgentsSchemaPath}`;
+        const response = await axios.post(url, {
+            include_sensitive_config: true
+        }, {
+            headers: {
+                'Authorization': `Bearer ${this.userId}:${this.userSecret}`,
+                'Content-Type': 'application/json'
+            }
+        });
+        return response.data;
+    }
+    async fetchAndEnrichAgents() {
+        if (this.cachedAgents)
+            return this.cachedAgents;
+        const data = await this.callGetAIAgentsSchema();
+        const agents = data.agents || [];
+        // Enrich each agent's workflows with full prompt details
+        for (const agent of agents) {
+            if (!agent.workflows)
+                continue;
+            for (const workflow of agent.workflows) {
+                if (!workflow.prompts || workflow.prompts.length === 0)
+                    continue;
+                // Fetch prompt metadata (name, order, description) — no instructions
+                const enrichedPrompts = await Promise.all(workflow.prompts.map(async (prompt) => {
+                    try {
+                        const promptData = await this.callRunPromptChain('prompt', prompt.id);
+                        return {
+                            id: prompt.id,
+                            name: promptData.name || prompt.name,
+                            order: promptData.order,
+                            description: promptData.description || ''
+                        };
+                    }
+                    catch {
+                        return { id: prompt.id, name: prompt.name, order: 0, description: '' };
+                    }
+                }));
+                workflow.prompts = enrichedPrompts.sort((a, b) => (a.order || 0) - (b.order || 0));
+            }
+        }
+        this.cachedAgents = agents;
+        return agents;
+    }
     setupErrorHandling() {
         // Error handling is now built into HttpLlm.execute
         // This method is kept for future error handling implementations

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "secondbrainos-mcp-server",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Second Brain OS MCP Server for Claude Desktop",
   "type": "module",
   "main": "build/index.js",