aiexecode 1.0.94 → 1.0.96

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) => {