morpheus-cli 0.4.0 → 0.4.2

package/dist/runtime/oracle.js

@@ -229,7 +229,10 @@ You maintain intent until resolution.
             const lastMessage = response.messages[response.messages.length - 1];
             const responseContent = (typeof lastMessage.content === 'string') ? lastMessage.content : JSON.stringify(lastMessage.content);
             // Sati Middleware: Evaluation (Fire and forget)
-            this.satiMiddleware.afterAgent(responseContent, [...previousMessages, userMessage])
+            const currentSessionId = (this.history instanceof SQLiteChatMessageHistory)
+                ? this.history.currentSessionId
+                : undefined;
+            this.satiMiddleware.afterAgent(responseContent, [...previousMessages, userMessage], currentSessionId)
                 .catch((e) => this.display.log(`Sati memory evaluation failed: ${e.message}`, { source: 'Sati' }));
             return responseContent;
         }

package/dist/runtime/providers/factory.js

@@ -4,14 +4,12 @@ import { ChatOllama } from "@langchain/ollama";
 import { ChatGoogleGenerativeAI } from "@langchain/google-genai";
 import { ProviderError } from "../errors.js";
 import { createAgent, createMiddleware } from "langchain";
-// import { MultiServerMCPClient, } from "@langchain/mcp-adapters"; // REMOVED
-import { z } from "zod";
 import { DisplayManager } from "../display.js";
