apexbot 1.0.8 → 1.1.0

package/README.md

@@ -39,20 +39,32 @@
 
 ### 🧠 Brain System
 - Personality profiles (SOUL files)
-- Long-term memory with vector store
+- **Long-term memory** with LanceDB vector store
+- **Auto-recall** - relevant memories injected into context
+- **Auto-capture** - preferences and decisions saved automatically
 - Context-aware responses
 - Lobster Engine for reasoning
 
+### 🔄 Model Fallback Chain
+- **Automatic failover** between AI providers
+- Tries: Ollama → Google → Anthropic
+- No manual intervention needed
+
 ### 🛠️ 30+ Skills
 
 | Category | Skills |
 |----------|--------|
 | **Communication** | Telegram, WhatsApp, Discord, Slack, Signal, iMessage, Matrix, Twitter, Gmail |
-| **Productivity** | Obsidian, Notion, Trello, GitHub, Calendar, Reminders, Apple Notes |
+| **Productivity** | Obsidian, Notion, Trello, GitHub, Calendar, Reminders, Apple Notes, **Memory** |
 | **Media** | Spotify, Sonos, Voice/TTS, Image Gen, GIF Search |
 | **Smart Home** | Home Assistant, Philips Hue |
 | **Automation** | Browser, Cron, 1Password, Weather, Search, System |
 
+### ⚡ Moltbot-Style Enhancements
+- **Rate limiting** via `@grammyjs/transformer-throttler`
+- **Typing indicators** - shows "typing..." while processing
+- **Memory tools** - `memory_recall`, `memory_store`, `memory_forget`
+
 ### ⌨️ Claude Code Style CLI
 
 **Input Prefixes:**
@@ -165,12 +177,23 @@ Config file: `~/.apexbot/config.json`
 
 | Provider | Cost | Notes |
 |----------|------|-------|
-| **Ollama** | Free | Local, recommended |
-| Google Gemini | Free tier | Cloud API |
-| Anthropic Claude | Paid | Cloud API |
+| **Ollama** | Free | Local, recommended, default |
+| Google Gemini | Free tier | Cloud API, fallback #1 |
+| Anthropic Claude | Paid | Cloud API, fallback #2 |
 | OpenAI GPT | Paid | Cloud API |
 | Kimi | Free tier | Cloud API |
 
+### Memory Plugin (Optional)
+
+```env
+# Required for memory_recall/store/forget
+OPENAI_API_KEY=sk-...
+
+# Optional
+MEMORY_EMBEDDING_MODEL=text-embedding-3-small
+MEMORY_DB_PATH=~/.apexbot/memory/lancedb
+```
+
 ---
 
 ## 🔧 CLI Commands
@@ -253,6 +276,9 @@ MIT License. See [LICENSE](LICENSE).
 
 ## 🙏 Acknowledgments
 
