@nordsym/apiclaw 1.3.12 → 1.3.13

package/dist/execute.js

@@ -4,6 +4,108 @@
 import { getCredentials } from './credentials.js';
 import { callProxy, PROXY_PROVIDERS } from './proxy.js';
 import { executeDynamicAction, hasDynamicConfig, listDynamicActions } from './execute-dynamic.js';
+// Error codes for structured error responses
+const ERROR_CODES = {
+    RATE_LIMITED: 'RATE_LIMITED',
+    SERVICE_UNAVAILABLE: 'SERVICE_UNAVAILABLE',
+    UNAUTHORIZED: 'UNAUTHORIZED',
+    FORBIDDEN: 'FORBIDDEN',
+    NOT_FOUND: 'NOT_FOUND',
+    BAD_REQUEST: 'BAD_REQUEST',
+    TIMEOUT: 'TIMEOUT',
+    NETWORK_ERROR: 'NETWORK_ERROR',
+    PROVIDER_ERROR: 'PROVIDER_ERROR',
+    INVALID_PARAMS: 'INVALID_PARAMS',
+    NO_CREDENTIALS: 'NO_CREDENTIALS',
+    UNKNOWN_PROVIDER: 'UNKNOWN_PROVIDER',
+    UNKNOWN_ACTION: 'UNKNOWN_ACTION',
+    MAX_RETRIES_EXCEEDED: 'MAX_RETRIES_EXCEEDED',
+};
+// Retry configuration
+const RETRY_CONFIG = {
+    maxRetries: 3,
+    baseDelayMs: 1000, // Start with 1 second
+    maxDelayMs: 30000, // Cap at 30 seconds
+    retryableStatusCodes: [429, 503, 502, 504], // Rate limit + service unavailable variants
+};
+/**
+ * Calculate exponential backoff delay with jitter
+ */
+function calculateBackoff(attempt) {
+    const exponentialDelay = RETRY_CONFIG.baseDelayMs * Math.pow(2, attempt);
+    const jitter = Math.random() * 0.3 * exponentialDelay; // 0-30% jitter
+    return Math.min(exponentialDelay + jitter, RETRY_CONFIG.maxDelayMs);
+}
+/**
+ * Sleep for a given number of milliseconds
+ */
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+/**
+ * Map HTTP status code to error code
+ */
+function statusToErrorCode(status) {
+    switch (status) {
+        case 400: return ERROR_CODES.BAD_REQUEST;
+        case 401: return ERROR_CODES.UNAUTHORIZED;
+        case 403: return ERROR_CODES.FORBIDDEN;
+        case 404: return ERROR_CODES.NOT_FOUND;
+        case 429: return ERROR_CODES.RATE_LIMITED;
+        case 502:
+        case 503:
+        case 504: return ERROR_CODES.SERVICE_UNAVAILABLE;
+        default: return ERROR_CODES.PROVIDER_ERROR;
+    }
+}
+/**
+ * Check if a response status code is retryable
+ */
+function isRetryableStatus(status) {
+    return RETRY_CONFIG.retryableStatusCodes.includes(status);
+}
+/**
+ * Fetch with automatic retry for transient failures (429, 503)
+ */
+async function fetchWithRetry(url, options, context) {
+    let lastError = null;
+    let lastResponse = null;
+    for (let attempt = 0; attempt <= RETRY_CONFIG.maxRetries; attempt++) {
+        try {
+            const response = await fetch(url, options);
+            // Check if we should retry
+            if (isRetryableStatus(response.status) && attempt < RETRY_CONFIG.maxRetries) {
+                lastResponse = response;
+                const delay = calculateBackoff(attempt);
+                // Check for Retry-After header
+                const retryAfter = response.headers.get('Retry-After');
+                const retryDelay = retryAfter
+                    ? (parseInt(retryAfter) * 1000 || delay)
+                    : delay;
+                console.log(`[APIClaw] ${context.provider}/${context.action}: Got ${response.status}, retrying in ${Math.round(retryDelay)}ms (attempt ${attempt + 1}/${RETRY_CONFIG.maxRetries})`);
+                await sleep(Math.min(retryDelay, RETRY_CONFIG.maxDelayMs));
+                continue;
+            }
+            return response;
+        }
+        catch (error) {
+            lastError = error;
+            // Retry on network errors
+            if (attempt < RETRY_CONFIG.maxRetries) {
+                const delay = calculateBackoff(attempt);
+                console.log(`[APIClaw] ${context.provider}/${context.action}: Network error, retrying in ${Math.round(delay)}ms (attempt ${attempt + 1}/${RETRY_CONFIG.maxRetries})`);
+                await sleep(delay);
+                continue;
+            }
+        }
+    }
+    // If we have a response (even if error status), return it for proper error handling
+    if (lastResponse) {
+        return lastResponse;
+    }
+    // All retries exhausted with network errors
+    throw lastError || new Error('Max retries exceeded');
+}
 /**
  * Normalize response by extracting common fields to top-level
  * Makes it easier for agents to access key data without digging into provider-specific structures
@@ -282,6 +384,18 @@ export function generateDryRun(providerId, action, params) {
         notes,
     };
 }
+/**
+ * Create a structured error result with error code
+ */
+function createErrorResult(provider, action, error, code, status) {
+    return {
+        success: false,
+        provider,
+        action,
+        error,
+        code,
+    };
+}
 // Helper to safely access properties
 function safeGet(obj, ...keys) {
     let current = obj;
@@ -302,20 +416,20 @@ const handlers = {
         send_sms: async (params, creds) => {
             const { to, message, from = 'APIClaw' } = params;
             if (!to || !message) {
-                return { success: false, provider: '46elks', action: 'send_sms', error: 'Missing required params: to, message' };
+                return createErrorResult('46elks', 'send_sms', 'Missing required params: to, message', ERROR_CODES.INVALID_PARAMS);
             }
             const auth = Buffer.from(`${creds.username}:${creds.password}`).toString('base64');
-            const response = await fetch('https://api.46elks.com/a1/sms', {
+            const response = await fetchWithRetry('https://api.46elks.com/a1/sms', {
                 method: 'POST',
                 headers: {
                     'Authorization': `Basic ${auth}`,
                     'Content-Type': 'application/x-www-form-urlencoded',
                 },
                 body: new URLSearchParams({ from, to, message }),
-            });
+            }, { provider: '46elks', action: 'send_sms' });
             const data = await response.json();
             if (!response.ok) {
-                return { success: false, provider: '46elks', action: 'send_sms', error: data.message || 'SMS failed' };
+                return createErrorResult('46elks', 'send_sms', data.message || 'SMS failed', statusToErrorCode(response.status));
             }
             return {
                 success: true,
@@ -331,21 +445,21 @@ const handlers = {
         send_sms: async (params, creds) => {
             const { to, message, from } = params;
             if (!to || !message) {
-                return { success: false, provider: 'twilio', action: 'send_sms', error: 'Missing required params: to, message' };
+                return createErrorResult('twilio', 'send_sms', 'Missing required params: to, message', ERROR_CODES.INVALID_PARAMS);
             }
             const auth = Buffer.from(`${creds.username}:${creds.password}`).toString('base64');
             const fromNumber = from || creds.from_number || '+15017122661';
-            const response = await fetch(`https://api.twilio.com/2010-04-01/Accounts/${creds.username}/Messages.json`, {
+            const response = await fetchWithRetry(`https://api.twilio.com/2010-04-01/Accounts/${creds.username}/Messages.json`, {
                 method: 'POST',
                 headers: {
                     'Authorization': `Basic ${auth}`,
                     'Content-Type': 'application/x-www-form-urlencoded',
                 },
                 body: new URLSearchParams({ From: fromNumber, To: to, Body: message }),
-            });
+            }, { provider: 'twilio', action: 'send_sms' });
             const data = await response.json();
             if (!response.ok) {
-                return { success: false, provider: 'twilio', action: 'send_sms', error: data.message || 'SMS failed' };
+                return createErrorResult('twilio', 'send_sms', data.message || 'SMS failed', statusToErrorCode(response.status));
             }
             return {
                 success: true,
@@ -360,17 +474,17 @@ const handlers = {
         search: async (params, creds) => {
             const { query, count = 5 } = params;
             if (!query) {
-                return { success: false, provider: 'brave_search', action: 'search', error: 'Missing required param: query' };
+                return createErrorResult('brave_search', 'search', 'Missing required param: query', ERROR_CODES.INVALID_PARAMS);
             }
             const url = new URL('https://api.search.brave.com/res/v1/web/search');
             url.searchParams.set('q', query);
             url.searchParams.set('count', count.toString());
-            const response = await fetch(url.toString(), {
+            const response = await fetchWithRetry(url.toString(), {
                 headers: { 'X-Subscription-Token': creds.api_key },
-            });
+            }, { provider: 'brave_search', action: 'search' });
             const data = await response.json();
             if (!response.ok) {
-                return { success: false, provider: 'brave_search', action: 'search', error: data.message || 'Search failed' };
+                return createErrorResult('brave_search', 'search', data.message || 'Search failed', statusToErrorCode(response.status));
             }
             const webData = data.web;
             const rawResults = webData?.results || [];
@@ -392,19 +506,19 @@ const handlers = {
         send_email: async (params, creds) => {
             const { to, subject, html, text, from = 'APIClaw <noreply@apiclaw.nordsym.com>' } = params;
             if (!to || !subject || (!html && !text)) {
-                return { success: false, provider: 'resend', action: 'send_email', error: 'Missing required params: to, subject, html or text' };
+                return createErrorResult('resend', 'send_email', 'Missing required params: to, subject, html or text', ERROR_CODES.INVALID_PARAMS);
             }
-            const response = await fetch('https://api.resend.com/emails', {
+            const response = await fetchWithRetry('https://api.resend.com/emails', {
                 method: 'POST',
                 headers: {
                     'Authorization': `Bearer ${creds.api_key}`,
                     'Content-Type': 'application/json',
                 },
                 body: JSON.stringify({ from, to, subject, html, text }),
-            });
+            }, { provider: 'resend', action: 'send_email' });
             const data = await response.json();
             if (!response.ok) {
-                return { success: false, provider: 'resend', action: 'send_email', error: data.message || 'Email failed' };
+                return createErrorResult('resend', 'send_email', data.message || 'Email failed', statusToErrorCode(response.status));
             }
             return {
                 success: true,
@@ -419,9 +533,9 @@ const handlers = {
         chat: async (params, creds) => {
             const { messages, model = 'anthropic/claude-3-haiku', max_tokens = 1000 } = params;
             if (!messages || !Array.isArray(messages)) {
-                return { success: false, provider: 'openrouter', action: 'chat', error: 'Missing required param: messages (array)' };
+                return createErrorResult('openrouter', 'chat', 'Missing required param: messages (array)', ERROR_CODES.INVALID_PARAMS);
             }
-            const response = await fetch('https://openrouter.ai/api/v1/chat/completions', {
+            const response = await fetchWithRetry('https://openrouter.ai/api/v1/chat/completions', {
                 method: 'POST',
                 headers: {
                     'Authorization': `Bearer ${creds.api_key}`,
@@ -429,11 +543,11 @@ const handlers = {
                     'HTTP-Referer': 'https://apiclaw.nordsym.com',
                 },
                 body: JSON.stringify({ model, messages, max_tokens }),
-            });
+            }, { provider: 'openrouter', action: 'chat' });
             const data = await response.json();
             if (!response.ok) {
                 const errorData = data.error;
-                return { success: false, provider: 'openrouter', action: 'chat', error: errorData?.message || 'Chat failed' };
+                return createErrorResult('openrouter', 'chat', errorData?.message || 'Chat failed', statusToErrorCode(response.status));
             }
             const choices = data.choices;
             const firstChoice = choices?.[0];
@@ -455,19 +569,19 @@ const handlers = {
         text_to_speech: async (params, creds) => {
             const { text, voice_id = '21m00Tcm4TlvDq8ikWAM', model_id = 'eleven_monolingual_v1' } = params;
             if (!text) {
-                return { success: false, provider: 'elevenlabs', action: 'text_to_speech', error: 'Missing required param: text' };
+                return createErrorResult('elevenlabs', 'text_to_speech', 'Missing required param: text', ERROR_CODES.INVALID_PARAMS);
             }
-            const response = await fetch(`https://api.elevenlabs.io/v1/text-to-speech/${voice_id}`, {
+            const response = await fetchWithRetry(`https://api.elevenlabs.io/v1/text-to-speech/${voice_id}`, {
                 method: 'POST',
                 headers: {
                     'xi-api-key': creds.api_key,
                     'Content-Type': 'application/json',
                 },
                 body: JSON.stringify({ text, model_id }),
-            });
+            }, { provider: 'elevenlabs', action: 'text_to_speech' });
             if (!response.ok) {
                 const error = await response.json().catch(() => ({}));
-                return { success: false, provider: 'elevenlabs', action: 'text_to_speech', error: error.detail || 'TTS failed' };
+                return createErrorResult('elevenlabs', 'text_to_speech', error.detail || 'TTS failed', statusToErrorCode(response.status));
             }
             // Return audio as base64
             const buffer = await response.arrayBuffer();
@@ -489,15 +603,15 @@ const handlers = {
         run: async (params, creds) => {
             const { model, input } = params;
             if (!model) {
-                return { success: false, provider: 'replicate', action: 'run', error: 'Missing required param: model (e.g., "stability-ai/sdxl:...")' };
+                return createErrorResult('replicate', 'run', 'Missing required param: model (e.g., "stability-ai/sdxl:...")', ERROR_CODES.INVALID_PARAMS);
             }
             if (!input) {
-                return { success: false, provider: 'replicate', action: 'run', error: 'Missing required param: input (object with model inputs)' };
+                return createErrorResult('replicate', 'run', 'Missing required param: input (object with model inputs)', ERROR_CODES.INVALID_PARAMS);
             }
             // Parse model into owner/name and version
             const [modelPath, version] = model.split(':');
             // Create prediction
-            const response = await fetch('https://api.replicate.com/v1/predictions', {
+            const response = await fetchWithRetry('https://api.replicate.com/v1/predictions', {
                 method: 'POST',
                 headers: {
                     'Authorization': `Bearer ${creds.api_key}`,
@@ -508,10 +622,10 @@ const handlers = {
                     model: version ? undefined : modelPath,
                     input,
                 }),
-            });
+            }, { provider: 'replicate', action: 'run' });
             if (!response.ok) {
                 const error = await response.json().catch(() => ({}));
-                return { success: false, provider: 'replicate', action: 'run', error: error.detail || 'Prediction failed' };
+                return createErrorResult('replicate', 'run', error.detail || 'Prediction failed', statusToErrorCode(response.status));
             }
             const prediction = await response.json();
             // Poll for completion (max 60 seconds)
@@ -531,14 +645,14 @@ const handlers = {
                         }
                     };
                 }
-                await new Promise(resolve => setTimeout(resolve, 1000));
-                const pollResponse = await fetch(result.urls?.get || `https://api.replicate.com/v1/predictions/${result.id}`, {
+                await sleep(1000);
+                const pollResponse = await fetchWithRetry(result.urls?.get || `https://api.replicate.com/v1/predictions/${result.id}`, {
                     headers: { 'Authorization': `Bearer ${creds.api_key}` },
-                });
+                }, { provider: 'replicate', action: 'run_poll' });
                 result = await pollResponse.json();
             }
             if (result.status === 'failed') {
-                return { success: false, provider: 'replicate', action: 'run', error: result.error || 'Prediction failed' };
+                return createErrorResult('replicate', 'run', result.error || 'Prediction failed', ERROR_CODES.PROVIDER_ERROR);
             }
             return {
                 success: true,
@@ -553,11 +667,11 @@ const handlers = {
             };
         },
         list_models: async (_params, creds) => {
-            const response = await fetch('https://api.replicate.com/v1/models', {
+            const response = await fetchWithRetry('https://api.replicate.com/v1/models', {
                 headers: { 'Authorization': `Bearer ${creds.api_key}` },
-            });
+            }, { provider: 'replicate', action: 'list_models' });
             if (!response.ok) {
-                return { success: false, provider: 'replicate', action: 'list_models', error: 'Failed to list models' };
+                return createErrorResult('replicate', 'list_models', 'Failed to list models', statusToErrorCode(response.status));
             }
             const data = await response.json();
             return {
@@ -576,19 +690,19 @@ const handlers = {
         scrape: async (params, creds) => {
             const { url, formats = ['markdown'] } = params;
             if (!url) {
-                return { success: false, provider: 'firecrawl', action: 'scrape', error: 'Missing required param: url' };
+                return createErrorResult('firecrawl', 'scrape', 'Missing required param: url', ERROR_CODES.INVALID_PARAMS);
             }
-            const response = await fetch('https://api.firecrawl.dev/v1/scrape', {
+            const response = await fetchWithRetry('https://api.firecrawl.dev/v1/scrape', {
                 method: 'POST',
                 headers: {
                     'Authorization': `Bearer ${creds.api_key}`,
                     'Content-Type': 'application/json',
                 },
                 body: JSON.stringify({ url, formats }),
-            });
+            }, { provider: 'firecrawl', action: 'scrape' });
             const data = await response.json();
             if (!response.ok || !data.success) {
-                return { success: false, provider: 'firecrawl', action: 'scrape', error: data.error || 'Scrape failed' };
+                return createErrorResult('firecrawl', 'scrape', data.error || 'Scrape failed', statusToErrorCode(response.status));
             }
             return {
                 success: true,
@@ -600,19 +714,19 @@ const handlers = {
         crawl: async (params, creds) => {
             const { url, limit = 10 } = params;
             if (!url) {
-                return { success: false, provider: 'firecrawl', action: 'crawl', error: 'Missing required param: url' };
+                return createErrorResult('firecrawl', 'crawl', 'Missing required param: url', ERROR_CODES.INVALID_PARAMS);
             }
-            const response = await fetch('https://api.firecrawl.dev/v1/crawl', {
+            const response = await fetchWithRetry('https://api.firecrawl.dev/v1/crawl', {
                 method: 'POST',
                 headers: {
                     'Authorization': `Bearer ${creds.api_key}`,
                     'Content-Type': 'application/json',
                 },
                 body: JSON.stringify({ url, limit }),
-            });
+            }, { provider: 'firecrawl', action: 'crawl' });
             const data = await response.json();
             if (!response.ok || !data.success) {
-                return { success: false, provider: 'firecrawl', action: 'crawl', error: data.error || 'Crawl failed' };
+                return createErrorResult('firecrawl', 'crawl', data.error || 'Crawl failed', statusToErrorCode(response.status));
             }
             return {
                 success: true,
@@ -624,19 +738,19 @@ const handlers = {
         map: async (params, creds) => {
             const { url } = params;
             if (!url) {
-                return { success: false, provider: 'firecrawl', action: 'map', error: 'Missing required param: url' };
+                return createErrorResult('firecrawl', 'map', 'Missing required param: url', ERROR_CODES.INVALID_PARAMS);
             }
-            const response = await fetch('https://api.firecrawl.dev/v1/map', {
+            const response = await fetchWithRetry('https://api.firecrawl.dev/v1/map', {
                 method: 'POST',
                 headers: {
                     'Authorization': `Bearer ${creds.api_key}`,
                     'Content-Type': 'application/json',
                 },
                 body: JSON.stringify({ url }),
-            });
+            }, { provider: 'firecrawl', action: 'map' });
             const data = await response.json();
             if (!response.ok || !data.success) {
-                return { success: false, provider: 'firecrawl', action: 'map', error: data.error || 'Map failed' };
+                return createErrorResult('firecrawl', 'map', data.error || 'Map failed', statusToErrorCode(response.status));
             }
             return {
                 success: true,
@@ -651,18 +765,18 @@ const handlers = {
         search_repos: async (params, creds) => {
             const { query, sort = 'stars', limit = 10 } = params;
             if (!query) {
-                return { success: false, provider: 'github', action: 'search_repos', error: 'Missing required param: query' };
+                return createErrorResult('github', 'search_repos', 'Missing required param: query', ERROR_CODES.INVALID_PARAMS);
             }
-            const response = await fetch(`https://api.github.com/search/repositories?q=${encodeURIComponent(query)}&sort=${sort}&per_page=${limit}`, {
+            const response = await fetchWithRetry(`https://api.github.com/search/repositories?q=${encodeURIComponent(query)}&sort=${sort}&per_page=${limit}`, {
                 headers: {
                     'Authorization': `Bearer ${creds.token}`,
                     'Accept': 'application/vnd.github+json',
                     'User-Agent': 'APIClaw',
                 },
-            });
+            }, { provider: 'github', action: 'search_repos' });
             const data = await response.json();
             if (!response.ok) {
-                return { success: false, provider: 'github', action: 'search_repos', error: data.message || 'Search failed' };
+                return createErrorResult('github', 'search_repos', data.message || 'Search failed', statusToErrorCode(response.status));
             }
             const items = data.items || [];
             return {
@@ -684,18 +798,18 @@ const handlers = {
         get_repo: async (params, creds) => {
             const { owner, repo } = params;
             if (!owner || !repo) {
-                return { success: false, provider: 'github', action: 'get_repo', error: 'Missing required params: owner, repo' };
+                return createErrorResult('github', 'get_repo', 'Missing required params: owner, repo', ERROR_CODES.INVALID_PARAMS);
             }
-            const response = await fetch(`https://api.github.com/repos/${owner}/${repo}`, {
+            const response = await fetchWithRetry(`https://api.github.com/repos/${owner}/${repo}`, {
                 headers: {
                     'Authorization': `Bearer ${creds.token}`,
                     'Accept': 'application/vnd.github+json',
                     'User-Agent': 'APIClaw',
                 },
-            });
+            }, { provider: 'github', action: 'get_repo' });
             const data = await response.json();
             if (!response.ok) {
-                return { success: false, provider: 'github', action: 'get_repo', error: data.message || 'Get repo failed' };
+                return createErrorResult('github', 'get_repo', data.message || 'Get repo failed', statusToErrorCode(response.status));
             }
             return {
                 success: true,
@@ -716,18 +830,18 @@ const handlers = {
         list_issues: async (params, creds) => {
             const { owner, repo, state = 'open', limit = 10 } = params;
             if (!owner || !repo) {
-                return { success: false, provider: 'github', action: 'list_issues', error: 'Missing required params: owner, repo' };
+                return createErrorResult('github', 'list_issues', 'Missing required params: owner, repo', ERROR_CODES.INVALID_PARAMS);
             }
-            const response = await fetch(`https://api.github.com/repos/${owner}/${repo}/issues?state=${state}&per_page=${limit}`, {
+            const response = await fetchWithRetry(`https://api.github.com/repos/${owner}/${repo}/issues?state=${state}&per_page=${limit}`, {
                 headers: {
                     'Authorization': `Bearer ${creds.token}`,
                     'Accept': 'application/vnd.github+json',
                     'User-Agent': 'APIClaw',
                 },
-            });
+            }, { provider: 'github', action: 'list_issues' });
             const data = await response.json();
             if (!response.ok) {
-                return { success: false, provider: 'github', action: 'list_issues', error: 'List issues failed' };
+                return createErrorResult('github', 'list_issues', 'List issues failed', statusToErrorCode(response.status));
             }
             return {
                 success: true,
@@ -748,9 +862,9 @@ const handlers = {
         create_issue: async (params, creds) => {
             const { owner, repo, title, body = '' } = params;
             if (!owner || !repo || !title) {
-                return { success: false, provider: 'github', action: 'create_issue', error: 'Missing required params: owner, repo, title' };
+                return createErrorResult('github', 'create_issue', 'Missing required params: owner, repo, title', ERROR_CODES.INVALID_PARAMS);
             }
-            const response = await fetch(`https://api.github.com/repos/${owner}/${repo}/issues`, {
+            const response = await fetchWithRetry(`https://api.github.com/repos/${owner}/${repo}/issues`, {
                 method: 'POST',
                 headers: {
                     'Authorization': `Bearer ${creds.token}`,
@@ -759,10 +873,10 @@ const handlers = {
                     'Content-Type': 'application/json',
                 },
                 body: JSON.stringify({ title, body }),
-            });
+            }, { provider: 'github', action: 'create_issue' });
             const data = await response.json();
             if (!response.ok) {
-                return { success: false, provider: 'github', action: 'create_issue', error: data.message || 'Create issue failed' };
+                return createErrorResult('github', 'create_issue', data.message || 'Create issue failed', statusToErrorCode(response.status));
             }
             return {
                 success: true,
@@ -777,18 +891,18 @@ const handlers = {
         get_file: async (params, creds) => {
             const { owner, repo, path } = params;
             if (!owner || !repo || !path) {
-                return { success: false, provider: 'github', action: 'get_file', error: 'Missing required params: owner, repo, path' };
+                return createErrorResult('github', 'get_file', 'Missing required params: owner, repo, path', ERROR_CODES.INVALID_PARAMS);
             }
-            const response = await fetch(`https://api.github.com/repos/${owner}/${repo}/contents/${path}`, {
+            const response = await fetchWithRetry(`https://api.github.com/repos/${owner}/${repo}/contents/${path}`, {
                 headers: {
                     'Authorization': `Bearer ${creds.token}`,
                     'Accept': 'application/vnd.github+json',
                     'User-Agent': 'APIClaw',
                 },
-            });
+            }, { provider: 'github', action: 'get_file' });
             const data = await response.json();
             if (!response.ok) {
-                return { success: false, provider: 'github', action: 'get_file', error: data.message || 'Get file failed' };
+                return createErrorResult('github', 'get_file', data.message || 'Get file failed', statusToErrorCode(response.status));
             }
             // Decode base64 content
             const content = data.content ? Buffer.from(data.content, 'base64').toString('utf-8') : null;
@@ -811,7 +925,7 @@ const handlers = {
         run_code: async (params, creds) => {
             const { code, language = 'python' } = params;
             if (!code) {
-                return { success: false, provider: 'e2b', action: 'run_code', error: 'Missing required param: code' };
+                return createErrorResult('e2b', 'run_code', 'Missing required param: code', ERROR_CODES.INVALID_PARAMS);
             }
             try {
                 // Dynamic import to avoid issues if SDK not installed
@@ -837,18 +951,13 @@ const handlers = {
                 }
             }
             catch (error) {
-                return {
-                    success: false,
-                    provider: 'e2b',
-                    action: 'run_code',
-                    error: error.message || 'Code execution failed'
-                };
+                return createErrorResult('e2b', 'run_code', error.message || 'Code execution failed', ERROR_CODES.PROVIDER_ERROR);
             }
         },
         run_shell: async (params, creds) => {
             const { command } = params;
             if (!command) {
-                return { success: false, provider: 'e2b', action: 'run_shell', error: 'Missing required param: command' };
+                return createErrorResult('e2b', 'run_shell', 'Missing required param: command', ERROR_CODES.INVALID_PARAMS);
             }
             try {
                 const { Sandbox } = await import('@e2b/code-interpreter');
@@ -872,12 +981,7 @@ const handlers = {
                 }
             }
             catch (error) {
-                return {
-                    success: false,
-                    provider: 'e2b',
-                    action: 'run_shell',
-                    error: error.message || 'Shell execution failed'
-                };
+                return createErrorResult('e2b', 'run_shell', error.message || 'Shell execution failed', ERROR_CODES.PROVIDER_ERROR);
             }
         },
     },
@@ -920,29 +1024,14 @@ export async function executeAPICall(providerId, action, params, userId, custome
         // Check if it might be a dynamic provider without userId
         const dynamicActions = await listDynamicActions(providerId);
         if (dynamicActions.length > 0) {
-            return {
-                success: false,
-                provider: providerId,
-                action,
-                error: `Provider '${providerId}' requires userId for dynamic execution. Available actions: ${dynamicActions.join(', ')}`,
-            };
+            return createErrorResult(providerId, action, `Provider '${providerId}' requires userId for dynamic execution. Available actions: ${dynamicActions.join(', ')}`, ERROR_CODES.INVALID_PARAMS);
         }
-        return {
-            success: false,
-            provider: providerId,
-            action,
-            error: `Provider '${providerId}' not connected. Available: ${Object.keys(handlers).join(', ')}`,
-        };
+        return createErrorResult(providerId, action, `Provider '${providerId}' not connected. Available: ${Object.keys(handlers).join(', ')}`, ERROR_CODES.UNKNOWN_PROVIDER);
     }
     // Check if action exists
     const handler = providerHandlers[action];
     if (!handler) {
-        return {
-            success: false,
-            provider: providerId,
-            action,
-            error: `Action '${action}' not available for ${providerId}. Available: ${Object.keys(providerHandlers).join(', ')}`,
-        };
+        return createErrorResult(providerId, action, `Action '${action}' not available for ${providerId}. Available: ${Object.keys(providerHandlers).join(', ')}`, ERROR_CODES.UNKNOWN_ACTION);
     }
     // Providers that don't require credentials (free/open APIs)
     const NO_CREDS_PROVIDERS = ['coingecko'];
@@ -967,20 +1056,10 @@ export async function executeAPICall(providerId, action, params, userId, custome
                 });
             }
             catch (e) {
-                return {
-                    success: false,
-                    provider: providerId,
-                    action,
-                    error: e.message || 'Proxy call failed',
-                };
+                return createErrorResult(providerId, action, e.message || 'Proxy call failed', ERROR_CODES.PROVIDER_ERROR);
             }
         }
-        return {
-            success: false,
-            provider: providerId,
-            action,
-            error: `No credentials configured for ${providerId}. Set up ~/.secrets/${providerId}.env`,
-        };
+        return createErrorResult(providerId, action, `No credentials configured for ${providerId}. Set up ~/.secrets/${providerId}.env`, ERROR_CODES.NO_CREDENTIALS);
     }
     // Execute and normalize response
     try {
@@ -988,12 +1067,19 @@ export async function executeAPICall(providerId, action, params, userId, custome
         return normalizeResponse(result);
     }
     catch (error) {
-        return {
-            success: false,
-            provider: providerId,
-            action,
-            error: error.message || 'Unknown error',
-        };
+        // Check if it's a network/timeout error
+        const errorMessage = error.message || 'Unknown error';
+        let errorCode = ERROR_CODES.PROVIDER_ERROR;
+        if (errorMessage.includes('Max retries exceeded')) {
+            errorCode = ERROR_CODES.MAX_RETRIES_EXCEEDED;
+        }
+        else if (errorMessage.includes('timeout') || errorMessage.includes('ETIMEDOUT')) {
+            errorCode = ERROR_CODES.TIMEOUT;
+        }
+        else if (errorMessage.includes('ECONNREFUSED') || errorMessage.includes('ENOTFOUND') || errorMessage.includes('fetch')) {
+            errorCode = ERROR_CODES.NETWORK_ERROR;
+        }
+        return createErrorResult(providerId, action, errorMessage, errorCode);
     }
 }
 //# sourceMappingURL=execute.js.map