morpheus-cli 0.1.4 → 0.1.6

package/dist/runtime/tools/diagnostic-tools.js

@@ -0,0 +1,124 @@
+import { tool } from "langchain";
+import * as z from "zod";
+import { ConfigManager } from "../../config/manager.js";
+import { promises as fsPromises } from "fs";
+import path from "path";
+import { homedir } from "os";
+// Tool for performing system diagnostics
+export const DiagnosticTool = tool(async () => {
+    try {
+        const timestamp = new Date().toISOString();
+        const components = {};
+        // Check configuration
+        try {
+            const configManager = ConfigManager.getInstance();
+            await configManager.load();
+            const config = configManager.get();
+            // Basic validation - check if required fields exist
+            const requiredFields = ['llm', 'logging', 'ui'];
+            const missingFields = requiredFields.filter(field => !(field in config));
+            if (missingFields.length === 0) {
+                components.config = {
+                    status: "healthy",
+                    message: "Configuration is valid and complete",
+                    details: {
+                        llmProvider: config.llm?.provider,
+                        uiEnabled: config.ui?.enabled,
+                        uiPort: config.ui?.port
+                    }
+                };
+            }
+            else {
+                components.config = {
+                    status: "warning",
+                    message: `Missing required configuration fields: ${missingFields.join(', ')}`,
+                    details: { missingFields }
+                };
+            }
+        }
+        catch (error) {
+            components.config = {
+                status: "error",
+                message: `Configuration error: ${error.message}`,
+                details: {}
+            };
+        }
+        // Check storage/database
+        try {
+            // For now, we'll check if the data directory exists
+            const dbPath = path.join(homedir(), ".morpheus", "memory", "short-memory.db");
+            await fsPromises.access(dbPath);
+            components.storage = {
+                status: "healthy",
+                message: "Database file is accessible",
+                details: { path: dbPath }
+            };
+        }
+        catch (error) {
+            components.storage = {
+                status: "error",
+                message: `Storage error: ${error.message}`,
+                details: {}
+            };
+        }
+        // Check network connectivity (basic check)
+        try {
+            // For now, we'll just check if we can reach the LLM provider configuration
+            const configManager = ConfigManager.getInstance();
+            await configManager.load();
+            const config = configManager.get();
+            if (config.llm && config.llm.provider) {
+                components.network = {
+                    status: "healthy",
+                    message: `LLM provider configured: ${config.llm.provider}`,
+                    details: { provider: config.llm.provider }
+                };
+            }
+            else {
+                components.network = {
+                    status: "warning",
+                    message: "No LLM provider configured",
+                    details: {}
+                };
+            }
+        }
+        catch (error) {
+            components.network = {
+                status: "error",
+                message: `Network check error: ${error.message}`,
+                details: {}
+            };
+        }
+        // Check if the agent is running
+        try {
+            // This is a basic check - in a real implementation, we might check if the agent process is running
+            components.agent = {
+                status: "healthy",
+                message: "Agent is running",
+                details: { uptime: "N/A - runtime information not available in this context" }
+            };
+        }
+        catch (error) {
+            components.agent = {
+                status: "error",
+                message: `Agent check error: ${error.message}`,
+                details: {}
+            };
+        }
+        return JSON.stringify({
+            timestamp,
+            components
+        });
+    }
+    catch (error) {
+        console.error("Error in DiagnosticTool:", error);
+        return JSON.stringify({
+            timestamp: new Date().toISOString(),
+            error: "Failed to run diagnostics"
+        });
+    }
+}, {
+    name: "diagnostic_check",
+    description: "Performs system health diagnostics and returns a comprehensive report on system components.",
+    schema: z.object({}),
+});

package/dist/runtime/tools/factory.js