-- Inspired by [Clawdbot/Moltbot](https://clawd.bot)
+- **Ported features from** [Clawdbot/Moltbot](https://clawd.bot)
+  - Model fallback chain
+  - Long-term memory with LanceDB
+  - Rate limiting & typing indicators
 - Powered by [Ollama](https://ollama.com)
 - Built with TypeScript, grammy, discord.js

package/dist/agent/agentManager.js

@@ -12,10 +12,18 @@ const generative_ai_1 = require("@google/generative-ai");
 const tools_1 = require("../tools");
 const brain_1 = require("../brain");
 const toolExecutor_1 = require("./toolExecutor");
+const debug_1 = require("../core/debug");
 class AgentManager {
     config = null;
     googleClient = null;
     brain = null;
+    // Moltbot-style model fallback chain
+    fallbackModels = [
+        { provider: 'ollama', model: 'qwen2.5:14b' },
+        { provider: 'google', model: 'gemini-2.0-flash' },
+        { provider: 'anthropic', model: 'claude-sonnet-4-20250514' },
+    ];
+    fallbackEnabled = true;
     defaultSystemPrompt = `You are ApexBot, an autonomous AI assistant like Claude Code. You can execute real actions on the user's computer.
 
 ## CORE PRINCIPLES
@@ -58,7 +66,7 @@ You are running locally on the user's machine. No data leaves their computer. Yo
      */
     setBrain(brain) {
         this.brain = brain;
-        console.log('[Agent] Brain connected');
+        (0, debug_1.debug)('Agent', 'Brain connected');
     }
     configure(config) {
         this.config = {
@@ -84,7 +92,7 @@ You are running locally on the user's machine. No data leaves their computer. Yo
         if (config.provider === 'kimi') {
             // nothing to initialize here; processWithKimi will use fetch + config.apiUrl
         }
-        console.log(`[Agent] Configured with ${config.provider} (${config.model || 'default model'})`);
+        (0, debug_1.debug)('Agent', `Configured with ${config.provider} (${config.model || 'default model'})`);
     }
     async process(session, message) {
         if (!this.config) {
@@ -92,7 +100,7 @@ You are running locally on the user's machine. No data leaves their computer. Yo
             return { text: 'Agent not configured. Please set up an AI provider.' };
         }
         const userText = message.text || '';
-        console.log(`[Agent] Processing message: ${userText.slice(0, 50)}...`);
+        (0, debug_1.debug)('Agent', `Processing message: ${userText.slice(0, 50)}...`);
         // Handle slash commands
         if (userText.startsWith('/')) {
             return this.handleCommand(session, userText);
@@ -101,30 +109,44 @@ You are running locally on the user's machine. No data leaves their computer. Yo
         const history = this.buildHistory(session, userText);
         try {
             let response;
-            switch (this.config.provider) {
-                case 'ollama':
-                    response = await this.processWithOllama(history);
-                    break;
-                case 'google':
-                    response = await this.processWithGemini(history);
-                    break;
-                case 'anthropic':
-                    response = await this.processWithClaude(history);
-                    break;
-                case 'openai':
-                    response = await this.processWithOpenAI(history);
-                    break;
-                case 'kimi':
-                    response = await this.processWithKimi(history);
-                    break;
-                default:
-                    response = { text: 'Unknown AI provider' };
+            let lastError = null;
+            // Try primary provider first
+            try {
+                response = await this.processWithProvider(this.config.provider, this.config.model || '', history);
             }
+            catch (primaryError) {
+                console.warn(`[Agent] Primary provider ${this.config.provider} failed: ${primaryError.message}`);
+                lastError = primaryError;
+                // Try fallback providers (Moltbot-style)
+                if (this.fallbackEnabled && this.fallbackModels.length > 0) {
+                    for (const fallback of this.fallbackModels) {
+                        // Skip if same as primary
+                        if (fallback.provider === this.config.provider)
+                            continue;
+                        try {
+                            (0, debug_1.debug)('Agent', `Trying fallback: ${fallback.provider}/${fallback.model}`);
+                            response = await this.processWithProvider(fallback.provider, fallback.model, history);
+                            (0, debug_1.debug)('Agent', `Fallback ${fallback.provider} succeeded!`);
+                            lastError = null;
+                            break;
+                        }
+                        catch (fallbackError) {
+                            console.warn(`[Agent] Fallback ${fallback.provider} failed: ${fallbackError.message}`);
+                            lastError = fallbackError;
+                        }
+                    }
+                }
+                // If all providers failed
+                if (lastError) {
+                    throw lastError;
+                }
+            }
+            response = response;
             // Check for tool calls in response
             if (this.config.enableTools) {
                 const toolCalls = (0, toolExecutor_1.parseToolCalls)(response.text);
                 if (toolCalls.length > 0) {
-                    console.log(`[Agent] Found ${toolCalls.length} tool calls:`, toolCalls.map(t => t.name));
+                    (0, debug_1.debug)('Agent', `Found ${toolCalls.length} tool calls:`, toolCalls.map(t => t.name));
                     // Build tool context
                     const context = (0, toolExecutor_1.buildToolContext)(session.id, message.userId || message.from || 'unknown', message.channel, { workspaceDir: process.cwd() });
                     // Execute tools
@@ -132,9 +154,9 @@ You are running locally on the user's machine. No data leaves their computer. Yo
                     response.toolCalls = toolResults;
                     // Log results
                     for (const { call, result } of toolResults) {
-                        console.log(`[Agent] Tool ${call.name}: ${result.success ? 'SUCCESS' : 'FAILED'}`);
+                        (0, debug_1.debug)('Agent', `Tool ${call.name}: ${result.success ? 'SUCCESS' : 'FAILED'}`);
                         if (!result.success)
-                            console.log(`[Agent] Error: ${result.error}`);
+                            (0, debug_1.debug)('Agent', `Error: ${result.error}`);
                     }
                     // Format results and continue conversation
                     const resultsText = (0, toolExecutor_1.formatToolResults)(toolResults);
@@ -172,7 +194,7 @@ You are running locally on the user's machine. No data leaves their computer. Yo
                     }
                 }
             }
-            console.log(`[Agent] Generated response: ${response.text.slice(0, 50)}...`);
+            (0, debug_1.debug)('Agent', `Generated response: ${response.text.slice(0, 50)}...`);
             // Save to session (initialize messages array if needed)
             if (!session.messages)
                 session.messages = [];
@@ -247,6 +269,38 @@ You are running locally on the user's machine. No data leaves their computer. Yo
         }
         return parts.join('\n') || 'Done.';
     }
+    /**
+     * Route to the correct provider-specific method (Moltbot-style)
+     */
+    async processWithProvider(provider, model, history) {
+        // Temporarily override model if specified
+        const originalModel = this.config?.model;
+        if (model && this.config) {
+            this.config.model = model;
+        }
+        try {
+            switch (provider) {
+                case 'ollama':
+                    return await this.processWithOllama(history);
+                case 'google':
+                    return await this.processWithGemini(history);
+                case 'anthropic':
+                    return await this.processWithClaude(history);
+                case 'openai':
+                    return await this.processWithOpenAI(history);
+                case 'kimi':
+                    return await this.processWithKimi(history);
+                default:
+                    throw new Error(`Unknown provider: ${provider}`);
+            }
+        }
+        finally {
+            // Restore original model
+            if (originalModel && this.config) {
+                this.config.model = originalModel;
+            }
+        }
+    }
     async processWithKimi(history) {
         // Generic Kimi 2.5 integration wrapper. This implementation is intentionally
         // generic: it will POST to a user-provided `apiUrl` (in config or env) and
@@ -298,7 +352,7 @@ You are running locally on the user's machine. No data leaves their computer. Yo
         const apiUrl = cfg.apiUrl || 'http://localhost:11434';
         const model = cfg.model || 'llama3.2';
         const temperature = cfg.temperature ?? 0.7;
-        console.log(`[Agent] Calling Ollama at ${apiUrl} with model ${model}...`);
+        (0, debug_1.debug)('Agent', `Calling Ollama at ${apiUrl} with model ${model}...`);
         // Build messages array for Ollama chat API
         const messages = history.map(m => ({
             role: m.role,
@@ -327,7 +381,7 @@ You are running locally on the user's machine. No data leaves their computer. Yo
             }
             const data = await res.json();
             const text = data.message?.content || '';
-            console.log(`[Agent] Ollama response received: ${text.slice(0, 50)}...`);
+            (0, debug_1.debug)('Agent', `Ollama response received: ${text.slice(0, 50)}...`);
             return {
                 text: String(text).trim() || 'No response from model',
                 usage: {
@@ -379,7 +433,7 @@ You are running locally on the user's machine. No data leaves their computer. Yo
             try {
                 // Build full system prompt from brain files
                 systemPrompt = await this.brain.buildSystemPrompt(this.defaultSystemPrompt);
-                console.log('[Agent] Using brain context for system prompt');
+                (0, debug_1.debug)('Agent', 'Using brain context for system prompt');
             }
             catch (e) {
                 console.warn('[Agent] Failed to load brain context, using default');

package/dist/agent/orchestrator.js

@@ -22,6 +22,7 @@ const allowlist_1 = require("../safety/allowlist");
 const unifiedInbox_1 = require("../channels/unifiedInbox");
 const lobster_1 = require("../lobster");
 const agentManager_1 = require("./agentManager");
+const debug_1 = require("../core/debug");
 const tools_1 = require("../tools");
 /**
  * Agent Orchestrator - Main control loop
@@ -94,7 +95,7 @@ class AgentOrchestrator extends events_1.EventEmitter {
             // ─────────────────────────────────────────
             // PHASE 1: INGEST
             // ─────────────────────────────────────────
-            console.log('[Orchestrator] Phase 1: INGEST');
+            (0, debug_1.debugPhase)(1, 'INGEST', { message, sessionId });
             this.emit('phase:ingest', { message, sessionId });
             // Get or create session
             const session = await this.sessionStore.getOrCreate(sessionId, userId, channel);
@@ -107,7 +108,7 @@ class AgentOrchestrator extends events_1.EventEmitter {
             // ─────────────────────────────────────────
             // PHASE 2: CONTEXT
             // ─────────────────────────────────────────
-            console.log('[Orchestrator] Phase 2: CONTEXT');
+            (0, debug_1.debugPhase)(2, 'CONTEXT', { sessionId });
             this.emit('phase:context', { sessionId });
             // Get brain context
             const brainContext = await this.brain.buildSystemPrompt();
@@ -118,7 +119,7 @@ class AgentOrchestrator extends events_1.EventEmitter {
             if (this.config.enableRAG) {
                 const searchResults = await this.vectorStore.search(message, this.config.ragTopK, this.config.ragThreshold);
                 memories = searchResults.map(r => r.entry.content);
-                console.log(`[Orchestrator] Found ${memories.length} relevant memories`);
+                (0, debug_1.debug)('Orchestrator', `Found ${memories.length} relevant memories`);
             }
             const context = {
                 sessionId,
@@ -134,7 +135,7 @@ class AgentOrchestrator extends events_1.EventEmitter {
             // ─────────────────────────────────────────
             // PHASE 3: INFER
             // ─────────────────────────────────────────
-            console.log('[Orchestrator] Phase 3: INFER');
+            (0, debug_1.debugPhase)(3, 'INFER', null);
             this.emit('phase:infer', { context });
             // Build enhanced prompt with memories
             let enhancedMessage = message;
@@ -172,7 +173,7 @@ class AgentOrchestrator extends events_1.EventEmitter {
             // ─────────────────────────────────────────
             // PHASE 4: EXECUTE (handled in agent)
             // ─────────────────────────────────────────
-            console.log('[Orchestrator] Phase 4: EXECUTE');
+            (0, debug_1.debugPhase)(4, 'EXECUTE', { toolsExecuted: result.toolsExecuted });
             this.emit('phase:execute', { toolsExecuted: result.toolsExecuted });
             // Check for workflow triggers
             const workflowMatch = message.match(/^\/(run|workflow)\s+(\w+)/i);
@@ -190,7 +191,7 @@ class AgentOrchestrator extends events_1.EventEmitter {
             // ─────────────────────────────────────────
             // PHASE 5: RESPOND
             // ─────────────────────────────────────────
-            console.log('[Orchestrator] Phase 5: RESPOND');
+            (0, debug_1.debugPhase)(5, 'RESPOND', null);
             this.emit('phase:respond', { response: result.response });
             // Store assistant response in session
             await this.sessionStore.appendMessage(sessionId, {

package/dist/agent/toolExecutor.js

@@ -94,6 +94,46 @@ function parseToolCalls(text) {
             }
         }
     }
+    // Pattern 4: Raw JSON tool calls (no code block) - common with Ollama
+    // Matches: {"tool": "name", "args": {...}}
+    if (calls.length === 0) {
+        const rawJsonRegex = /\{"(?:tool|function|name)"\s*:\s*"([^"]+)"[^}]*\}/g;
+        let rawMatch;
+        while ((rawMatch = rawJsonRegex.exec(text)) !== null) {
+            try {
+                // Try to parse the full JSON object
+                const startIdx = rawMatch.index;
+                let braceCount = 0;
+                let endIdx = startIdx;
+                for (let i = startIdx; i < text.length; i++) {
+                    if (text[i] === '{')
+                        braceCount++;
+                    if (text[i] === '}')
+                        braceCount--;
+                    if (braceCount === 0) {
+                        endIdx = i + 1;
+                        break;
+                    }
+                }
+                const jsonStr = text.slice(startIdx, endIdx);
+                const parsed = JSON.parse(jsonStr);
+                if (parsed.tool || parsed.function || parsed.name) {
+                    const toolName = parsed.tool || parsed.function || parsed.name;
+                    // Only add if it's a registered tool
+                    if (tools_1.toolRegistry.has(toolName)) {
+                        calls.push({
+                            name: toolName,
+                            arguments: parsed.args || parsed.arguments || parsed.parameters || {},
+                        });
+                        console.log(`[ToolExecutor] Parsed raw JSON tool call: ${toolName}`);
+                    }
+                }
+            }
+            catch (e) {
+                // Failed to parse, try next match
+            }
+        }
+    }
     if (calls.length > 0) {
         console.log(`[ToolExecutor] Found ${calls.length} tool call(s): ${calls.map(c => c.name).join(', ')}`);
     }
@@ -140,47 +180,48 @@ function getToolsSystemPrompt() {
         return '';
     }
     const toolDescriptions = tools.map(t => {
-        const params = t.parameters.map(p => `  - ${p.name} (${p.type}${p.required ? ', required' : ''}): ${p.description}`).join('\n');
-        return `- **${t.name}**: ${t.description}`;
+        const params = t.parameters.map(p => `    - ${p.name} (${p.type}${p.required ? ', required' : ''}): ${p.description}`).join('\n');
+        return `- **${t.name}**: ${t.description}\n  Parameters:\n${params}`;
     }).join('\n');
+    const toolNames = tools.map(t => t.name).join(', ');
     return `
-## TOOLS - IMPORTANT!
+## TOOLS - CRITICAL INSTRUCTIONS
 
-You have tools to interact with the real world. **USE THEM AUTOMATICALLY** when the user asks for something that requires them.
+You have access to specific tools listed below. Use them to perform real actions.
 
-**HOW TO USE A TOOL:**
-Include this EXACT format in your response (the system will execute it automatically):
+**⚠️ CRITICAL RULE:**
+You can ONLY use tools from this exact list: [${toolNames}]
+DO NOT invent, guess, or fabricate tool names. If a tool doesn't exist in the list, say "I don't have a tool for that" instead of making one up.
 
+**FORMAT (exact JSON required):**
 \`\`\`json
-{"tool": "tool_name", "args": {"param": "value"}}
+{"tool": "exact_tool_name_from_list", "args": {"param": "value"}}
 \`\`\`
 
-**WHEN TO USE TOOLS (do it automatically, don't ask!):**
-- "what's the weather" → use \`weather\` tool
-- "set a reminder" → use \`reminder_set\` tool  
-- "what time is it" → use \`datetime\` tool
-- "how much RAM" / system info → use \`system_info\` tool
-- "calculate X" / math → use \`math\` tool
-- "read file X" → use \`read_file\` tool
-- "run command X" → use \`shell\` tool
-- "search for X" → use \`web_search\` tool
-- "play music" / spotify → use \`spotify_*\` tools
-- "create playlist" → use \`spotify_create_playlist\` tool
-- "my notes" / obsidian → use \`obsidian_*\` tools
+**WHEN TO USE TOOLS (do it automatically):**
+- Weather request → use \`weather\`
+- Time/date → use \`datetime\`
+- Math → use \`math\`
+- System info → use \`system_info\`
+- Set reminder → use \`reminder_set\`
+- Spotify controls → use \`spotify_*\` (only if listed)
+- Notes/Obsidian → use \`obsidian_*\` (only if listed)
+- Web search → use \`search\` or \`web_search\`
+- Shell commands → use \`shell\`
+- Read/write files → use \`read_file\`, \`write_file\`
 
-**AVAILABLE TOOLS:**
+**AVAILABLE TOOLS (ONLY these exist):**
 ${toolDescriptions}
 
 **RULES:**
-1. ALWAYS use a tool when the user's request matches a tool's capability
-2. Do NOT explain how to use tools - just USE them
-3. Do NOT show code examples - execute the tool directly
-4. After tool execution, summarize the result in natural language
-5. If a tool fails, explain why and suggest alternatives
+1. ✅ USE tools from the above list automatically
+2. ❌ NEVER invent tool names that aren't listed
+3. ❌ NEVER show code examples - execute tools directly
+4. If tool doesn't exist, say "I don't have that capability" 
+5. After execution, explain results in natural language
 
 **EXAMPLE:**
 User: "What's the weather in Tokyo?"
-Your response should include:
 \`\`\`json
 {"tool": "weather", "args": {"location": "Tokyo"}}
 \`\`\`

package/dist/channels/telegram.js

@@ -5,6 +5,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TelegramChannel = void 0;
 const grammy_1 = require("grammy");
+const transformer_throttler_1 = require("@grammyjs/transformer-throttler");
 const eventBus_1 = require("../core/eventBus");
 class TelegramChannel {
     name = 'telegram';
@@ -19,6 +20,8 @@ class TelegramChannel {
             ...config,
         };
         this.bot = new grammy_1.Bot(config.botToken);
+        // Apply rate limiting (Moltbot-style)
+        this.bot.api.config.use((0, transformer_throttler_1.apiThrottler)());
         this.setupHandlers();
     }
     setupHandlers() {
@@ -33,6 +36,13 @@ class TelegramChannel {
             const chatId = ctx.chat.id;
             const isGroup = ctx.chat.type === 'group' || ctx.chat.type === 'supergroup';
             const text = ctx.message.text;
+            // Send typing indicator immediately (Moltbot-style)
+            try {
+                await ctx.replyWithChatAction('typing');
+            }
+            catch (e) {
+                // Ignore typing errors
+            }
             // Skip slash commands - they are handled by bot.command()
             if (text.startsWith('/')) {
                 return;

package/dist/cli/chat.js

@@ -81,16 +81,13 @@ const FOX_THINKING = `${colors.orange}
   ${colors.orange} / - \\${colors.reset}
 `;
 const BANNER = `
-${colors.rust}╔═══════════════════════════════════════════════════════════╗${colors.reset}
-${colors.rust}║${colors.reset}  ${colors.orange}█████╗ ██████╗ ███████╗██╗  ██╗${colors.amber}  ██████╗  ██████╗ ████████╗${colors.reset}  ${colors.rust}║${colors.reset}
-${colors.rust}║${colors.reset}  ${colors.orange}██╔══██╗██╔══██╗██╔════╝╚██╗██╔╝${colors.amber}  ██╔══██╗██╔═══██╗╚══██╔══╝${colors.reset}  ${colors.rust}║${colors.reset}
-${colors.rust}║${colors.reset}  ${colors.orange}███████║██████╔╝█████╗   ╚███╔╝${colors.amber}  ██████╔╝██║   ██║   ██║${colors.reset}     ${colors.rust}║${colors.reset}
-${colors.rust}║${colors.reset}  ${colors.orange}██╔══██║██╔═══╝ ██╔══╝   ██╔██╗${colors.amber}  ██╔══██╗██║   ██║   ██║${colors.reset}     ${colors.rust}║${colors.reset}
-${colors.rust}║${colors.reset}  ${colors.orange}██║  ██║██║     ███████╗██╔╝ ██╗${colors.amber} ██████╔╝╚██████╔╝   ██║${colors.reset}     ${colors.rust}║${colors.reset}
-${colors.rust}║${colors.reset}  ${colors.orange}╚═╝  ╚═╝╚═╝     ╚══════╝╚═╝  ╚═╝${colors.amber} ╚═════╝  ╚═════╝    ╚═╝${colors.reset}     ${colors.rust}║${colors.reset}
-${colors.rust}╠═══════════════════════════════════════════════════════════╣${colors.reset}
-${colors.rust}║${colors.reset}  ${colors.gold}🦊 Free • Private • Local-First AI${colors.reset}          ${colors.gray}v2026.1${colors.reset}  ${colors.rust}║${colors.reset}
-${colors.rust}╚═══════════════════════════════════════════════════════════╝${colors.reset}
+${colors.orange}${colors.bold}     _    ____  _______  ______   ___ _____${colors.reset}
+${colors.orange}${colors.bold}    / \\  |  _ \\| ____\\ \\/ / __ ) / _ \\_   _|${colors.reset}
+${colors.amber}${colors.bold}   / _ \\ | |_) |  _|  \\  /|  _ \\| | | || |${colors.reset}
+${colors.amber}${colors.bold}  / ___ \\|  __/| |___ /  \\| |_) | |_| || |${colors.reset}
+${colors.rust}${colors.bold} /_/   \\_\\_|   |_____/_/\\_\\____/ \\___/ |_|${colors.reset}
+
+${colors.gold}🦊 Free • Private • Local-First AI${colors.reset} ${colors.gray}v2026.1${colors.reset}
 `;
 const SPINNER_FRAMES = ['🦊', '🔥', '✨', '💫', '⭐', '🌟', '✨', '🔥'];
 /**
@@ -270,6 +267,27 @@ ${colors.orange}${colors.bold}Input Prefixes${colors.reset}                 ${co
             case 'tools':
                 this.emit('command:tools');
                 break;
+            case 'model':
+                if (args[0]) {
+                    this.emit('command:model', args[0]);
+                    console.log(`${colors.green}✓ Model changed to: ${colors.gold}${args[0]}${colors.reset}`);
+                }
+                else {
+                    this.emit('command:model:show');
+                }
+                break;
+            case 'provider':
+                if (args[0]) {
+                    this.emit('command:provider', args[0]);
+                    console.log(`${colors.green}✓ Provider changed to: ${colors.gold}${args[0]}${colors.reset}`);
+                }
+                else {
+                    console.log(`${colors.amber}Usage: /provider <ollama|google|anthropic|openai|kimi>${colors.reset}`);
+                }
+                break;
+            case 'config':
+                this.emit('command:config');
+                break;
             case 'exit':
             case 'quit':
             case 'bye':
@@ -285,15 +303,19 @@ ${colors.orange}${colors.bold}Input Prefixes${colors.reset}                 ${co
 ${colors.orange}${colors.bold}🦊 ApexBot Commands${colors.reset}
 ${colors.gray}${'─'.repeat(40)}${colors.reset}
 
-  ${colors.orange}/help${colors.reset}      Show this help
-  ${colors.orange}/clear${colors.reset}     Clear screen
-  ${colors.orange}/reset${colors.reset}     Reset conversation
-  ${colors.orange}/history${colors.reset}   Show recent messages
-  ${colors.orange}/status${colors.reset}    Show bot status
-  ${colors.orange}/skills${colors.reset}    List enabled skills
-  ${colors.orange}/tools${colors.reset}     List available tools
-  ${colors.orange}/fox${colors.reset}       Show fox mascot 🦊
-  ${colors.orange}/exit${colors.reset}      Exit ApexBot
+  ${colors.orange}/help${colors.reset}        Show this help
+  ${colors.orange}/clear${colors.reset}       Clear screen
+  ${colors.orange}/reset${colors.reset}       Reset conversation
+  ${colors.orange}/history${colors.reset}     Show recent messages
+  ${colors.orange}/status${colors.reset}      Show bot status
+  ${colors.orange}/skills${colors.reset}      List enabled skills
+  ${colors.orange}/tools${colors.reset}       List available tools
+  ${colors.orange}/model${colors.reset}       Show/change model
+  ${colors.orange}/model${colors.reset} ${colors.gray}<name>${colors.reset}  Change to specified model
+  ${colors.orange}/provider${colors.reset}    Change AI provider
+  ${colors.orange}/config${colors.reset}      Show configuration
+  ${colors.orange}/fox${colors.reset}         Show fox mascot 🦊
+  ${colors.orange}/exit${colors.reset}        Exit ApexBot
 
 ${colors.gray}Shortcuts: Ctrl+C (exit), Ctrl+L (clear), ↑↓ (history)${colors.reset}
         `);

