morpheus-cli 0.5.0 → 0.5.2

package/dist/runtime/tools/neo-tool.js

@@ -4,31 +4,41 @@ import { TaskRepository } from "../tasks/repository.js";
 import { TaskRequestContext } from "../tasks/context.js";
 import { compositeDelegationError, isLikelyCompositeDelegationTask } from "./delegation-guard.js";
 import { DisplayManager } from "../display.js";
+const NEO_BUILTIN_CAPABILITIES = `
+Neo built-in capabilities (always available — no MCP required):
+• Config: morpheus_config_query, morpheus_config_update — read/write Morpheus configuration (LLM, channels, UI, etc.)
+• Diagnostics: diagnostic_check — full system health report (config, databases, LLM provider, logs)
+• Analytics: message_count, token_usage, provider_model_usage — message counts and token/cost usage stats
+• Tasks: task_query — look up task status by id or session
+• MCP Management: mcp_list, mcp_manage — list/add/update/delete/enable/disable MCP servers; use action "reload" to reload tools across all agents after config changes
+• Webhooks: webhook_list, webhook_manage — create/update/delete webhooks; create returns api_key
+• Trinity DB: trinity_db_list, trinity_db_manage — register/update/delete/test connection/refresh schema for databases`.trim();
 const NEO_BASE_DESCRIPTION = `Delegate execution to Neo asynchronously.
 
 This tool creates a background task and returns an acknowledgement with task id.
-Use it for requests that require tools of morpheus config / motpheus analystics / morpheus diagnostics and available MCPs,
-or external/stateful verification.
-Each delegated task must contain one atomic objective.`;
+Use it for any request that requires Neo's built-in capabilities or a runtime MCP tool listed below.
+Each delegated task must contain one atomic objective.
+
+${NEO_BUILTIN_CAPABILITIES}`;
 function normalizeDescription(text) {
     if (!text)
         return "No description";
     return text.replace(/\s+/g, " ").trim();
 }
-function buildCatalogSection(tools) {
-    if (tools.length === 0) {
-        return "\n\nNeo MCP tools catalog: no tools currently loaded.";
+function buildCatalogSection(mcpTools) {
+    if (mcpTools.length === 0) {
+        return "\n\nRuntime MCP tools: none currently loaded.";
     }
     const maxItems = 32;
-    const lines = tools.slice(0, maxItems).map((t) => {
+    const lines = mcpTools.slice(0, maxItems).map((t) => {
         const desc = normalizeDescription(t.description).slice(0, 120);
         return `- ${t.name}: ${desc}`;
     });
-    const hidden = tools.length - lines.length;
+    const hidden = mcpTools.length - lines.length;
     if (hidden > 0) {
         lines.push(`- ... and ${hidden} more tools`);
     }
-    return `\n\nNeo MCP tools catalog (runtime loaded):\n${lines.join("\n")}`;
+    return `\n\nRuntime MCP tools:\n${lines.join("\n")}`;
 }
 export function updateNeoDelegateToolDescription(tools) {
     const full = `${NEO_BASE_DESCRIPTION}${buildCatalogSection(tools)}`;

package/dist/runtime/tools/trinity-tool.js

@@ -0,0 +1,98 @@
+import { tool } from "@langchain/core/tools";
+import { z } from "zod";
+import { TaskRepository } from "../tasks/repository.js";
+import { TaskRequestContext } from "../tasks/context.js";
+import { compositeDelegationError, isLikelyCompositeDelegationTask } from "./delegation-guard.js";
+import { DisplayManager } from "../display.js";
+const TRINITY_BASE_DESCRIPTION = `Delegate a database task to Trinity, the specialized database subagent, asynchronously.
+
+This tool enqueues a background task and returns an acknowledgement with task id.
+Trinity interprets natural language database requests, generates the appropriate query, and returns results.
+
+Use this tool when the user asks for ANY of the following:
+- Querying data from a registered database (SELECT, find, aggregate)
+- Checking database status or schema
+- Running reports or analytics against a database
+- Listing tables, collections, or fields
+- Counting records or summarizing data`;
+function buildDatabaseCatalog(databases) {
+    if (databases.length === 0) {
+        return '\n\nNo databases currently registered. Register databases via /api/trinity/databases.';
+    }
+    const lines = databases.map((db) => {
+        const schema = db.schema_json ? JSON.parse(db.schema_json) : null;
+        const tables = schema?.tables?.map((t) => t.name).join(', ') || 'schema not loaded';
+        return `- [${db.id}] ${db.name} (${db.type}): ${tables}`;
+    });
+    return `\n\nRegistered databases:\n${lines.join('\n')}`;
+}
+export function updateTrinityDelegateToolDescription(databases) {
+    const full = `${TRINITY_BASE_DESCRIPTION}${buildDatabaseCatalog(databases)}`;
+    TrinityDelegateTool.description = full;
+}
+export const TrinityDelegateTool = tool(async ({ task, context }) => {
+    try {
+        const display = DisplayManager.getInstance();
+        if (isLikelyCompositeDelegationTask(task)) {
+            display.log(`Trinity delegation rejected (non-atomic task): ${task.slice(0, 140)}`, {
+                source: 'TrinityDelegateTool',
+                level: 'warning',
+            });
+            return compositeDelegationError();
+        }
+        const existingAck = TaskRequestContext.findDuplicateDelegation('trinit', task);
+        if (existingAck) {
+            display.log(`Trinity delegation deduplicated. Reusing task ${existingAck.task_id}.`, {
+                source: 'TrinityDelegateTool',
+                level: 'info',
+            });
+            return `Task ${existingAck.task_id} already queued for ${existingAck.agent} execution.`;
+        }
+        if (!TaskRequestContext.canEnqueueDelegation()) {
+            display.log(`Trinity delegation blocked by per-turn limit.`, {
+                source: 'TrinityDelegateTool',
+                level: 'warning',
+            });
+            return 'Delegation limit reached for this user turn. Split the request or wait for current tasks.';
+        }
+        const ctx = TaskRequestContext.get();
+        const repository = TaskRepository.getInstance();
+        const created = repository.createTask({
+            agent: 'trinit',
+            input: task,
+            context: context ?? null,
+            origin_channel: ctx?.origin_channel ?? 'api',
+            session_id: ctx?.session_id ?? 'default',
+            origin_message_id: ctx?.origin_message_id ?? null,
+            origin_user_id: ctx?.origin_user_id ?? null,
+            max_attempts: 3,
+        });
+        TaskRequestContext.setDelegationAck({ task_id: created.id, agent: 'trinit', task });
+        display.log(`Trinity task created: ${created.id}`, {
+            source: 'TrinityDelegateTool',
+            level: 'info',
+            meta: {
+                agent: created.agent,
+                origin_channel: created.origin_channel,
+                session_id: created.session_id,
+                input: created.input,
+            },
+        });
+        return `Task ${created.id} queued for Trinity execution.`;
+    }
+    catch (err) {
+        const display = DisplayManager.getInstance();
+        display.log(`TrinityDelegateTool error: ${err.message}`, {
+            source: 'TrinityDelegateTool',
+            level: 'error',
+        });
+        return `Trinity task enqueue failed: ${err.message}`;
+    }
+}, {
+    name: 'trinity_delegate',
+    description: TRINITY_BASE_DESCRIPTION,
+    schema: z.object({
+        task: z.string().describe('Clear description of the database task **in the user\'s language**'),
+        context: z.string().optional().describe('Optional context from the conversation to help Trinity understand the goal **in the user\'s language**'),
+    }),
+});