apexbot 1.0.5 → 1.0.6

package/dist/agent/agentManager.js

@@ -12,26 +12,34 @@ const toolExecutor_1 = require("./toolExecutor");
 class AgentManager {
     config = null;
     googleClient = null;
-    defaultSystemPrompt = `You are ApexBot, a helpful AI assistant running locally via Ollama. You are 100% free, private, and self-hosted.
+    defaultSystemPrompt = `You are ApexBot, an autonomous AI assistant like Claude Code. You can execute real actions on the user's computer.
 
-Your goal is to act as a fully autonomous agent, not just a chatbot. Follow these principles:
+## CORE PRINCIPLES
+1. **ACT, DON'T EXPLAIN** - When user asks for something, DO IT using tools. Don't explain how to do it.
+2. **BE AUTONOMOUS** - Make decisions and execute actions automatically
+3. **BE HELPFUL** - Provide direct answers and results, not tutorials
 
-1. **EXPLORE:** Analyze code and context thoroughly before responding.
-2. **PLAN:** Outline a clear plan before implementing changes.
-3. **ACT:** Provide complete, working code without placeholders like "// ... rest of code".
-4. **VERIFY:** Test your suggestions mentally and point out edge cases.
+## CAPABILITIES
+- Execute shell commands
+- Read/write/edit files
+- Get weather forecasts
+- Set reminders and timers
+- Control Spotify playback
+- Manage Obsidian notes
+- Search the web
+- Do math calculations
+- Get system information
 
-CODING STANDARDS:
-- TypeScript / Node.js with strict typing
-- Modular, clean, modern ES6+ syntax
-- Explicit error handling
-- Safety first for financial/crypto logic (arbitrage, Kelly criterion)
+## RESPONSE STYLE
+- Be concise and direct
+- Show results, not code tutorials
+- Use natural language to explain results
+- If something fails, explain why simply
 
-INTERACTION STYLE:
-- Be direct and actionable
-- Proactively identify issues and offer fixes
-- Keep responses concise but complete
-- Start with context analysis when working with code
+## LANGUAGE
+- Respond in the same language as the user
+- If user writes in Polish, respond in Polish
+- If user writes in English, respond in English
 
 You are running locally on the user's machine. No data leaves their computer. You are free, private, and open-source.`;
     constructor(config) {
@@ -103,12 +111,18 @@ You are running locally on the user's machine. No data leaves their computer. Yo
             if (this.config.enableTools) {
                 const toolCalls = (0, toolExecutor_1.parseToolCalls)(response.text);
                 if (toolCalls.length > 0) {
-                    console.log(`[Agent] Found ${toolCalls.length} tool calls`);
+                    console.log(`[Agent] Found ${toolCalls.length} tool calls:`, toolCalls.map(t => t.name));
                     // Build tool context
-                    const context = (0, toolExecutor_1.buildToolContext)(session.id, message.userId || 'unknown', message.channel, { workspaceDir: process.cwd() });
+                    const context = (0, toolExecutor_1.buildToolContext)(session.id, message.userId || message.from || 'unknown', message.channel, { workspaceDir: process.cwd() });
                     // Execute tools
                     const toolResults = await (0, toolExecutor_1.executeToolCalls)(toolCalls, context);
                     response.toolCalls = toolResults;
+                    // Log results
+                    for (const { call, result } of toolResults) {
+                        console.log(`[Agent] Tool ${call.name}: ${result.success ? 'SUCCESS' : 'FAILED'}`);
+                        if (!result.success)
+                            console.log(`[Agent] Error: ${result.error}`);
+                    }
                     // Format results and continue conversation
                     const resultsText = (0, toolExecutor_1.formatToolResults)(toolResults);
                     if (resultsText) {
@@ -116,7 +130,7 @@ You are running locally on the user's machine. No data leaves their computer. Yo
                         const followUpHistory = [
                             ...history,
                             { role: 'assistant', content: response.text, timestamp: Date.now() },
-                            { role: 'user', content: `Tool results:\n${resultsText}\n\nPlease continue based on these results.`, timestamp: Date.now() },
+                            { role: 'user', content: `[TOOL EXECUTION COMPLETE]\n\nResults:\n${resultsText}\n\nNow provide a natural language response to the user summarizing these results. Be concise. Respond in the same language as the user's original message.`, timestamp: Date.now() },
                         ];
                         // Get follow-up response
                         let followUp;
@@ -127,11 +141,21 @@ You are running locally on the user's machine. No data leaves their computer. Yo
                             case 'google':
                                 followUp = await this.processWithGemini(followUpHistory);
                                 break;
+                            case 'anthropic':
+                                followUp = await this.processWithClaude(followUpHistory);
+                                break;
+                            case 'openai':
+                                followUp = await this.processWithOpenAI(followUpHistory);
+                                break;
+                            case 'kimi':
+                                followUp = await this.processWithKimi(followUpHistory);
+                                break;
                             default:
-                                followUp = { text: resultsText };
+                                // Fallback: return formatted results directly
+                                followUp = { text: this.formatResultsForUser(toolResults) };
                         }
-                        // Combine responses
-                        response.text = followUp.text;
+                        // Use follow-up response (or fallback to formatted results)
+                        response.text = followUp.text || this.formatResultsForUser(toolResults);
                     }
                 }
             }
@@ -149,6 +173,65 @@ You are running locally on the user's machine. No data leaves their computer. Yo
             return { text: `Error: ${errorMsg}` };
         }
     }
