morpheus-cli 0.4.1 → 0.4.3

package/dist/devkit/tools/system.js

@@ -0,0 +1,132 @@
+import { tool } from '@langchain/core/tools';
+import { z } from 'zod';
+import { ShellAdapter } from '../adapters/shell.js';
+import { registerToolFactory } from '../registry.js';
+import { platform } from 'os';
+export function createSystemTools(ctx) {
+    const shell = ShellAdapter.create();
+    const isWindows = platform() === 'win32';
+    const isMac = platform() === 'darwin';
+    return [
+        tool(async ({ title, message, urgency }) => {
+            try {
+                if (isWindows) {
+                    // PowerShell toast notification
+                    const ps = `[Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType=WindowsRuntime] | Out-Null; $template = [Windows.UI.Notifications.ToastNotificationManager]::GetTemplateContent([Windows.UI.Notifications.ToastTemplateType]::ToastText02); $template.GetElementsByTagName('text')[0].AppendChild($template.CreateTextNode('${title}')); $template.GetElementsByTagName('text')[1].AppendChild($template.CreateTextNode('${message}')); [Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier('Morpheus').Show([Windows.UI.Notifications.ToastNotification]::new($template))`;
+                    await shell.run('powershell', ['-Command', ps], { cwd: ctx.working_dir, timeout_ms: 5_000 });
+                }
+                else if (isMac) {
+                    await shell.run('osascript', ['-e', `display notification "${message}" with title "${title}"`], {
+                        cwd: ctx.working_dir, timeout_ms: 5_000,
+                    });
+                }
+                else {
+                    // Linux — notify-send
+                    const args = [title, message];
+                    if (urgency)
+                        args.unshift(`-u`, urgency);
+                    await shell.run('notify-send', args, { cwd: ctx.working_dir, timeout_ms: 5_000 });
+                }
+                return JSON.stringify({ success: true });
+            }
+            catch (err) {
+                return JSON.stringify({ success: false, error: err.message });
+            }
+        }, {
+            name: 'notify',
+            description: 'Send a desktop notification.',
+            schema: z.object({
+                title: z.string(),
+                message: z.string(),
+                urgency: z.enum(['low', 'normal', 'critical']).optional().describe('Linux urgency level'),
+            }),
+        }),
+        tool(async () => {
+            try {
+                let result;
+                if (isWindows) {
+                    result = await shell.run('powershell', ['-Command', 'Get-Clipboard'], {
+                        cwd: ctx.working_dir, timeout_ms: 5_000,
+                    });
+                }
+                else if (isMac) {
+                    result = await shell.run('pbpaste', [], { cwd: ctx.working_dir, timeout_ms: 5_000 });
+                }
+                else {
+                    result = await shell.run('xclip', ['-selection', 'clipboard', '-o'], {
+                        cwd: ctx.working_dir, timeout_ms: 5_000,
+                    });
+                }
+                return JSON.stringify({ success: result.exitCode === 0, content: result.stdout });
+            }
+            catch (err) {
+                return JSON.stringify({ success: false, error: err.message });
+            }
+        }, {
+            name: 'read_clipboard',
+            description: 'Read the current clipboard contents.',
+            schema: z.object({}),
+        }),
+        tool(async ({ content }) => {
+            try {
+                let result;
+                if (isWindows) {
+                    result = await shell.run('powershell', ['-Command', `Set-Clipboard -Value '${content.replace(/'/g, "''")}'`], {
+                        cwd: ctx.working_dir, timeout_ms: 5_000,
+                    });
+                }
+                else if (isMac) {
+                    result = await shell.run('sh', ['-c', `printf '%s' '${content.replace(/'/g, "'\\''")}' | pbcopy`], {
+                        cwd: ctx.working_dir, timeout_ms: 5_000,
+                    });
+                }
+                else {
+                    result = await shell.run('sh', ['-c', `printf '%s' '${content.replace(/'/g, "'\\''")}' | xclip -selection clipboard`], {
+                        cwd: ctx.working_dir, timeout_ms: 5_000,
+                    });
+                }
+                return JSON.stringify({ success: result.exitCode === 0 });
+            }
+            catch (err) {
+                return JSON.stringify({ success: false, error: err.message });
+            }
+        }, {
+            name: 'write_clipboard',
+            description: 'Write content to the clipboard.',
+            schema: z.object({ content: z.string() }),
+        }),
+        tool(async ({ url }) => {
+            try {
+                const open = isWindows ? 'start' : isMac ? 'open' : 'xdg-open';
+                const result = await shell.run(isWindows ? 'cmd' : open, isWindows ? ['/c', 'start', url] : [url], {
+                    cwd: ctx.working_dir, timeout_ms: 5_000,
+                });
+                return JSON.stringify({ success: result.exitCode === 0, url });
+            }
+            catch (err) {
+                return JSON.stringify({ success: false, error: err.message });
+            }
+        }, {
+            name: 'open_url',
+            description: 'Open a URL in the default browser.',
+            schema: z.object({ url: z.string() }),
+        }),
+        tool(async ({ file_path }) => {
+            try {
+                const open = isWindows ? 'start' : isMac ? 'open' : 'xdg-open';
+                const result = await shell.run(isWindows ? 'cmd' : open, isWindows ? ['/c', 'start', '""', file_path] : [file_path], {
+                    cwd: ctx.working_dir, timeout_ms: 5_000,
+                });
+                return JSON.stringify({ success: result.exitCode === 0, file_path });
+            }
+            catch (err) {
+                return JSON.stringify({ success: false, error: err.message });
+            }
+        }, {
+            name: 'open_file',
+            description: 'Open a file with the default application.',
+            schema: z.object({ file_path: z.string() }),
+        }),
+    ];
+}
+registerToolFactory(createSystemTools);