@@ -0,0 +1,78 @@
+import { MultiServerMCPClient } from "@langchain/mcp-adapters";
+import { DisplayManager } from "../display.js";
+import { loadMCPConfig } from "../../config/mcp-loader.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.
+ * This is needed because some MCP servers (like Coolify) return schemas
+ * with fields that Gemini doesn't accept.
+ */
+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.
+ * Creates a proxy that intercepts schema access and sanitizes the output.
+ */
+function wrapToolWithSanitizedSchema(tool) {
+    display.log('Tool loaded: - ' + tool.name, { source: 'ToolsFactory' });
+    // The MCP tools have a schema property that returns JSON Schema
+    // We need to intercept and sanitize it
+    const originalSchema = tool.schema;
+    if (originalSchema && typeof originalSchema === 'object') {
+        // Sanitize the schema object directly
+        const sanitized = sanitizeSchema(originalSchema);
+        tool.schema = sanitized;
+    }
+    return tool;
+}
+export class ToolsFactory {
+    static async create() {
+        const display = DisplayManager.getInstance();
+        const mcpServers = await loadMCPConfig();
+        const serverCount = Object.keys(mcpServers).length;
+        if (serverCount === 0) {
+            display.log('No MCP servers configured in mcps.json', { level: 'info', source: 'ToolsFactory' });
+            return [];
+        }
+        const client = new MultiServerMCPClient({
+            mcpServers: mcpServers,
+            onConnectionError: "ignore",
+            // log the MCP client's internal events
+            beforeToolCall: ({ serverName, name, args }) => {
+                display.log(`MCP Tool Call - Server: ${serverName}, Tool: ${name}, Args: ${JSON.stringify(args)}`, { source: 'MCPServer' });
+                return;
+            },
+            // log the results of tool calls
+            afterToolCall: (res) => {
+                display.log(`MCP Tool Result - ${JSON.stringify(res)}`, { source: 'MCPServer' });
+                return;
+            }
+        });
+        try {
+            const tools = await client.getTools();
+            // Sanitize tool schemas to remove fields not supported by Gemini
+            const sanitizedTools = tools.map(tool => wrapToolWithSanitizedSchema(tool));
+            display.log(`Loaded ${sanitizedTools.length} MCP tools (schemas sanitized for Gemini compatibility)`, { level: 'info', source: 'ToolsFactory' });
+            return sanitizedTools;
+        }
+        catch (error) {
+            display.log(`Failed to initialize MCP tools: ${error}`, { level: 'warning', source: 'ToolsFactory' });
+            return []; // Return empty tools on failure to allow agent to start
+        }
+    }
+}

package/dist/runtime/tools/index.js

@@ -0,0 +1,4 @@
+// Export all tools from the tools module
+export * from './config-tools.js';
+export * from './diagnostic-tools.js';
+export * from './analytics-tools.js';

package/dist/types/auth.js

@@ -0,0 +1,4 @@
+/**
+ * Shared constants and interfaces for HTTP Authentication
+ */
+export const AUTH_HEADER = 'x-architect-pass';

package/dist/types/config.js

@@ -9,10 +9,14 @@ export const DEFAULT_CONFIG = {
         retention: '14d',
     },
     audio: {
+        provider: 'google',
         enabled: true,
         maxDurationSeconds: 300,
         supportedMimeTypes: ['audio/ogg', 'audio/mp3', 'audio/mpeg', 'audio/wav'],
     },
+    memory: {
+        limit: 100
+    },
     llm: {
         provider: 'openai',
         model: 'gpt-4',

package/dist/types/mcp.js

@@ -0,0 +1,11 @@
+export const DEFAULT_MCP_TEMPLATE = {
+    "_comment": "MCP Server Configuration for Morpheus",
+    "_docs": "Add your MCP servers below. Each key is a unique server name.",
+    "example": {
+        "_comment": "EXAMPLE - Remove or replace this entry with your own MCPs",
+        "transport": "stdio",
+        "command": "npx",
+        "args": ["-y", "your-mcp-package-name"],
+        "env": {}
+    }
+};

package/dist/types/tools.js

@@ -0,0 +1,2 @@
+// Tool type definitions for Morpheus internal tools
+export {};

package/dist/types/usage.js

@@ -0,0 +1 @@
+export {};