morpheus-cli 0.7.4 → 0.7.6

package/dist/runtime/apoc.js

@@ -42,17 +42,23 @@ export class Apoc {
     async initialize() {
         const apocConfig = this.config.apoc || this.config.llm;
         // console.log(`Apoc configuration: ${JSON.stringify(apocConfig)}`);
-        const working_dir = this.config.apoc?.working_dir || process.cwd();
-        const timeout_ms = this.config.apoc?.timeout_ms || 30_000;
+        const devkit = ConfigManager.getInstance().getDevKitConfig();
+        const timeout_ms = devkit.timeout_ms || this.config.apoc?.timeout_ms || 30_000;
         const personality = this.config.apoc?.personality || 'pragmatic_dev';
         // Import all devkit tool factories (side-effect registration)
         await import("../devkit/index.js");
         const tools = buildDevKit({
-            working_dir,
-            allowed_commands: [], // no restriction — Oracle is trusted orchestrator
+            working_dir: devkit.sandbox_dir || process.cwd(),
+            allowed_commands: devkit.allowed_shell_commands || [],
             timeout_ms,
+            sandbox_dir: devkit.sandbox_dir,
+            readonly_mode: devkit.readonly_mode,
+            enable_filesystem: devkit.enable_filesystem,
+            enable_shell: devkit.enable_shell,
+            enable_git: devkit.enable_git,
+            enable_network: devkit.enable_network,
         });
-        this.display.log(`Apoc initialized with ${tools.length} DevKit tools (working_dir: ${working_dir}, personality: ${personality})`, { source: "Apoc" });
+        this.display.log(`Apoc initialized with ${tools.length} DevKit tools (sandbox_dir: ${devkit.sandbox_dir}, personality: ${personality})`, { source: "Apoc" });
         try {
             this.agent = await ProviderFactory.createBare(apocConfig, tools);
         }

package/dist/runtime/hot-reload.js

@@ -0,0 +1,96 @@
+/**
+ * Hot-reload module for Morpheus configuration changes.
+ *
+ * This module allows config changes to take effect without restarting the daemon.
+ * It reinitializes agents that have already been initialized, and resets lazy-loaded
+ * singletons so they pick up new config on next use.
+ */
+import { ConfigManager } from '../config/manager.js';
+import { DisplayManager } from './display.js';
+import { Apoc } from './apoc.js';
+import { Neo } from './neo.js';
+import { Trinity } from './trinity.js';
+let currentOracle = null;
+/**
+ * Register the current Oracle instance for hot-reload.
+ * Called from start.ts after Oracle initialization.
+ */
+export function registerOracleForHotReload(oracle) {
+    currentOracle = oracle;
+}
+/**
+ * Hot-reload configuration changes.
+ *
+ * This function:
+ * 1. Reloads config from disk (zaion.yaml)
+ * 2. Reinitializes Oracle with new config
+ * 3. Resets subagent singletons (they reinitialize lazily on next use)
+ *
+ * Note: Some changes still require full restart:
+ * - Channel tokens (Telegram, Discord)
+ * - UI port changes
+ * - Chronos check_interval_ms
+ */
+export async function hotReloadConfig() {
+    const display = DisplayManager.getInstance();
+    const reinitialized = [];
+    try {
+        // 1. Reload configuration from disk
+        await ConfigManager.getInstance().load();
+        display.log('Configuration reloaded from disk', { source: 'HotReload', level: 'info' });
+        // 2. Reinitialize Oracle if it exists
+        if (currentOracle && typeof currentOracle.reinitialize === 'function') {
+            await currentOracle.reinitialize();
+            reinitialized.push('Oracle');
+            display.log('Oracle reinitialized with new config', { source: 'HotReload', level: 'info' });
+        }
+        // 3. Reset subagent singletons - they will reinitialize with new config on next use
+        Apoc.resetInstance();
+        Neo.resetInstance();
+        Trinity.resetInstance();
+        reinitialized.push('Apoc', 'Neo', 'Trinity');
+        display.log('Subagent singletons reset (will reinitialize on next use)', { source: 'HotReload', level: 'info' });
+        return {
+            success: true,
+            reinitialized,
+            message: `Hot-reload complete. Reinitialized: ${reinitialized.join(', ')}`
+        };
+    }
+    catch (error) {
+        display.log(`Hot-reload failed: ${error.message}`, { source: 'HotReload', level: 'error' });
+        return {
+            success: false,
+            reinitialized,
+            message: `Hot-reload failed: ${error.message}`
+        };
+    }
+}
+/**
+ * Check which config changes require a full restart vs hot-reload.
+ */
+export function getRestartRequiredChanges(oldConfig, newConfig) {
+    const restartRequired = [];
+    // Channel token changes require restart
+    if (oldConfig.channels?.telegram?.token !== newConfig.channels?.telegram?.token) {
+        restartRequired.push('Telegram token');
+    }
+    if (oldConfig.channels?.discord?.token !== newConfig.channels?.discord?.token) {
+        restartRequired.push('Discord token');
+    }
+    // Channel enabled state changes require restart
+    if (oldConfig.channels?.telegram?.enabled !== newConfig.channels?.telegram?.enabled) {
+        restartRequired.push('Telegram enabled state');
+    }
+    if (oldConfig.channels?.discord?.enabled !== newConfig.channels?.discord?.enabled) {
+        restartRequired.push('Discord enabled state');
+    }
+    // UI port changes require restart
+    if (oldConfig.ui?.port !== newConfig.ui?.port) {
+        restartRequired.push('UI port');
+    }
+    // Chronos interval requires restart (it's read once in constructor)
+    if (oldConfig.chronos?.check_interval_ms !== newConfig.chronos?.check_interval_ms) {
+        restartRequired.push('Chronos check interval');
+    }
+    return restartRequired;
+}

package/dist/runtime/keymaker.js

@@ -34,13 +34,19 @@ export class Keymaker {
         const keymakerConfig = this.config.keymaker || this.config.llm;
         const personality = this.config.keymaker?.personality || 'versatile_specialist';
         // Build DevKit tools (filesystem, shell, git, browser, network, etc.)
-        const working_dir = process.cwd();
-        const timeout_ms = 30_000;
+        const devkit = ConfigManager.getInstance().getDevKitConfig();
+        const timeout_ms = devkit.timeout_ms || 30_000;
         await import("../devkit/index.js");
         const devKitTools = buildDevKit({
-            working_dir,
-            allowed_commands: [], // no restriction
+            working_dir: devkit.sandbox_dir || process.cwd(),
+            allowed_commands: devkit.allowed_shell_commands || [],
             timeout_ms,
+            sandbox_dir: devkit.sandbox_dir,
+            readonly_mode: devkit.readonly_mode,
+            enable_filesystem: devkit.enable_filesystem,
+            enable_shell: devkit.enable_shell,
+            enable_git: devkit.enable_git,
+            enable_network: devkit.enable_network,
         });
         // Load MCP tools from configured servers
         const mcpTools = await Construtor.create();

package/dist/runtime/oracle.js

@@ -14,6 +14,7 @@ import { NeoDelegateTool } from "./tools/neo-tool.js";
 import { ApocDelegateTool } from "./tools/apoc-tool.js";
 import { TrinityDelegateTool } from "./tools/trinity-tool.js";
 import { TaskQueryTool, chronosTools, timeVerifierTool } from "./tools/index.js";
+import { Construtor } from "./tools/factory.js";
 import { MCPManager } from "../config/mcp-manager.js";
 import { SkillRegistry, SkillExecuteTool, SkillDelegateTool, updateSkillToolDescriptions } from "./skills/index.js";
 export class Oracle {
@@ -167,6 +168,17 @@ export class Oracle {
             throw new ProviderError(this.config.llm.provider || 'unknown', err, "Oracle initialization failed");
         }
     }
+    /**
+     * Reinitialize Oracle with fresh configuration.
+     * Used for hot-reloading config changes without daemon restart.
+     */
+    async reinitialize() {
+        // Reload config from ConfigManager
+        this.config = ConfigManager.getInstance().get();
+        // Reinitialize the provider with new config
+        await this.initialize();
+        this.display.log('Oracle reinitialized with updated configuration', { source: 'Oracle', level: 'info' });
+    }
     async chat(message, extraUsage, isTelephonist, taskContext) {
         if (!this.provider) {
             throw new Error("Oracle not initialized. Call initialize() first.");
@@ -213,6 +225,7 @@ Rules:
 9. Avoid duplicate delegations to the same tool or agent.
 10. After enqueuing all required delegated tasks for the current message, stop calling tools and return a concise acknowledgement.
 11. If a delegation is rejected as "not atomic", immediately split into smaller delegations and retry.
+12. When the user message contains @neo, @apoc, or @trinity (case-insensitive), delegate to that specific agent. The mention is an explicit routing directive — respect it even if another agent might also handle the request.
 
 ## Chronos Channel Routing
 When calling chronos_schedule, set notify_channels based on the user's message:
@@ -546,10 +559,12 @@ Use it to inform your response and tool selection (if needed), but do not assume
         if (!this.provider) {
             throw new Error("Oracle not initialized. Call initialize() first.");
         }
+        // Reload MCP tool cache from servers (slow path)
+        await Construtor.reload();
         await Neo.refreshDelegateCatalog().catch(() => { });
         await Trinity.refreshDelegateCatalog().catch(() => { });
         updateSkillToolDescriptions();
-        this.provider = await ProviderFactory.create(this.config.llm, [TaskQueryTool, NeoDelegateTool, ApocDelegateTool, TrinityDelegateTool, SkillExecuteTool, SkillDelegateTool, ...chronosTools]);
+        this.provider = await ProviderFactory.create(this.config.llm, [TaskQueryTool, NeoDelegateTool, ApocDelegateTool, TrinityDelegateTool, SkillExecuteTool, SkillDelegateTool, timeVerifierTool, ...chronosTools]);
         await Neo.getInstance().reload();
         this.display.log(`Oracle and Neo tools reloaded`, { source: 'Oracle' });
     }

package/dist/runtime/providers/factory.js

@@ -6,6 +6,11 @@ import { ProviderError } from "../errors.js";
 import { createAgent, createMiddleware } from "langchain";
 import { DisplayManager } from "../display.js";
 import { getUsableApiKey } from "../trinity-crypto.js";
+import { ConfigManager } from "../../config/manager.js";
+import { TaskRequestContext } from "../tasks/context.js";
+import { ChannelRegistry } from "../../channels/registry.js";
+/** Channels that should NOT receive verbose tool notifications */
+const SILENT_CHANNELS = new Set(['api', 'ui']);
 export class ProviderFactory {
     static buildMonitoringMiddleware() {
         const display = DisplayManager.getInstance();
@@ -14,6 +19,15 @@ export class ProviderFactory {
             wrapToolCall: (request, handler) => {
                 display.log(`Executing tool: ${request.toolCall.name}`, { level: "warning", source: 'ConstructLoad' });
                 display.log(`Arguments: ${JSON.stringify(request.toolCall.args)}`, { level: "info", source: 'ConstructLoad' });
+                // Verbose mode: notify originating channel about which tool is running
+                const verboseEnabled = ConfigManager.getInstance().get().verbose_mode !== false;
+                if (verboseEnabled) {
+                    const ctx = TaskRequestContext.get();
+                    if (ctx?.origin_channel && ctx.origin_user_id && !SILENT_CHANNELS.has(ctx.origin_channel)) {
+                        ChannelRegistry.sendToUser(ctx.origin_channel, ctx.origin_user_id, `🔧 executing: ${request.toolCall.name}`)
+                            .catch(() => { });
+                    }
+                }
                 try {
                     const result = handler(request);
                     display.log(`Tool completed successfully. Result: ${JSON.stringify(result)}`, { level: "info", source: 'ConstructLoad' });

package/dist/runtime/tools/__tests__/construtor.test.js

@@ -1,9 +1,22 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { Construtor } from '../factory.js';
-import { MultiServerMCPClient } from "@langchain/mcp-adapters";
-vi.mock("@langchain/mcp-adapters", () => {
+import { MCPToolCache } from '../cache.js';
+vi.mock("../cache.js", () => {
+    const mockCache = {
+        ensureLoaded: vi.fn().mockResolvedValue(undefined),
+        getTools: vi.fn().mockReturnValue([{ name: 'tool1' }, { name: 'tool2' }]),
+        getStats: vi.fn().mockReturnValue({
+            totalTools: 2,
+            servers: [{ name: 'server1', toolCount: 2, ok: true }],
+            lastLoadedAt: new Date(),
+            isLoading: false,
+        }),
+        reload: vi.fn().mockResolvedValue(undefined),
+    };
     return {
-        MultiServerMCPClient: vi.fn(),
+        MCPToolCache: {
+            getInstance: () => mockCache,
+        },
     };
 });
 vi.mock("../../display.js", () => ({
@@ -15,28 +28,32 @@ vi.mock("../../display.js", () => ({
 }));
 describe('Construtor', () => {
     beforeEach(() => {
-        vi.resetAllMocks();
+        vi.clearAllMocks();
     });
-    it('should create tools successfully', async () => {
-        const mockGetTools = vi.fn().mockResolvedValue(['tool1', 'tool2']);
-        // Mock the constructor and getTools method
-        MultiServerMCPClient.mockImplementation(function () {
-            return {
-                getTools: mockGetTools
-            };
-        });
+    it('should create tools from cache successfully', async () => {
         const tools = await Construtor.create();
-        expect(MultiServerMCPClient).toHaveBeenCalled();
-        expect(mockGetTools).toHaveBeenCalled();
-        expect(tools).toEqual(['tool1', 'tool2']);
+        const cache = MCPToolCache.getInstance();
+        expect(cache.ensureLoaded).toHaveBeenCalled();
+        expect(cache.getTools).toHaveBeenCalled();
+        expect(tools).toHaveLength(2);
     });
-    it('should return empty array on failure', async () => {
-        MultiServerMCPClient.mockImplementation(function () {
-            return {
-                getTools: vi.fn().mockRejectedValue(new Error('MCP Failed'))
-            };
-        });
-        const tools = await Construtor.create();
-        expect(tools).toEqual([]);
+    it('should probe servers from cache stats', async () => {
+        const results = await Construtor.probe();
+        const cache = MCPToolCache.getInstance();
+        expect(cache.ensureLoaded).toHaveBeenCalled();
+        expect(results).toHaveLength(1);
+        expect(results[0].name).toBe('server1');
+        expect(results[0].toolCount).toBe(2);
+        expect(results[0].ok).toBe(true);
+    });
+    it('should reload cache when reload is called', async () => {
+        await Construtor.reload();
+        const cache = MCPToolCache.getInstance();
+        expect(cache.reload).toHaveBeenCalled();
+    });
+    it('should return cache stats', () => {
+        const stats = Construtor.getStats();
+        expect(stats.totalTools).toBe(2);
+        expect(stats.servers).toHaveLength(1);
     });
 });

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

@@ -6,6 +6,7 @@ import { compositeDelegationError, isLikelyCompositeDelegationTask } from "./del
 import { DisplayManager } from "../display.js";
 import { ConfigManager } from "../../config/manager.js";
 import { Apoc } from "../apoc.js";
+import { ChannelRegistry } from "../../channels/registry.js";
 /**
  * Returns true when Apoc is configured to execute synchronously (inline).
  */
@@ -42,6 +43,11 @@ export const ApocDelegateTool = tool(async ({ task, context }) => {
             });
             const ctx = TaskRequestContext.get();
             const sessionId = ctx?.session_id ?? "default";
+            // Notify originating channel that the agent is working
+            if (ctx?.origin_channel && ctx.origin_user_id && ctx.origin_channel !== 'api' && ctx.origin_channel !== 'ui') {
+                ChannelRegistry.sendToUser(ctx.origin_channel, ctx.origin_user_id, '🧑‍🔬 Apoc is executing your request...')
+                    .catch(() => { });
+            }
             const apoc = Apoc.getInstance();
             const result = await apoc.execute(task, context, sessionId);
             TaskRequestContext.incrementSyncDelegation();

package/dist/runtime/tools/cache.js

@@ -0,0 +1,227 @@
+import { MultiServerMCPClient } from "@langchain/mcp-adapters";
+import { loadMCPConfig } from "../../config/mcp-loader.js";
+import { DisplayManager } from "../display.js";
+const display = DisplayManager.getInstance();
+/** Fields not supported by Google Gemini API */
+const UNSUPPORTED_SCHEMA_FIELDS = ['examples', 'additionalInfo', 'default', '$schema'];
+/**
+ * Recursively removes unsupported fields from JSON schema objects.
+ */
+function sanitizeSchema(obj) {
+    if (obj === null || typeof obj !== 'object')
+        return obj;
+    if (Array.isArray(obj))
+        return obj.map(sanitizeSchema);
+    const sanitized = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (!UNSUPPORTED_SCHEMA_FIELDS.includes(key)) {
+            sanitized[key] = sanitizeSchema(value);
+        }
+    }
+    return sanitized;
+}
+/**
+ * Wraps a tool to sanitize its schema for Gemini compatibility.
+ */
+function wrapToolWithSanitizedSchema(tool) {
+    const originalSchema = tool.schema;
+    if (originalSchema && typeof originalSchema === 'object') {
+        tool.schema = sanitizeSchema(originalSchema);
+    }
+    return tool;
+}
+/** Timeout (ms) for connecting to each MCP server */
+const MCP_CONNECT_TIMEOUT_MS = 60_000;
+function connectTimeout(serverName, ms) {
+    return new Promise((_, reject) => setTimeout(() => reject(new Error(`MCP server '${serverName}' timed out after ${ms}ms`)), ms));
+}
+/**
+ * MCPToolCache is a singleton that caches MCP tools in memory.
+ *
+ * Tools are loaded once at startup (or on first access) and cached.
+ * Subsequent calls to `getTools()` return the cached tools instantly.
+ * Call `reload()` to refresh tools from MCP servers.
+ *
+ * This eliminates the slow re-connection to MCP servers on every agent invocation.
+ */
+export class MCPToolCache {
+    static instance = null;
+    allTools = [];
+    serverInfos = [];
+    lastLoadedAt = null;
+    isLoading = false;
+    loadPromise = null;
+    hasLoaded = false;
+    constructor() { }
+    static getInstance() {
+        if (!MCPToolCache.instance) {
+            MCPToolCache.instance = new MCPToolCache();
+        }
+        return MCPToolCache.instance;
+    }
+    /** Reset singleton - for testing */
+    static resetInstance() {
+        MCPToolCache.instance = null;
+    }
+    /**
+     * Ensure tools are loaded. If already loaded, returns immediately.
+     * If loading is in progress, waits for that load to complete.
+     * Otherwise, triggers a new load.
+     */
+    async ensureLoaded() {
+        if (this.hasLoaded)
+            return;
+        if (this.isLoading && this.loadPromise) {
+            await this.loadPromise;
+            return;
+        }
+        await this.load();
+    }
+    /**
+     * Load tools from all MCP servers. Called once at startup.
+     * If already loading, returns the existing promise.
+     */
+    async load() {
+        if (this.isLoading && this.loadPromise) {
+            return this.loadPromise;
+        }
+        this.isLoading = true;
+        this.loadPromise = this._doLoad();
+        try {
+            await this.loadPromise;
+        }
+        finally {
+            this.isLoading = false;
+            this.loadPromise = null;
+        }
+    }
+    async _doLoad() {
+        const startTime = Date.now();
+        const mcpServers = await loadMCPConfig();
+        const serverNames = Object.keys(mcpServers);
+        if (serverNames.length === 0) {
+            display.log('No MCP servers configured in mcps.json', { level: 'info', source: 'MCPToolCache' });
+            this.allTools = [];
+            this.serverInfos = [];
+            this.lastLoadedAt = new Date();
+            this.hasLoaded = true;
+            return;
+        }
+        display.log(`Loading MCP tools from ${serverNames.length} servers...`, { level: 'info', source: 'MCPToolCache' });
+        const newTools = [];
+        const newServerInfos = [];
+        for (const [serverName, serverConfig] of Object.entries(mcpServers)) {
+            const serverStart = Date.now();
+            try {
+                display.log(`Connecting to MCP server '${serverName}'... (timeout: ${MCP_CONNECT_TIMEOUT_MS / 1000}s)`, {
+                    level: 'info',
+                    source: 'MCPToolCache',
+                    meta: { server: serverName, transport: serverConfig.transport }
+                });
+                const client = new MultiServerMCPClient({
+                    mcpServers: { [serverName]: serverConfig },
+                    onConnectionError: "ignore",
+                });
+                const tools = await Promise.race([
+                    client.getTools(),
+                    connectTimeout(serverName, MCP_CONNECT_TIMEOUT_MS),
+                ]);
+                // Rename tools with server prefix to avoid collisions
+                tools.forEach(tool => {
+                    const newName = `${serverName}_${tool.name}`;
+                    Object.defineProperty(tool, "name", { value: newName });
+                });
+                // Sanitize schemas for Gemini compatibility
+                const sanitizedTools = tools.map(wrapToolWithSanitizedSchema);
+                newTools.push(...sanitizedTools);
+                newServerInfos.push({
+                    name: serverName,
+                    toolCount: sanitizedTools.length,
+                    tools: sanitizedTools,
+                    ok: true,
+                    loadedAt: new Date(),
+                });
+                const elapsed = Date.now() - serverStart;
+                display.log(`Loaded ${sanitizedTools.length} tools from '${serverName}' in ${elapsed}ms`, {
+                    level: 'info',
+                    source: 'MCPToolCache'
+                });
+            }
+            catch (error) {
+                const elapsed = Date.now() - serverStart;
+                const errorMsg = String(error);
+                display.log(`Failed to load tools from '${serverName}' (${elapsed}ms): ${errorMsg}`, {
+                    level: 'warning',
+                    source: 'MCPToolCache'
+                });
+                newServerInfos.push({
+                    name: serverName,
+                    toolCount: 0,
+                    tools: [],
+                    ok: false,
+                    error: errorMsg,
+                    loadedAt: new Date(),
+                });
+            }
+        }
+        this.allTools = newTools;
+        this.serverInfos = newServerInfos;
+        this.lastLoadedAt = new Date();
+        this.hasLoaded = true;
+        const totalElapsed = Date.now() - startTime;
+        display.log(`MCP tool cache loaded: ${newTools.length} tools from ${serverNames.length} servers in ${totalElapsed}ms`, {
+            level: 'info',
+            source: 'MCPToolCache'
+        });
+    }
+    /**
+     * Force reload tools from MCP servers.
+     * Clears the cache and loads fresh tools.
+     */
+    async reload() {
+        this.hasLoaded = false;
+        await this.load();
+    }
+    /**
+     * Get all cached MCP tools.
+     * Returns cached tools instantly (no server connection).
+     * Call `ensureLoaded()` first if tools may not be loaded yet.
+     */
+    getTools() {
+        return this.allTools;
+    }
+    /**
+     * Get detailed info about each MCP server's tools.
+     */
+    getServerInfos() {
+        return this.serverInfos;
+    }
+    /**
+     * Get stats for UI display (without full tool objects).
+     */
+    getStats() {
+        return {
+            totalTools: this.allTools.length,
+            servers: this.serverInfos.map(s => ({
+                name: s.name,
+                toolCount: s.toolCount,
+                ok: s.ok,
+                error: s.error,
+            })),
+            lastLoadedAt: this.lastLoadedAt,
+            isLoading: this.isLoading,
+        };
+    }
+    /**
+     * Check if cache has been loaded at least once.
+     */
+    isLoaded() {
+        return this.hasLoaded;
+    }
+    /**
+     * Get timestamp of last load (or null if never loaded).
+     */
+    getLastLoadedAt() {
+        return this.lastLoadedAt;
+    }
+}