package/dist/devkit/types.js

@@ -0,0 +1 @@
+export const MAX_OUTPUT_BYTES = 50 * 1024; // 50 KB

package/dist/devkit/utils.js

@@ -0,0 +1,45 @@
+import path from 'path';
+import { MAX_OUTPUT_BYTES } from './types.js';
+/**
+ * Truncates a string to MAX_OUTPUT_BYTES (50 KB) if needed.
+ * Returns a UTF-8-safe truncation with a note when truncated.
+ */
+export function truncateOutput(output) {
+    const bytes = Buffer.byteLength(output, 'utf8');
+    if (bytes <= MAX_OUTPUT_BYTES)
+        return output;
+    const truncated = Buffer.from(output).subarray(0, MAX_OUTPUT_BYTES).toString('utf8');
+    return truncated + `\n\n[OUTPUT TRUNCATED: ${bytes} bytes total, showing first ${MAX_OUTPUT_BYTES} bytes]`;
+}
+/**
+ * Returns true if filePath is inside dir (or equal to dir).
+ * Both paths are resolved before comparison.
+ */
+export function isWithinDir(filePath, dir) {
+    const resolved = path.resolve(filePath);
+    const resolvedDir = path.resolve(dir);
+    return resolved === resolvedDir || resolved.startsWith(resolvedDir + path.sep);
+}
+/**
+ * Extracts the binary base name from a command string.
+ * Handles full paths (/usr/bin/node, C:\bin\node.exe) and plain names.
+ */
+export function extractBinaryName(command) {
+    // Take first token (before any space), then get the basename, strip extension
+    const firstToken = command.split(/\s+/)[0] ?? command;
+    const base = path.basename(firstToken);
+    return base.replace(/\.(exe|cmd|bat|sh|ps1)$/i, '').toLowerCase();
+}
+/**
+ * Checks if a command is allowed based on the allowlist.
+ * Empty allowlist means ALL commands are allowed (Merovingian mode).
+ */
+export function isCommandAllowed(command, allowedCommands) {
+    if (allowedCommands.length === 0)
+        return true;
+    const binary = extractBinaryName(command);
+    return allowedCommands.some(allowed => {
+        const allowedBinary = extractBinaryName(allowed);
+        return allowedBinary === binary;
+    });
+}

package/dist/http/api.js

@@ -386,6 +386,52 @@ export function createApiRouter(oracle) {
             res.status(500).json({ error: error.message });
         }
     });
