morpheus-cli 0.4.14 → 0.5.0

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,
     }
 };