morpheus-cli 0.4.15 → 0.5.0

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

@@ -1,6 +1,9 @@
 import { tool } from "@langchain/core/tools";
 import { z } from "zod";
-import { Apoc } from "../apoc.js";
+import { TaskRepository } from "../tasks/repository.js";
+import { TaskRequestContext } from "../tasks/context.js";
+import { compositeDelegationError, isLikelyCompositeDelegationTask } from "./delegation-guard.js";
+import { DisplayManager } from "../display.js";
 /**
  * Tool that Oracle uses to delegate devtools tasks to Apoc.
  * Oracle should call this whenever the user requests operations like:
@@ -14,16 +17,66 @@ import { Apoc } from "../apoc.js";
  */
 export const ApocDelegateTool = tool(async ({ task, context }) => {
     try {
-        const apoc = Apoc.getInstance();
-        const result = await apoc.execute(task, context);
-        return result;
+        const display = DisplayManager.getInstance();
+        if (isLikelyCompositeDelegationTask(task)) {
+            display.log(`Apoc delegation rejected (non-atomic task): ${task.slice(0, 140)}`, {
+                source: "ApocDelegateTool",
+                level: "warning",
+            });
+            return compositeDelegationError();
+        }
+        const existingAck = TaskRequestContext.findDuplicateDelegation("apoc", task);
+        if (existingAck) {
+            display.log(`Apoc delegation deduplicated. Reusing task ${existingAck.task_id}.`, {
+                source: "ApocDelegateTool",
+                level: "info",
+            });
+            return `Task ${existingAck.task_id} already queued for ${existingAck.agent} execution.`;
+        }
+        if (!TaskRequestContext.canEnqueueDelegation()) {
+            display.log(`Apoc delegation blocked by per-turn limit.`, {
+                source: "ApocDelegateTool",
+                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: "apoc",
+            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: "apoc", task });
+        display.log(`Apoc task created: ${created.id}`, {
+            source: "ApocDelegateTool",
+            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 Apoc execution.`;
     }
     catch (err) {
-        return `Apoc execution failed: ${err.message}`;
+        const display = DisplayManager.getInstance();
+        display.log(`ApocDelegateTool error: ${err.message}`, { source: "ApocDelegateTool", level: "error" });
+        return `Apoc task enqueue failed: ${err.message}`;
     }
 }, {
     name: "apoc_delegate",
-    description: `Delegate a devtools task to Apoc, the specialized development subagent.
+    description: `Delegate a devtools task to Apoc, the specialized development subagent, asynchronously.
+
+This tool enqueues a background task and returns an acknowledgement with task id.
+Do not expect final execution output in the same response.
+Each task must contain a single atomic action with a clear expected result.
 
 Use this tool when the user asks for ANY of the following:
 - File operations: read, write, create, delete files or directories
@@ -39,7 +92,7 @@ Use this tool when the user asks for ANY of the following:
 Provide a clear natural language task description. Optionally provide context
 from the current conversation to help Apoc understand the broader goal.`,
     schema: z.object({
-        task: z.string().describe("Clear description of the devtools task to execute"),
-        context: z.string().optional().describe("Optional context from the conversation to help Apoc understand the goal"),
+        task: z.string().describe("Clear description of the devtools task to execute **in the user's language**"),
+        context: z.string().optional().describe("Optional context from the conversation to help Apoc understand the goal **in the user's language**"),
     }),
 });

package/dist/runtime/tools/delegation-guard.js

@@ -0,0 +1,29 @@
+function normalize(text) {
+    return text
+        .toLowerCase()
+        .replace(/\s+/g, " ")
+        .trim();
+}
+/**
+ * Heuristic guard to reject clearly multi-action delegations.
+ * Allows phrases like "do X and return/report Y".
+ */
+export function isLikelyCompositeDelegationTask(task) {
+    const t = normalize(task);
+    if (!t)
+        return false;
+    if (/[;\n]/.test(t))
+        return true;
+    const conjunction = /\b(and|then|also|e|depois|tambem|também|alem disso|além disso)\b/;
+    if (!conjunction.test(t))
+        return false;
+    // "and return/report" is usually part of a single atomic objective.
+    const allowedSecondStep = /\b(and|then|e|depois)\s+(return|report|summarize|retorne|informe|resuma|mostre|show)\b/;
+    if (allowedSecondStep.test(t))
+        return false;
+    const actionVerbAfterConjunction = /\b(and|then|also|e|depois|tambem|também)\s+(check|ping|run|execute|search|fetch|get|list|create|update|delete|open|verify|consult|verificar|fazer|executar|buscar|obter|listar|criar|atualizar|deletar|abrir)\b/;
+    return actionVerbAfterConjunction.test(t);
+}
+export function compositeDelegationError() {
+    return "Delegation rejected: task must be atomic (single action). Split this request into multiple delegations, one task per action/tool.";
+}

package/dist/runtime/tools/index.js

@@ -3,3 +3,4 @@ export * from './config-tools.js';
 export * from './diagnostic-tools.js';
 export * from './analytics-tools.js';
 export * from './apoc-tool.js';
+export * from './neo-tool.js';

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

@@ -0,0 +1,99 @@
+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 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.`;
+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.";
+    }
+    const maxItems = 32;
+    const lines = tools.slice(0, maxItems).map((t) => {
+        const desc = normalizeDescription(t.description).slice(0, 120);
+        return `- ${t.name}: ${desc}`;
+    });
+    const hidden = tools.length - lines.length;
+    if (hidden > 0) {
+        lines.push(`- ... and ${hidden} more tools`);
+    }
+    return `\n\nNeo MCP tools catalog (runtime loaded):\n${lines.join("\n")}`;
+}
+export function updateNeoDelegateToolDescription(tools) {
+    const full = `${NEO_BASE_DESCRIPTION}${buildCatalogSection(tools)}`;
+    NeoDelegateTool.description = full;
+}
+export const NeoDelegateTool = tool(async ({ task, context }) => {
+    try {
+        const display = DisplayManager.getInstance();
+        if (isLikelyCompositeDelegationTask(task)) {
+            display.log(`Neo delegation rejected (non-atomic task): ${task.slice(0, 140)}`, {
+                source: "NeoDelegateTool",
+                level: "warning",
+            });
+            return compositeDelegationError();
+        }
+        const existingAck = TaskRequestContext.findDuplicateDelegation("neo", task);
+        if (existingAck) {
+            display.log(`Neo delegation deduplicated. Reusing task ${existingAck.task_id}.`, {
+                source: "NeoDelegateTool",
+                level: "info",
+            });
+            return `Task ${existingAck.task_id} already queued for ${existingAck.agent} execution.`;
+        }
+        if (!TaskRequestContext.canEnqueueDelegation()) {
+            display.log(`Neo delegation blocked by per-turn limit.`, {
+                source: "NeoDelegateTool",
+                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: "neo",
+            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: "neo", task });
+        display.log(`Neo task created: ${created.id}`, {
+            source: "NeoDelegateTool",
+            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 Neo execution.`;
+    }
+    catch (err) {
+        const display = DisplayManager.getInstance();
+        display.log(`NeoDelegateTool error: ${err.message}`, { source: "NeoDelegateTool", level: "error" });
+        return `Neo task enqueue failed: ${err.message}`;
+    }
+}, {
+    name: "neo_delegate",
+    description: NEO_BASE_DESCRIPTION,
+    schema: z.object({
+        task: z.string().describe("Clear task objective for Neo to execute **in the user's language**"),
+        context: z.string().optional().describe("Optional context from conversation **in the user's language**"),
+    }),
+});

package/dist/runtime/tools/task-query-tool.js

@@ -0,0 +1,76 @@
+import { tool } from "@langchain/core/tools";
+import { z } from "zod";
+import { TaskRepository } from "../tasks/repository.js";
+import { TaskRequestContext } from "../tasks/context.js";
+function toTaskView(task) {
+    return {
+        id: task.id,
+        agent: task.agent,
+        status: task.status,
+        input: task.input,
+        output: task.output,
+        error: task.error,
+        session_id: task.session_id,
+        origin_channel: task.origin_channel,
+        created_at: task.created_at,
+        started_at: task.started_at,
+        finished_at: task.finished_at,
+        updated_at: task.updated_at,
+    };
+}
+export const TaskQueryTool = tool(async ({ task_id, limit, session_id, include_completed }) => {
+    try {
+        const repository = TaskRepository.getInstance();
+        if (task_id) {
+            const task = repository.getTaskById(task_id);
+            if (!task) {
+                return JSON.stringify({
+                    found: false,
+                    query: { task_id },
+                    message: "Task not found",
+                });
+            }
+            return JSON.stringify({
+                found: true,
+                query: { task_id },
+                task: toTaskView(task),
+            });
+        }
+        const ctx = TaskRequestContext.get();
+        const targetSessionId = session_id ?? ctx?.session_id;
+        const requestedLimit = Math.max(1, Math.min(50, limit ?? 10));
+        const baseLimit = Math.max(requestedLimit * 5, 50);
+        const tasks = repository.listTasks({
+            session_id: targetSessionId,
+            limit: baseLimit,
+        });
+        const filtered = tasks.filter((task) => include_completed ? true : task.status !== "completed");
+        const latest = filtered.slice(0, requestedLimit);
+        return JSON.stringify({
+            found: latest.length > 0,
+            query: {
+                task_id: null,
+                limit: requestedLimit,
+                session_id: targetSessionId ?? null,
+                include_completed: include_completed ?? false,
+            },
+            count: latest.length,
+            tasks: latest.map(toTaskView),
+        });
+    }
+    catch (error) {
+        return JSON.stringify({
+            found: false,
+            error: error?.message ?? String(error),
+        });
+    }
+}, {
+    name: "task_query",
+    description: "Query task status directly from database without delegation. Supports lookup by task id, or latest tasks (default: only non-completed) for current session.",
+    schema: z.object({
+        task_id: z.string().uuid().optional().describe("Specific task id to fetch"),
+        limit: z.number().int().min(1).max(50).optional().describe("Max number of tasks to return when task_id is not provided (default: 10)"),
+        session_id: z.string().optional().describe("Optional session id filter; if omitted, uses current request session"),
+        include_completed: z.boolean().optional().describe("Include completed tasks when listing latest tasks (default: false)"),
+    }),
+});

package/dist/runtime/webhooks/dispatcher.js

@@ -21,9 +21,8 @@ export class WebhookDispatcher {
     /**
      * Main orchestration method — runs in background (fire-and-forget).
      * 1. Builds the agent prompt from webhook.prompt + payload
-     * 2. Sends to Oracle (which can use MCPs or delegate to Apoc)
-     * 3. Persists result to DB
-     * 4. Dispatches to configured channels
+     * 2. Sends to Oracle for async task enqueue
+     * 3. Final result is persisted by TaskNotifier through TaskDispatcher
      */
     async dispatch(webhook, payload, notificationId) {
         const repo = WebhookRepository.getInstance();
@@ -35,26 +34,18 @@ export class WebhookDispatcher {
             return;
         }
         const message = this.buildPrompt(webhook.prompt, payload);
-        let result;
-        let status;
         try {
-            result = await oracle.chat(message);
-            status = 'completed';
-            this.display.log(`Webhook "${webhook.name}" completed (notification: ${notificationId})`, { source: 'Webhooks', level: 'success' });
+            await oracle.chat(message, undefined, false, {
+                origin_channel: 'webhook',
+                session_id: `webhook-${webhook.id}`,
+                origin_message_id: notificationId,
+            });
+            this.display.log(`Webhook "${webhook.name}" accepted and queued (notification: ${notificationId})`, { source: 'Webhooks', level: 'success' });
         }
         catch (err) {
-            result = `Execution error: ${err.message}`;
-            status = 'failed';
+            const result = `Execution error: ${err.message}`;
             this.display.log(`Webhook "${webhook.name}" failed: ${err.message}`, { source: 'Webhooks', level: 'error' });
-        }
-        // Persist result
-        repo.updateNotificationResult(notificationId, status, result);
-        // Dispatch to configured channels
-        for (const channel of webhook.notification_channels) {
-            if (channel === 'telegram') {
-                await this.sendTelegram(webhook.name, result, status);
-            }
-            // 'ui' channel is handled by UI polling — nothing extra needed here
+            repo.updateNotificationResult(notificationId, 'failed', result);
         }
     }
     /**

package/dist/types/config.js

@@ -18,6 +18,11 @@ export const DEFAULT_CONFIG = {
     memory: {
         limit: 100
     },
+    runtime: {
+        async_tasks: {
+            enabled: true,
+        },
+    },
     llm: {
         provider: 'openai',
         model: 'gpt-4',
@@ -45,5 +50,10 @@ export const DEFAULT_CONFIG = {
         model: 'gpt-4',
         temperature: 0.2,
         timeout_ms: 30000,
+    },
+    neo: {
+        provider: 'openai',
+        model: 'gpt-4',
+        temperature: 0.2,
     }
 };