+    // Apoc config endpoints
+    router.get('/config/apoc', (req, res) => {
+        try {
+            const apocConfig = configManager.getApocConfig();
+            res.json(apocConfig);
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    router.post('/config/apoc', async (req, res) => {
+        try {
+            const config = configManager.get();
+            await configManager.save({ ...config, apoc: req.body });
+            const display = DisplayManager.getInstance();
+            display.log('Apoc configuration updated via UI', {
+                source: 'Zaion',
+                level: 'info'
+            });
+            res.json({ success: true });
+        }
+        catch (error) {
+            if (error.name === 'ZodError') {
+                res.status(400).json({ error: 'Validation failed', details: error.errors });
+            }
+            else {
+                res.status(500).json({ error: error.message });
+            }
+        }
+    });
+    router.delete('/config/apoc', async (req, res) => {
+        try {
+            const config = configManager.get();
+            const { apoc: _apoc, ...restConfig } = config;
+            await configManager.save(restConfig);
+            const display = DisplayManager.getInstance();
+            display.log('Apoc configuration removed via UI (falling back to Oracle config)', {
+                source: 'Zaion',
+                level: 'info'
+            });
+            res.json({ success: true });
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
     // Sati memories endpoints
     router.get('/sati/memories', async (req, res) => {
         try {

package/dist/runtime/apoc.js

@@ -0,0 +1,110 @@
+import { HumanMessage, SystemMessage } from "@langchain/core/messages";
+import { ConfigManager } from "../config/manager.js";
+import { ProviderFactory } from "./providers/factory.js";
+import { ProviderError } from "./errors.js";
+import { DisplayManager } from "./display.js";
+import { buildDevKit } from "../devkit/index.js";
+/**
+ * Apoc is a subagent of Oracle specialized in devtools operations.
+ * It receives delegated tasks from Oracle and executes them using DevKit tools
+ * (filesystem, shell, git, network, processes, packages, system).
+ *
+ * Oracle calls Apoc via the `apoc_delegate` tool when the user requests
+ * dev-related tasks such as running commands, reading/writing files,
+ * managing git, or inspecting system state.
+ */
+export class Apoc {
+    static instance = null;
+    agent;
+    config;
+    display = DisplayManager.getInstance();
+    constructor(config) {
+        this.config = config || ConfigManager.getInstance().get();
+    }
+    static getInstance(config) {
+        if (!Apoc.instance) {
+            Apoc.instance = new Apoc(config);
+        }
+        return Apoc.instance;
+    }
+    static resetInstance() {
+        Apoc.instance = null;
+    }
+    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;
+        // 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
+            timeout_ms,
+        });
+        this.display.log(`Apoc initialized with ${tools.length} DevKit tools (working_dir: ${working_dir})`, { source: "Apoc" });
+        try {
+            this.agent = await ProviderFactory.createBare(apocConfig, tools);
+        }
+        catch (err) {
+            throw new ProviderError(apocConfig.provider, err, "Apoc subagent initialization failed");
+        }
+    }
+    /**
+     * Execute a devtools task delegated by Oracle.
+     * @param task Natural language task description
+     * @param context Optional additional context from the ongoing conversation
+     */
+    async execute(task, context) {
+        if (!this.agent) {
+            await this.initialize();
+        }
+        this.display.log(`Executing delegated task: ${task.slice(0, 80)}...`, {
+            source: "Apoc",
+        });
+        const systemMessage = new SystemMessage(`
+You are Apoc, a specialized devtools subagent within the Morpheus system.
+
+You are called by Oracle when the user needs dev operations performed.
+Your job is to execute the requested task accurately using your available tools.
+
+Available capabilities:
+- Read, write, append, and delete files
+- Execute shell commands
+- Inspect and manage processes
+- Run git operations (status, log, diff, clone, commit, etc.)
+- Perform network operations (curl, DNS, ping)
+- Manage packages (npm, yarn)
+- Inspect system information
+
+OPERATING RULES:
+1. Use tools to accomplish the task. Do not speculate.
+2. Always verify results after execution.
+3. Report clearly what was done and what the result was.
+4. If something fails, report the error and what you tried.
+5. Stay focused on the delegated task only.
+
+${context ? `CONTEXT FROM ORACLE:\n${context}` : ""}
+    `);
+        const userMessage = new HumanMessage(task);
+        const messages = [systemMessage, userMessage];
+        try {
+            const response = await this.agent.invoke({ messages });
+            const lastMessage = response.messages[response.messages.length - 1];
+            const content = typeof lastMessage.content === "string"
+                ? lastMessage.content
+                : JSON.stringify(lastMessage.content);
+            this.display.log("Apoc task completed.", { source: "Apoc" });
+            return content;
+        }
+        catch (err) {
+            throw new ProviderError(this.config.apoc?.provider || this.config.llm.provider, err, "Apoc task execution failed");
+        }
+    }
+    /** Reload with updated config (called when settings change) */
+    async reload() {
+        this.config = ConfigManager.getInstance().get();
+        this.agent = undefined;
+        await this.initialize();
+    }
+}

package/dist/runtime/lifecycle.js

@@ -31,15 +31,37 @@ export function isProcessRunning(pid) {
         return e.code === 'EPERM'; // If EPERM, it exists but we lack permission (still running)
     }
 }
+/**
+ * Waits until the given PID is no longer running, or until timeout is reached.
+ * Returns true if the process died, false if timeout was reached.
+ */
+export async function waitForProcessDeath(pid, timeoutMs = 5000, intervalMs = 200) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (!isProcessRunning(pid))
+            return true;
+        await new Promise(resolve => setTimeout(resolve, intervalMs));
+    }
+    return !isProcessRunning(pid);
+}
 export async function checkStalePid() {
     const pid = await readPid();
     if (pid !== null) {
+        // Never treat our own PID as stale — this avoids self-kill loops in containers
+        // where a restarted process may inherit the same PID that was previously written.
+        if (pid === process.pid) {
+            await clearPid();
+            return;
+        }
         if (!isProcessRunning(pid)) {
             await clearPid();
         }
     }
 }
 export function killProcess(pid) {
+    // Safety guard: never kill ourselves
+    if (pid === process.pid)
+        return false;
     try {
         process.kill(pid, 'SIGTERM');
         return true;

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