+    /**
+     * Format tool results for direct user display (fallback when AI can't summarize)
+     */
+    formatResultsForUser(toolResults) {
+        const parts = [];
+        for (const { call, result } of toolResults) {
+            if (result.success) {
+                const data = result.data;
+                // Format based on tool type
+                if (call.name === 'weather' && data) {
+                    parts.push(`Weather in ${data.location}: ${data.current?.temperature}°C, ${data.current?.condition}`);
+                }
+                else if (call.name === 'datetime' && data) {
+                    parts.push(`Current time: ${data.formatted || data.time}`);
+                }
+                else if (call.name === 'math' && data) {
+                    parts.push(`Result: ${data.result}`);
+                }
+                else if (call.name === 'system_info' && data) {
+                    if (data.memory) {
+                        parts.push(`RAM: ${data.memory.used} / ${data.memory.total} (${data.memory.usage} used)`);
+                    }
+                    if (data.cpu) {
+                        parts.push(`CPU: ${data.cpu.model} (${data.cpu.cores} cores)`);
+                    }
+                }
+                else if (call.name.startsWith('reminder') && data) {
+                    parts.push(data.message || `Reminder ${data.action || 'set'}`);
+                }
+                else if (call.name.startsWith('spotify') && data) {
+                    if (data.track)
+                        parts.push(`Now playing: ${data.track} by ${data.artist}`);
+                    else if (data.message)
+                        parts.push(data.message);
+                    else if (data.action)
+                        parts.push(`Spotify: ${data.action}`);
+                }
+                else if (data) {
+                    // Generic formatting
+                    if (typeof data === 'string') {
+                        parts.push(data);
+                    }
+                    else if (data.message) {
+                        parts.push(data.message);
+                    }
+                    else if (data.result) {
+                        parts.push(String(data.result));
+                    }
+                    else if (data.output) {
+                        parts.push(data.output);
+                    }
+                }
+            }
+            else {
+                parts.push(`Error (${call.name}): ${result.error}`);
+            }
+        }
+        return parts.join('\n') || 'Done.';
+    }
     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

package/dist/agent/toolExecutor.js

@@ -114,20 +114,49 @@ function getToolsSystemPrompt() {
     }
     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}\nParameters:\n${params}`;
-    }).join('\n\n');
+        return `- **${t.name}**: ${t.description}`;
+    }).join('\n');
     return `
-You have access to the following tools. To use a tool, include a JSON block in your response:
+## TOOLS - IMPORTANT!
+
+You have tools to interact with the real world. **USE THEM AUTOMATICALLY** when the user asks for something that requires them.
+
+**HOW TO USE A TOOL:**
+Include this EXACT format in your response (the system will execute it automatically):
 
 \`\`\`json
-{"tool": "tool_name", "args": {"param1": "value1"}}
+{"tool": "tool_name", "args": {"param": "value"}}
 \`\`\`
 
-Available tools:
+**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
 
+**AVAILABLE TOOLS:**
 ${toolDescriptions}
 
-After I execute the tool, I'll show you the result so you can incorporate it into your response.
+**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
+
+**EXAMPLE:**
+User: "What's the weather in Tokyo?"
+Your response should include:
+\`\`\`json
+{"tool": "weather", "args": {"location": "Tokyo"}}
+\`\`\`
 `;
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apexbot",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "ApexBot - Your free, private AI assistant. 100% free with Ollama (local AI). Multi-channel: Telegram, Discord, WebChat. Tools & Skills system with Spotify, Obsidian, and more!",
   "main": "dist/index.js",
   "bin": {