package/dist/cli/index.js

@@ -1105,6 +1105,43 @@ program
         const status = await orchestrator.getStatus();
         console.log(`  Files: ${status.brain?.files?.join(', ') || 'none'}`);
     });
+    // Model/provider/config commands
+    chat.on('command:model', (model) => {
+        const cfg = loadConfig();
+        cfg.agent = cfg.agent || {};
+        cfg.agent.model = model;
+        saveConfig(cfg);
+        console.log(chalk.green(`  Model configured: ${model}`));
+    });
+    chat.on('command:model:show', () => {
+        const cfg = loadConfig();
+        const currentModel = cfg.agent?.model || 'llama3.2:latest';
+        const provider = cfg.agent?.provider || 'ollama';
+        console.log(`\n  ${chalk.yellow('Current Model:')} ${chalk.cyan(currentModel)}`);
+        console.log(`  ${chalk.yellow('Provider:')} ${chalk.cyan(provider)}`);
+        console.log(`\n  ${chalk.gray('Usage: /model <name>  (e.g. /model gemma2:9b)')}`);
+    });
+    chat.on('command:provider', (provider) => {
+        const validProviders = ['ollama', 'google', 'anthropic', 'openai', 'kimi'];
+        if (!validProviders.includes(provider.toLowerCase())) {
+            console.log(chalk.red(`  Invalid provider. Use: ${validProviders.join(', ')}`));
+            return;
+        }
+        const cfg = loadConfig();
+        cfg.agent = cfg.agent || {};
+        cfg.agent.provider = provider.toLowerCase();
+        saveConfig(cfg);
+        console.log(chalk.green(`  Provider configured: ${provider}`));
+    });
+    chat.on('command:config', () => {
+        const cfg = loadConfig();
+        console.log(`\n  ${chalk.yellow('Current Configuration:')}`);
+        console.log(`  ${chalk.gray('─'.repeat(30))}`);
+        console.log(`  Provider: ${chalk.cyan(cfg.agent?.provider || 'ollama')}`);
+        console.log(`  Model: ${chalk.cyan(cfg.agent?.model || 'llama3.2:latest')}`);
+        console.log(`  API URL: ${chalk.cyan(cfg.agent?.apiUrl || 'http://localhost:11434')}`);
+        console.log(`\n  ${chalk.gray(`Config file: ${CONFIG_FILE}`)}`);
+    });
     // Start chat
     await chat.start();
 });