aiexecode 1.0.94 → 1.0.127

package/payload_viewer/web_server.js

@@ -3,6 +3,7 @@ import path from 'path';
 import fs from 'fs';
 import { fileURLToPath } from 'url';
 import OpenAI from 'openai';
+import Anthropic from '@anthropic-ai/sdk';
 function consolelog() { }
 
 const __filename = fileURLToPath(import.meta.url);
@@ -48,6 +49,46 @@ if (openaiApiKey) {
     consolelog('   Checked: process.env.OPENAI_API_KEY and ~/.aiexe/settings.json');
 }
 
+// Initialize Z.AI client (Anthropic SDK with Z.AI base URL)
+let zaiClient = null;
+const zaiApiKey = process.env.ZAI_API_KEY || aiAgentSettings.API_KEY;
+const ZAI_BASE_URL = 'https://api.z.ai/api/anthropic';
+
+// Check if API key is Z.AI format (32-char hex + '.' + 16-char alphanumeric)
+function isZaiApiKey(apiKey) {
+    if (!apiKey || typeof apiKey !== 'string') return false;
+    return /^[a-f0-9]{32}\.[A-Za-z0-9]{16}$/.test(apiKey);
+}
+
+if (zaiApiKey && isZaiApiKey(zaiApiKey)) {
+    zaiClient = new Anthropic({
+        apiKey: zaiApiKey,
+        baseURL: ZAI_BASE_URL,
+    });
+    consolelog('✅ Z.AI client initialized (Anthropic SDK with Z.AI base URL)');
+} else {
+    consolelog('⚠️  Z.AI API key not found or invalid format - Z.AI testing will return mock responses');
+}
+
+// Initialize Anthropic client
+let anthropicClient = null;
+const anthropicApiKey = process.env.ANTHROPIC_API_KEY || aiAgentSettings.ANTHROPIC_API_KEY;
+
+// Check if API key is Anthropic format (sk-ant-...)
+function isAnthropicApiKey(apiKey) {
+    if (!apiKey || typeof apiKey !== 'string') return false;
+    return apiKey.startsWith('sk-ant-');
+}
+
+if (anthropicApiKey && isAnthropicApiKey(anthropicApiKey)) {
+    anthropicClient = new Anthropic({
+        apiKey: anthropicApiKey,
+    });
+    consolelog('✅ Anthropic client initialized');
+} else {
+    consolelog('⚠️  Anthropic API key not found or invalid format - Anthropic testing will return mock responses');
+}
+
 
 // ID generation function
 function generateId() {
@@ -420,6 +461,326 @@ function startWebServer(port = 3300) {
         }
     });
 