-import { ConfigQueryTool, ConfigUpdateTool, DiagnosticTool, MessageCountTool, TokenUsageTool, ProviderModelUsageTool } from "../tools/index.js";
+import { ConfigQueryTool, ConfigUpdateTool, DiagnosticTool, MessageCountTool, TokenUsageTool, ProviderModelUsageTool, ApocDelegateTool } from "../tools/index.js";
 export class ProviderFactory {
-    static async create(config, tools = []) {
-        let display = DisplayManager.getInstance();
-        const toolMonitoringMiddleware = createMiddleware({
+    static buildMonitoringMiddleware() {
+        const display = DisplayManager.getInstance();
+        return createMiddleware({
             name: "ToolMonitoringMiddleware",
             wrapToolCall: (request, handler) => {
                 display.log(`Executing tool: ${request.toolCall.name}`, { level: "warning", source: 'ConstructLoad' });
@@ -27,55 +25,84 @@ export class ProviderFactory {
                 }
             },
         });
-        let model;
-        const responseSchema = z.object({
-            content: z.string().describe("The main response content from the agent"),
-        });
-        // Removed direct MCP client instantiation
+    }
+    static buildModel(config) {
+        switch (config.provider) {
+            case 'openai':
+                return new ChatOpenAI({
+                    modelName: config.model,
+                    temperature: config.temperature,
+                    apiKey: process.env.OPENAI_API_KEY || config.api_key,
+                });
+            case 'anthropic':
+                return new ChatAnthropic({
+                    modelName: config.model,
+                    temperature: config.temperature,
+                    apiKey: process.env.ANTHROPIC_API_KEY || config.api_key,
+                });
+            case 'openrouter':
+                return new ChatOpenAI({
+                    modelName: config.model,
+                    temperature: config.temperature,
+                    apiKey: process.env.OPENROUTER_API_KEY || config.api_key,
+                    configuration: {
+                        baseURL: config.base_url || 'https://openrouter.ai/api/v1'
+                    }
+                });
+            case 'ollama':
+                return new ChatOllama({
+                    model: config.model,
+                    temperature: config.temperature,
+                    baseUrl: config.base_url || config.api_key,
+                });
+            case 'gemini':
+                return new ChatGoogleGenerativeAI({
+                    model: config.model,
+                    temperature: config.temperature,
+                    apiKey: process.env.GOOGLE_API_KEY || config.api_key
+                });
+            default:
+                throw new Error(`Unsupported provider: ${config.provider}`);
+        }
+    }
+    static handleProviderError(config, error) {
+        let suggestion = "Check your configuration and API keys.";
+        const msg = error.message?.toLowerCase() || '';
+        if (msg.includes("api key") && (msg.includes("missing") || msg.includes("not found"))) {
+            suggestion = `API Key is missing for ${config.provider}. Run 'morpheus config' or set it in .env.`;
+        }
+        else if (msg.includes("401") || msg.includes("unauthorized")) {
+            suggestion = `Run 'morpheus config' to update your ${config.provider} API key.`;
+        }
+        else if ((msg.includes("econnrefused") || msg.includes("fetch failed")) && config.provider === 'ollama') {
+            suggestion = "Is Ollama running? Try 'ollama serve'.";
+        }
+        else if (msg.includes("model not found") || msg.includes("404")) {
+            suggestion = `Model '${config.model}' may not be available. Check provider docs.`;
+        }
+        else if (msg.includes("unsupported provider")) {
+            suggestion = "Edit your config file to use a supported provider (openai, anthropic, openrouter, ollama, gemini).";
+        }
+        throw new ProviderError(config.provider, error, suggestion);
+    }
+    /**
+     * Creates a ReactAgent with only the provided tools — no internal Oracle tools injected.
+     * Used by subagents like Apoc that need a clean, isolated tool context.
+     */
+    static async createBare(config, tools = []) {
+        try {
+            const model = ProviderFactory.buildModel(config);
+            const middleware = ProviderFactory.buildMonitoringMiddleware();
+            return createAgent({ model, tools, middleware: [middleware] });
+        }
+        catch (error) {
+            ProviderFactory.handleProviderError(config, error);
+        }
+    }
+    static async create(config, tools = []) {
         try {
-            switch (config.provider) {
-                case 'openai':
-                    model = new ChatOpenAI({
-                        modelName: config.model,
-                        temperature: config.temperature,
-                        apiKey: process.env.OPENAI_API_KEY || config.api_key, // Check env var first, then config
-                    });
-                    break;
-                case 'anthropic':
-                    model = new ChatAnthropic({
-                        modelName: config.model,
-                        temperature: config.temperature,
-                        apiKey: process.env.ANTHROPIC_API_KEY || config.api_key, // Check env var first, then config
-                    });
-                    break;
-                case 'openrouter':
-                    model = new ChatOpenAI({
-                        modelName: config.model,
-                        temperature: config.temperature,
-                        apiKey: process.env.OPENROUTER_API_KEY || config.api_key, // Check env var first, then config
-                        configuration: {
-                            baseURL: config.base_url || 'https://openrouter.ai/api/v1'
-                        }
-                    });
-                    break;
-                case 'ollama':
-                    // Ollama usually runs locally, api_key optional
-                    model = new ChatOllama({
-                        model: config.model,
-                        temperature: config.temperature,
-                        baseUrl: config.api_key, // Sometimes users might overload api_key for base URL or similar, but simplified here
-                    });
-                    break;
-                case 'gemini':
-                    model = new ChatGoogleGenerativeAI({
-                        model: config.model,
-                        temperature: config.temperature,
-                        apiKey: process.env.GOOGLE_API_KEY || config.api_key // Check env var first, then config
-                    });
-                    break;
-                default:
-                    throw new Error(`Unsupported provider: ${config.provider}`);
-            }
+            const model = ProviderFactory.buildModel(config);
+            const middleware = ProviderFactory.buildMonitoringMiddleware();
             const toolsForAgent = [
                 ...tools,
                 ConfigQueryTool,
@@ -83,35 +110,13 @@ export class ProviderFactory {
                 DiagnosticTool,
                 MessageCountTool,
                 TokenUsageTool,
-                ProviderModelUsageTool
+                ProviderModelUsageTool,
+                ApocDelegateTool
             ];
-            return createAgent({
-                model: model,
-                tools: toolsForAgent,
-                middleware: [toolMonitoringMiddleware]
-            });
+            return createAgent({ model, tools: toolsForAgent, middleware: [middleware] });
         }
         catch (error) {
-            let suggestion = "Check your configuration and API keys.";
-            const msg = error.message?.toLowerCase() || '';
-            // Constructor validation errors (Missing Keys)
-            if (msg.includes("api key") && (msg.includes("missing") || msg.includes("not found"))) {
-                suggestion = `API Key is missing for ${config.provider}. Run 'morpheus config' or set it in .env.`;
-            }
-            // Network/Auth errors (unlikely in constructor, but possible if pre-validation exists)
-            else if (msg.includes("401") || msg.includes("unauthorized")) {
-                suggestion = `Run 'morpheus config' to update your ${config.provider} API key.`;
-            }
-            else if ((msg.includes("econnrefused") || msg.includes("fetch failed")) && config.provider === 'ollama') {
-                suggestion = "Is Ollama running? Try 'ollama serve'.";
-            }
-            else if (msg.includes("model not found") || msg.includes("404")) {
-                suggestion = `Model '${config.model}' may not be available. Check provider docs.`;
-            }
-            else if (msg.includes("unsupported provider")) {
-                suggestion = "Edit your config file to use a supported provider (openai, anthropic, openrouter, ollama, gemini).";
-            }
-            throw new ProviderError(config.provider, error, suggestion);
+            ProviderFactory.handleProviderError(config, error);
         }
     }
 }

package/dist/runtime/telephonist.js

@@ -2,6 +2,21 @@ import { GoogleGenAI } from '@google/genai';
 import OpenAI from 'openai';
 import { OpenRouter } from '@openrouter/sdk';
 import fs from 'fs';
+/**
+ * Estimates audio duration in seconds based on file size and a typical bitrate.
+ * Uses 32 kbps (4000 bytes/sec) as a conservative baseline for compressed audio (OGG, MP3, etc.).
+ * This is an approximation — actual duration depends on encoding settings.
+ */
+function estimateAudioDurationSeconds(filePath) {
+    try {
+        const stats = fs.statSync(filePath);
+        const bytesPerSecond = 4000; // ~32 kbps
+        return Math.round(stats.size / bytesPerSecond);
+    }
+    catch {
+        return 0;
+    }
+}
 class GeminiTelephonist {
     model;
     constructor(model) {
@@ -41,7 +56,8 @@ class GeminiTelephonist {
             total_tokens: usage?.totalTokenCount ?? 0,
             input_token_details: {
                 cache_read: usage?.cachedContentTokenCount ?? 0
-            }
+            },
+            audio_duration_seconds: estimateAudioDurationSeconds(filePath)
         };
         return { text, usage: usageMetadata };
     }
@@ -75,6 +91,7 @@ class WhisperTelephonist {
             input_tokens: 0,
             output_tokens: 0,
             total_tokens: 0,
+            audio_duration_seconds: estimateAudioDurationSeconds(filePath)
         };
         return { text, usage: usageMetadata };
     }
@@ -131,6 +148,7 @@ class OpenRouterTelephonist {
             input_tokens: usage?.prompt_tokens ?? 0,
             output_tokens: usage?.completion_tokens ?? 0,
             total_tokens: usage?.total_tokens ?? 0,
+            audio_duration_seconds: estimateAudioDurationSeconds(filePath)
         };
         return { text, usage: usageMetadata };
     }

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

@@ -0,0 +1,43 @@
+import { tool } from "@langchain/core/tools";
+import { z } from "zod";
+import { Apoc } from "../apoc.js";
+/**
+ * Tool that Oracle uses to delegate devtools tasks to Apoc.
+ * Oracle should call this whenever the user requests operations like:
+ * - Reading/writing/listing files
+ * - Running shell commands or scripts
+ * - Git operations (status, log, commit, push, etc.)
+ * - Package management (npm install, etc.)
+ * - Process inspection or management
+ * - Network diagnostics (ping, curl, DNS)
+ * - System information queries
+ */
+export const ApocDelegateTool = tool(async ({ task, context }) => {
+    try {
+        const apoc = Apoc.getInstance();
+        const result = await apoc.execute(task, context);
+        return result;
+    }
+    catch (err) {
+        return `Apoc execution failed: ${err.message}`;
+    }
+}, {
+    name: "apoc_delegate",
+    description: `Delegate a devtools task to Apoc, the specialized development subagent.
+
+Use this tool when the user asks for ANY of the following:
+- File operations: read, write, create, delete files or directories
+- Shell commands: run scripts, execute commands, check output
+- Git: status, log, diff, commit, push, pull, clone, branch
+- Package management: npm install/update/audit, yarn, package.json inspection
+- Process management: list processes, kill processes, check ports
+- Network: ping hosts, curl URLs, DNS lookups
+- System info: environment variables, OS info, disk space, memory
+
+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"),
+    }),
+});

package/dist/runtime/tools/index.js

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

package/dist/types/config.js

@@ -39,5 +39,11 @@ export const DEFAULT_CONFIG = {
         context_window: 100,
         memory_limit: 100,
         enabled_archived_sessions: true,
+    },
+    apoc: {
+        provider: 'openai',
+        model: 'gpt-4',
+        temperature: 0.2,
+        timeout_ms: 30000,
     }
 };