+    // Anthropic API test endpoint
+    app.post('/api/test-anthropic', async (req, res) => {
+        try {
+            const payload = req.body;
+
+            if (anthropicClient && anthropicApiKey && isAnthropicApiKey(anthropicApiKey)) {
+                // Convert Responses API format to Anthropic Messages API format if needed
+                let anthropicPayload = { ...payload };
+
+                // If payload uses Responses API format (input array), convert to messages
+                if (payload.input && Array.isArray(payload.input)) {
+                    const messages = [];
+                    let systemMessage = null;
+
+                    for (const item of payload.input) {
+                        if (item.role === 'system') {
+                            if (Array.isArray(item.content)) {
+                                systemMessage = item.content.map(c => c.text || c).join('\n');
+                            } else if (typeof item.content === 'string') {
+                                systemMessage = item.content;
+                            }
+                        } else if (item.role === 'user' || item.role === 'assistant') {
+                            let content;
+                            if (Array.isArray(item.content)) {
+                                content = item.content.map(c => ({
+                                    type: 'text',
+                                    text: c.text || c
+                                }));
+                            } else {
+                                content = [{ type: 'text', text: item.content || '' }];
+                            }
+                            messages.push({ role: item.role, content });
+                        }
+                    }
+
+                    anthropicPayload = {
+                        model: payload.model || 'claude-3-haiku-20240307',
+                        max_tokens: payload.max_output_tokens || payload.max_tokens || 4096,
+                        messages: messages,
+                    };
+
+                    if (systemMessage) {
+                        anthropicPayload.system = systemMessage;
+                    }
+                }
+
+                // Ensure required fields
+                if (!anthropicPayload.model) anthropicPayload.model = 'claude-3-haiku-20240307';
+                if (!anthropicPayload.max_tokens) anthropicPayload.max_tokens = 4096;
+
+                // Make the API call
+                const response = await anthropicClient.messages.create(anthropicPayload);
+
+                // Convert Anthropic response to Responses API format
+                const output = [];
+                let outputText = '';
+
+                if (response.content && Array.isArray(response.content)) {
+                    for (const block of response.content) {
+                        if (block.type === 'text') {
+                            outputText += block.text;
+                        } else if (block.type === 'tool_use') {
+                            output.push({
+                                type: 'function_call',
+                                id: block.id,
+                                call_id: block.id,
+                                name: block.name,
+                                arguments: JSON.stringify(block.input)
+                            });
+                        }
+                    }
+                }
+
+                if (outputText) {
+                    output.unshift({
+                        type: 'message',
+                        id: `msg_${generateId()}`,
+                        status: 'completed',
+                        role: 'assistant',
+                        content: [{
+                            type: 'output_text',
+                            text: outputText
+                        }]
+                    });
+                }
+
+                const convertedResponse = {
+                    id: response.id,
+                    object: 'response',
+                    created_at: Math.floor(Date.now() / 1000),
+                    status: response.stop_reason === 'end_turn' ? 'completed' : 'incomplete',
+                    model: response.model,
+                    provider: 'anthropic',
+                    output: output,
+                    usage: {
+                        input_tokens: response.usage?.input_tokens || 0,
+                        output_tokens: response.usage?.output_tokens || 0,
+                        total_tokens: (response.usage?.input_tokens || 0) + (response.usage?.output_tokens || 0),
+                        cache_creation_input_tokens: response.usage?.cache_creation_input_tokens,
+                        cache_read_input_tokens: response.usage?.cache_read_input_tokens
+                    },
+                    stop_reason: response.stop_reason
+                };
+
+                res.json({
+                    success: true,
+                    provider: 'anthropic',
+                    status: 200,
+                    data: convertedResponse,
+                    originalPayload: payload,
+                    convertedPayload: anthropicPayload,
+                    rawResponse: response
+                });
+            } else {
+                // Mock response when API key is not available
+                res.json({
+                    success: false,
+                    provider: 'anthropic',
+                    error: 'Anthropic API key not found or invalid format',
+                    hint: 'Anthropic API key format: sk-ant-...',
+                    mockResponse: {
+                        taskName: "api_test_RES",
+                        timestamp: new Date().toISOString(),
+                        data: {
+                            id: `resp_${generateId()}`,
+                            object: "response",
+                            created_at: Math.floor(Date.now() / 1000),
+                            status: "completed",
+                            model: payload.model || 'claude-3-haiku-20240307',
+                            provider: 'anthropic',
+                            output: [{
+                                id: `msg_${generateId()}`,
+                                type: "message",
+                                status: "completed",
+                                content: [{
+                                    type: "output_text",
+                                    text: 'This is a mock response. Set a valid Anthropic API key to get real responses.'
+                                }],
+                                role: "assistant"
+                            }],
+                            usage: {
+                                input_tokens: 10,
+                                output_tokens: 15,
+                                total_tokens: 25
+                            }
+                        }
+                    },
+                    originalPayload: payload
+                });
+            }
+        } catch (error) {
+            res.status(500).json({
+                success: false,
+                provider: 'anthropic',
+                error: error.message,
+                originalPayload: req.body
+            });
+        }
+    });
+
+    // Z.AI (GLM) API test endpoint - Uses Anthropic SDK with Z.AI base URL
+    app.post('/api/test-zai', async (req, res) => {
+        try {
+            const payload = req.body;
+
+            if (zaiClient && zaiApiKey && isZaiApiKey(zaiApiKey)) {
+                // Convert Responses API format to Anthropic Messages API format if needed
+                let zaiPayload = { ...payload };
+
+                // If payload uses Responses API format (input array), convert to messages
+                if (payload.input && Array.isArray(payload.input)) {
+                    const messages = [];
+                    let systemMessage = null;
+
+                    for (const item of payload.input) {
+                        if (item.role === 'system') {
+                            // Extract system message content
+                            if (Array.isArray(item.content)) {
+                                systemMessage = item.content.map(c => c.text || c).join('\n');
+                            } else if (typeof item.content === 'string') {
+                                systemMessage = item.content;
+                            }
+                        } else if (item.role === 'user' || item.role === 'assistant') {
+                            let content;
+                            if (Array.isArray(item.content)) {
+                                content = item.content.map(c => ({
+                                    type: 'text',
+                                    text: c.text || c
+                                }));
+                            } else {
+                                content = [{ type: 'text', text: item.content || '' }];
+                            }
+                            messages.push({ role: item.role, content });
+                        }
+                    }
+
+                    zaiPayload = {
+                        model: payload.model || 'glm-4.5',
+                        max_tokens: payload.max_output_tokens || payload.max_tokens || 8192,
+                        messages: messages,
+                    };
+
+                    if (systemMessage) {
+                        zaiPayload.system = systemMessage;
+                    }
+                }
+
+                // Ensure required fields
+                if (!zaiPayload.model) zaiPayload.model = 'glm-4.5';
+                if (!zaiPayload.max_tokens) zaiPayload.max_tokens = 8192;
+
+                // Make the API call
+                const response = await zaiClient.messages.create(zaiPayload);
+
+                // Convert Anthropic response to Responses API format
+                const output = [];
+                let outputText = '';
+
+                if (response.content && Array.isArray(response.content)) {
+                    for (const block of response.content) {
+                        if (block.type === 'text') {
+                            outputText += block.text;
+                        } else if (block.type === 'tool_use') {
+                            output.push({
+                                type: 'function_call',
+                                id: block.id,
+                                call_id: block.id,
+                                name: block.name,
+                                arguments: JSON.stringify(block.input)
+                            });
+                        }
+                    }
+                }
+
+                if (outputText) {
+                    output.unshift({
+                        type: 'message',
+                        id: `msg_${generateId()}`,
+                        status: 'completed',
+                        role: 'assistant',
+                        content: [{
+                            type: 'output_text',
+                            text: outputText
+                        }]
+                    });
+                }
+
+                const convertedResponse = {
+                    id: response.id,
+                    object: 'response',
+                    created_at: Math.floor(Date.now() / 1000),
+                    status: response.stop_reason === 'end_turn' ? 'completed' : 'incomplete',
+                    model: response.model,
+                    provider: 'zai',
+                    output: output,
+                    usage: {
+                        input_tokens: response.usage?.input_tokens || 0,
+                        output_tokens: response.usage?.output_tokens || 0,
+                        total_tokens: (response.usage?.input_tokens || 0) + (response.usage?.output_tokens || 0),
+                        cache_creation_input_tokens: response.usage?.cache_creation_input_tokens,
+                        cache_read_input_tokens: response.usage?.cache_read_input_tokens
+                    },
+                    stop_reason: response.stop_reason
+                };
+
+                res.json({
+                    success: true,
+                    provider: 'zai',
+                    status: 200,
+                    data: convertedResponse,
+                    originalPayload: payload,
+                    convertedPayload: zaiPayload,
+                    rawResponse: response
+                });
+            } else {
+                // Mock response when API key is not available
+                res.json({
+                    success: false,
+                    provider: 'zai',
+                    error: 'Z.AI API key not found or invalid format',
+                    hint: 'Z.AI API key format: 32-char hex + "." + 16-char alphanumeric',
+                    mockResponse: {
+                        taskName: "api_test_RES",
+                        timestamp: new Date().toISOString(),
+                        data: {
+                            id: `resp_${generateId()}`,
+                            object: "response",
+                            created_at: Math.floor(Date.now() / 1000),
+                            status: "completed",
+                            model: payload.model || 'glm-4.5',
+                            provider: 'zai',
+                            output: [{
+                                id: `msg_${generateId()}`,
+                                type: "message",
+                                status: "completed",
+                                content: [{
+                                    type: "output_text",
+                                    text: 'This is a mock response. Set a valid Z.AI API key to get real responses.'
+                                }],
+                                role: "assistant"
+                            }],
+                            usage: {
+                                input_tokens: 10,
+                                output_tokens: 15,
+                                total_tokens: 25
+                            }
+                        }
+                    },
+                    originalPayload: payload
+                });
+            }
+        } catch (error) {
+            res.status(500).json({
+                success: false,
+                provider: 'zai',
+                error: error.message,
+                originalPayload: req.body
+            });
+        }
+    });
 
     // Health check endpoint
     app.get('/api/health', (req, res) => {

package/prompts/completion_judge.txt

@@ -15,6 +15,7 @@ You have access to the full conversation history between the orchestrator and th
 **CORE PRINCIPLE**: Focus STRICTLY on whether the ESSENTIAL requirements requested by the user have been fulfilled. The agent should NEVER perform optional enhancements beyond the user's explicit request.
 
 ### Mission is COMPLETE (should_complete: true) when:
+- **The request cannot be fulfilled as stated**: The assistant clearly explains that the literal request is impossible and why. Do NOT continue pursuing an unfulfillable goal.
 - **All essential requirements from the user's original request have been satisfied**
 - The assistant explicitly states the task is finished/complete/done
 - The assistant provides final results or deliverables that satisfy the original mission's core requirements
@@ -31,6 +32,9 @@ You have access to the full conversation history between the orchestrator and th
 - The assistant's message is incomplete or cut off
 - The message is just status updates without clear completion signals
 - **There are mandatory next steps required to fulfill the user's core request**
+- **The assistant is seeking permission, confirmation, or approval before taking action**
+- **The assistant offers to do something rather than just doing it** (e.g., "Would you like me to...", "Should I...", "Do you want me to...", "Can I...")
+- **The assistant's response implies waiting for user decision before proceeding with work**
 
 ### Key Distinction:
 - **Essential Requirements**: ONLY the core functionality, features, or fixes explicitly requested by the user

package/prompts/orchestrator.txt

@@ -47,6 +47,21 @@ NEVER ASK USER:
 - Permission to continue
 - Technical decisions
 
+# Understanding request feasibility
+
+Before attempting any action, assess whether the request is actually achievable:
+
+1. **Literal interpretation first**: Understand what the user literally asked for
+2. **Feasibility check**: Can this request actually be fulfilled as stated?
+3. **No silent reinterpretation**: If the literal request is impossible, do NOT silently substitute it with something "related" or "similar"
+
+When a request cannot be fulfilled as stated:
+- Clearly explain why it cannot be done
+- Ask for clarification or suggest what you CAN do
+- Do NOT attempt workarounds that don't address the actual request
+
+Principle: Honesty about limitations is more valuable than creative reinterpretation that misses the point.
+
 # Understanding user intent
 
 Distinguish between conversation and work:
@@ -379,7 +394,33 @@ Use for: Finding code by content, exploring codebases, locating specific impleme
 
 ### bash
 
-Purpose: Execute shell commands
+Purpose: Execute shell commands (for terminal operations ONLY)
+
+**CRITICAL - Use Specialized Tools Instead of Bash:**
+
+NEVER use bash for these operations - use the dedicated tools:
+
+| Operation | WRONG (bash) | CORRECT (dedicated tool) |
+|-----------|--------------|--------------------------|
+| Read files | `cat file.js` | `read_file({ filePath: "file.js" })` |
+| Read file sections | `head -100 file.js` | `read_file_range({ filePath, startLine, endLine })` |
+| Search content | `grep -r "pattern" .` | `ripgrep({ pattern: "pattern" })` |
+| Find files | `find . -name "*.js"` | `glob_search({ pattern: "**/*.js" })` |
+| Edit files | `sed -i 's/old/new/' file` | `edit_file_replace({ file_path, old_string, new_string })` |
+| Write files | `echo "content" > file` | `write_file({ file_path, content })` |
+
+**Why dedicated tools are mandatory:**
+- bash output is truncated to 8000 chars - long files get cut off
+- Dedicated tools have proper error handling and formatting
+- Dedicated tools integrate with file integrity tracking
+- Dedicated tools display results properly in UI
+
+**When to use bash:**
+- git commands: `git status`, `git commit`, `git push`
+- Package management: `npm install`, `pip install`
+- Running scripts: `npm test`, `python script.py`
+- Directory operations: `mkdir`, `rm -rf`, `mv`, `cp`
+- System commands: `chmod`, `chown`, `which`
 
 Usage notes:
 - Output limits: stdout 8000 chars, stderr 4000 chars
@@ -813,10 +854,43 @@ Match the user's language:
 
 ## Tool usage
 
-- Use specialized tools: glob_search and ripgrep, NOT bash find/grep
-- No file editing via bash: Never use sed, awk, echo > for file content
+**MANDATORY - Specialized Tools Over Bash:**
+
+This is NOT optional. You MUST use dedicated tools for these operations:
+
+| Task | NEVER Use | ALWAYS Use |
+|------|-----------|------------|
+| Read files | cat, head, tail, less | read_file, read_file_range |
+| Search content | grep, rg, ack | ripgrep |
+| Find files | find, ls -R, locate | glob_search |
+| Edit files | sed, awk, perl -i | edit_file_replace |
+| Create/write files | echo >, cat <<EOF | write_file |
+
+**Why this matters:**
+- bash output truncated at 8000 chars → long content gets lost
+- Dedicated tools have built-in limits and error handling
+- File integrity tracking only works with dedicated tools
+- Results display properly in UI with dedicated tools
+
+**Correct patterns:**
+```
+# Find files → glob_search
+glob_search({ pattern: "**/*.ts" })
+
+# Search content → ripgrep
+ripgrep({ pattern: "TODO", output_mode: "content", head_limit: 20 })
+
+# Read file → read_file
+read_file({ filePath: "src/index.js" })
+
+# Large file → read_file_range
+read_file_range({ filePath: "big.log", startLine: 1, endLine: 500 })
+```
+
+**Other tool usage rules:**
 - Auto-exclusions trusted: node_modules, .git, etc. are automatically excluded
 - Parallel when possible: Execute independent tool calls simultaneously
+- Check output limits: ripgrep has 30KB limit, read_file has 2000 line limit
 
 ## Error handling
 
@@ -827,6 +901,44 @@ When errors occur, handle them autonomously:
 - Fix immediately: Don't report errors - fix them and continue
 - Iterate as needed: If fix doesn't work, try alternative approaches
 
+## CRITICAL - Avoiding repetitive behavior
+
+**You MUST recognize and break out of repetitive patterns:**
+
+SELF-AWARENESS RULES:
+1. **Same action, same result = STOP**: If you execute the same command and get the same result twice, DO NOT try it a third time
+2. **Analyze before retrying**: When something fails, understand WHY before trying again
+3. **Change approach**: If an approach isn't working, try a fundamentally different strategy
+4. **Admit limitations**: If you cannot solve a problem after 2-3 different approaches, clearly tell the user
+
+FORBIDDEN PATTERNS:
+- Running the same bash command repeatedly hoping for different results
+- Re-reading the same file without making changes
+- Retrying the same edit that failed without fixing the root cause
+- Looping through identical tool calls
+
+REQUIRED BEHAVIOR:
+- After failure: STOP → ANALYZE root cause → TRY DIFFERENT approach
+- After 2 identical failures: STOP completely and inform user
+- When stuck: Clearly explain what you tried, why it failed, and ask for guidance
+
+EXAMPLE - WRONG:
+```
+bash("node test.js") → Error
+bash("node test.js") → Same error
+bash("node test.js") → Same error (FORBIDDEN - endless loop!)
+```
+
+EXAMPLE - CORRECT:
+```
+bash("node test.js") → Error: "module not found"
+STOP and ANALYZE: The error says module is not found
+read_file("test.js") → Check what module is being imported
+DIFFERENT APPROACH: Fix the import or install the module
+```
+
+**If you find yourself doing the same thing more than twice, you have FAILED to think properly. STOP and THINK.**
+
 # Response format
 
 ## Tool call structure
@@ -1092,3 +1204,4 @@ ASK USER:
 
 DECIDE YOURSELF:
 - All implementation details (HOW to implement)
+