neoagent 2.4.1-beta.8 → 2.4.1

package/server/services/ai/providerRetry.js

@@ -0,0 +1,169 @@
+'use strict';
+
+// Centralized transient-error retry for AI provider calls.
+//
+// A transient blip (rate limit, provider overload, brief network failure) should
+// retry the SAME model with a short backoff. Only after these retries are
+// exhausted does the engine fall back to a different (often weaker) model. This
+// keeps response quality high and avoids burning the fallback chain on errors a
+// one-second wait would have resolved.
+
+const DEFAULTS = {
+  maxAttempts: 3, // total attempts including the first
+  baseDelayMs: 500,
+  maxDelayMs: 8000,
+};
+
+// HTTP statuses worth retrying: request timeout, conflict, rate limit, and the
+// 5xx family including Anthropic's 529 "overloaded" and common CDN edge codes.
+const RETRYABLE_STATUS = new Set([408, 409, 425, 429, 500, 502, 503, 504, 520, 521, 522, 524, 529]);
+
+// Low-level socket / DNS errors surfaced by Node and undici.
+const RETRYABLE_CODES = new Set([
+  'ECONNRESET', 'ECONNREFUSED', 'ETIMEDOUT', 'EPIPE', 'EAI_AGAIN', 'ENOTFOUND',
+  'ENETUNREACH', 'EHOSTUNREACH', 'EAGAIN',
+  'UND_ERR_CONNECT_TIMEOUT', 'UND_ERR_SOCKET', 'UND_ERR_HEADERS_TIMEOUT',
+]);
+
+function readNumberEnv(name, fallback, { min = 0, max = Number.MAX_SAFE_INTEGER } = {}) {
+  const raw = process.env[name];
+  if (raw === undefined || raw === null || String(raw).trim() === '') return fallback;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed)) return fallback;
+  return Math.min(max, Math.max(min, parsed));
+}
+
+function resolveConfig(overrides = {}) {
+  return {
+    maxAttempts: overrides.maxAttempts
+      ?? readNumberEnv('NEOAGENT_AI_RETRY_MAX_ATTEMPTS', DEFAULTS.maxAttempts, { min: 1, max: 8 }),
+    baseDelayMs: overrides.baseDelayMs
+      ?? readNumberEnv('NEOAGENT_AI_RETRY_BASE_MS', DEFAULTS.baseDelayMs, { min: 0, max: 60000 }),
+    maxDelayMs: overrides.maxDelayMs
+      ?? readNumberEnv('NEOAGENT_AI_RETRY_MAX_MS', DEFAULTS.maxDelayMs, { min: 0, max: 120000 }),
+  };
+}
+
+// SDKs disagree on where they put the HTTP status: OpenAI/Anthropic expose
+// `.status`, raw http clients use `.statusCode`, and some nest it under
+// `.response.status`. Check all of them.
+function getStatus(err) {
+  if (!err || typeof err !== 'object') return null;
+  const candidates = [err.status, err.statusCode, err.response?.status, err.cause?.status];
+  for (const value of candidates) {
+    const num = Number(value);
+    if (Number.isFinite(num) && num >= 100 && num < 600) return num;
+  }
+  return null;
+}
+
+function getErrorCode(err) {
+  if (!err || typeof err !== 'object') return null;
+  return err.code || err.errno || err.cause?.code || null;
+}
+
+function isTransientError(err) {
+  if (!err) return false;
+
+  const status = getStatus(err);
+  if (status !== null) return RETRYABLE_STATUS.has(status);
+
+  const code = getErrorCode(err);
+  if (code && RETRYABLE_CODES.has(String(code))) return true;
+
+  // SDK connection wrappers that don't carry a status or code.
+  const name = String(err.name || '');
+  if (name === 'APIConnectionError' || name === 'APIConnectionTimeoutError') return true;
+
+  const message = String(err.message || '').toLowerCase();
+  if (!message) return false;
+  return /\b(overloaded|rate limit|timed? ?out|timeout|temporarily unavailable|connection (?:reset|refused|error)|socket hang up|network (?:error|timeout)|service unavailable)\b/.test(message);
+}
+
+// Honor a server-provided Retry-After when present; it is authoritative over our
+// own backoff. Supports both delta-seconds and `retry-after-ms` style headers.
+function retryAfterMs(err) {
+  if (!err || typeof err !== 'object') return null;
+  const headers = err.headers || err.response?.headers;
+  const read = (name) => {
+    if (!headers) return undefined;
+    if (typeof headers.get === 'function') return headers.get(name);
+    return headers[name] ?? headers[name.toLowerCase()];
+  };
+
+  const ms = read('retry-after-ms');
+  if (ms !== undefined && ms !== null && String(ms).trim() !== '') {
+    const parsed = Number(ms);
+    if (Number.isFinite(parsed) && parsed >= 0) return parsed;
+  }
+
+  const after = read('retry-after');
+  if (after !== undefined && after !== null && String(after).trim() !== '') {
+    const seconds = Number(after);
+    if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1000;
+    const date = Date.parse(String(after));
+    if (Number.isFinite(date)) return Math.max(0, date - Date.now());
+  }
+
+  return null;
+}
+
+// Exponential backoff with equal-jitter: half the window is fixed, half random,
+// which spreads retries out without ever collapsing the delay to zero.
+function computeBackoffMs(attempt, baseDelayMs, maxDelayMs) {
+  const exp = Math.min(maxDelayMs, baseDelayMs * 2 ** (attempt - 1));
+  return Math.round(exp / 2 + Math.random() * (exp / 2));
+}
+
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * Run `fn` with transient-error retries.
+ *
+ * @param {(attempt: number) => Promise<any>} fn The provider call to attempt;
+ *   invoked with the current 1-based attempt number.
+ * @param {object} [options]
+ * @param {(err: any) => boolean} [options.isRetryable] Override transient classification.
+ * @param {(info: {attempt:number, delayMs:number, error:any}) => void} [options.onRetry]
+ *   Called before each wait so callers can surface progress to the user.
+ * @param {string} [options.label] Prefix for diagnostic logs.
+ */
+async function withProviderRetry(fn, options = {}) {
+  const { maxAttempts, baseDelayMs, maxDelayMs } = resolveConfig(options);
+  const isRetryable = typeof options.isRetryable === 'function' ? options.isRetryable : isTransientError;
+  const label = options.label || 'ProviderRetry';
+
+  let attempt = 0;
+  while (true) {
+    attempt += 1;
+    try {
+      return await fn(attempt);
+    } catch (err) {
+      const exhausted = attempt >= maxAttempts;
+      if (exhausted || !isRetryable(err)) throw err;
+
+      const waitMs = retryAfterMs(err) ?? computeBackoffMs(attempt, baseDelayMs, maxDelayMs);
+      console.warn(
+        `[${label}] transient failure on attempt ${attempt}/${maxAttempts}; retrying in ${waitMs}ms: ${String(err?.message || err).slice(0, 200)}`
+      );
+      if (typeof options.onRetry === 'function') {
+        try {
+          options.onRetry({ attempt, delayMs: waitMs, error: err });
+        } catch { /* a misbehaving progress callback must not abort the retry */ }
+      }
+      await delay(waitMs);
+    }
+  }
+}
+
+module.exports = {
+  withProviderRetry,
+  isTransientError,
+  retryAfterMs,
+  computeBackoffMs,
+  resolveConfig,
+  RETRYABLE_STATUS,
+  RETRYABLE_CODES,
+};

package/server/services/ai/providers/anthropic.js

@@ -6,18 +6,24 @@ class AnthropicProvider extends BaseProvider {
     super(config);
     this.name = 'anthropic';
     this.models = [
+      'claude-opus-4-8',
+      'claude-opus-4-7',
+      'claude-sonnet-4-6',
       'claude-sonnet-4-20250514',
-      'claude-3-5-sonnet-20241022',
+      'claude-haiku-4-5-20251001',
       'claude-3-5-haiku-20241022',
+      'claude-3-5-sonnet-20241022',
       'claude-3-opus-20240229',
-      'MiniMax-M2.7'
     ];
     this.contextWindows = {
+      'claude-opus-4-8': 1000000,
+      'claude-opus-4-7': 200000,
+      'claude-sonnet-4-6': 200000,
       'claude-sonnet-4-20250514': 200000,
-      'claude-3-5-sonnet-20241022': 200000,
+      'claude-haiku-4-5-20251001': 200000,
       'claude-3-5-haiku-20241022': 200000,
+      'claude-3-5-sonnet-20241022': 200000,
       'claude-3-opus-20240229': 200000,
-      'MiniMax-M2.7': 204800
     };
     this.client = new Anthropic({
       apiKey: config.apiKey || process.env.ANTHROPIC_API_KEY,
@@ -25,6 +31,11 @@ class AnthropicProvider extends BaseProvider {
     });
   }
 
+  async listModels() {
+    const res = await this.client.models.list({ limit: 100 });
+    return (res.data || []).map((m) => ({ id: m.id, name: m.display_name || m.id }));
+  }
+
   getContextWindow(model) {
     return this.contextWindows[model] || 200000;
   }

package/server/services/ai/providers/google.js

@@ -6,20 +6,49 @@ class GoogleProvider extends BaseProvider {
     super(config);
     this.name = 'google';
     this.models = [
+      'gemini-3.5-pro',
+      'gemini-3.5-flash',
+      'gemini-3.1-pro',
+      'gemini-3.1-flash-lite-preview',
+      'gemini-2.5-pro',
+      'gemini-2.5-flash',
       'gemini-2.0-flash',
-      'gemini-2.0-pro',
       'gemini-1.5-pro',
       'gemini-1.5-flash',
-      'gemini-3.1-flash-lite-preview'
     ];
     this.contextWindows = {
+      'gemini-3.5-pro': 2097152,
+      'gemini-3.5-flash': 1048576,
+      'gemini-3.1-pro': 2097152,
+      'gemini-3.1-flash-lite-preview': 1048576,
+      'gemini-2.5-pro': 1048576,
+      'gemini-2.5-flash': 1048576,
       'gemini-2.0-flash': 1048576,
-      'gemini-2.0-pro': 2097152,
       'gemini-1.5-pro': 2097152,
       'gemini-1.5-flash': 1048576,
-      'gemini-3.1-flash-lite-preview': 1048576
     };
-    this.genAI = new GoogleGenerativeAI(config.apiKey || process.env.GOOGLE_AI_KEY);
+    this.apiKey = config.apiKey || process.env.GOOGLE_AI_KEY;
+    this.genAI = new GoogleGenerativeAI(this.apiKey);
+  }
+
+  async listModels() {
+    const DROP = /tts|lyria|robotics|deep-research|antigravity|computer-use|-image(?!.*it)/i;
+    const res = await fetch(
+      `https://generativelanguage.googleapis.com/v1beta/models?key=${this.apiKey}&pageSize=200`
+    );
+    if (!res.ok) throw new Error(`Google models API returned ${res.status}`);
+    const { models = [] } = await res.json();
+    return models
+      .filter((m) => {
+        const id = m.name.replace('models/', '');
+        return (m.supportedGenerationMethods || []).includes('generateContent')
+          && !DROP.test(id);
+      })
+      .map((m) => {
+        const id = m.name.replace('models/', '');
+        this.contextWindows[id] = m.inputTokenLimit || 1048576;
+        return { id, name: m.displayName || id };
+      });
   }
 
   getContextWindow(model) {
@@ -177,14 +206,12 @@ class GoogleProvider extends BaseProvider {
     const toolCalls = [];
 
     for await (const chunk of result.stream) {
-      const text = chunk.text();
-      if (text) {
-        content += text;
-        yield { type: 'content', content: text };
-      }
-
       for (const candidate of chunk.candidates || []) {
         for (const part of candidate.content?.parts || []) {
+          if (part.text) {
+            content += part.text;
+            yield { type: 'content', content: part.text };
+          }
           if (part.functionCall) {
             toolCalls.push({
               id: `call_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,

package/server/services/ai/providers/grok.js

@@ -1,7 +1,7 @@
 const OpenAI = require('openai');
-const { BaseProvider } = require('./base');
+const { OpenAICompatibleProvider } = require('./openaiCompatible');
 
-class GrokProvider extends BaseProvider {
+class GrokProvider extends OpenAICompatibleProvider {
   constructor(config = {}) {
     super(config);
     this.name = 'grok';
@@ -11,8 +11,21 @@ class GrokProvider extends BaseProvider {
     });
   }
 
+  async listModels() {
+    try {
+      const res = await this.client.models.list();
+      const DROP = /imagine|diffus|embed|-tts/i;
+      return res.data
+        .filter((m) => !DROP.test(m.id))
+        .map((m) => ({ id: m.id, name: m.id }));
+    } catch (err) {
+      throw new Error(`Failed to list Grok models: ${err.message || String(err)}`);
+    }
+  }
+
   getContextWindow(model) {
-    return 131072; // grok-4 context window
+    if (model === 'grok-4.3') return 1000000;
+    return 131072;
   }
 
   supportsVision() {
@@ -68,7 +81,7 @@ class GrokProvider extends BaseProvider {
 
     for await (const chunk of stream) {
       if (chunk.usage && (!chunk.choices || chunk.choices.length === 0)) {
-        finalUsage = this.#normalizeUsage(chunk.usage);
+        finalUsage = this.normalizeUsage(chunk.usage);
         continue;
       }
 
@@ -97,7 +110,7 @@ class GrokProvider extends BaseProvider {
           type: 'tool_calls',
           toolCalls,
           content,
-          usage: this.#normalizeUsage(chunk.usage) || finalUsage
+          usage: this.normalizeUsage(chunk.usage) || finalUsage
         };
         return;
       }
@@ -105,7 +118,7 @@ class GrokProvider extends BaseProvider {
         yield {
           type: 'done',
           content,
-          usage: this.#normalizeUsage(chunk.usage) || finalUsage
+          usage: this.normalizeUsage(chunk.usage) || finalUsage
         };
         return;
       }
@@ -118,68 +131,6 @@ class GrokProvider extends BaseProvider {
     }
   }
 
-  normalizeResponse(response) {
-    const choice = response.choices[0];
-    const msg = choice.message;
-    return {
-      content: msg.content || '',
-      toolCalls: msg.tool_calls?.map(tc => ({
-        id: tc.id,
-        type: 'function',
-        function: { name: tc.function.name, arguments: tc.function.arguments }
-      })) || [],
-      finishReason: choice.finish_reason,
-      usage: this.#normalizeUsage(response.usage)
-    };
-  }
-
-  #normalizeUsage(usage) {
-    if (!usage) {
-      return null;
-    }
-    return {
-      promptTokens: usage.prompt_tokens ?? usage.promptTokens ?? 0,
-      completionTokens: usage.completion_tokens ?? usage.completionTokens ?? 0,
-      totalTokens: usage.total_tokens ?? usage.totalTokens ?? 0,
-    };
-  }
-
-  formatTools(tools) {
-    return tools.map(tool => ({
-      type: 'function',
-      function: {
-        name: tool.name,
-        description: tool.description,
-        parameters: tool.parameters
-      }
-    }));
-  }
-
-  async analyzeImage(options = {}) {
-    const model = options.model || this.getDefaultVisionModel();
-    const b64 = BaseProvider.readImageAsBase64(options.imagePath);
-    const response = await this.client.chat.completions.create({
-      model,
-      max_tokens: options.maxTokens || 4096,
-      messages: [{
-        role: 'user',
-        content: [
-          { type: 'text', text: options.question || 'Describe this image in detail.' },
-          {
-            type: 'image_url',
-            image_url: {
-              url: `data:${options.mimeType || 'image/jpeg'};base64,${b64}`
-            }
-          }
-        ]
-      }]
-    });
-
-    return {
-      content: response.choices[0]?.message?.content || '',
-      model: response.model || model,
-    };
-  }
 }
 
 module.exports = { GrokProvider };

package/server/services/ai/providers/grokOauth.js

@@ -0,0 +1,141 @@
+const fs = require('fs');
+const path = require('path');
+const OpenAI = require('openai');
+const { GrokProvider } = require('./grok');
+
+const GROK_OAUTH_BASE_URL = 'https://api.x.ai/v1';
+const GROK_OAUTH_CLIENT_ID = 'b1a00492-073a-47ea-816f-4c329264a828';
+const GROK_OAUTH_TOKEN_URL = 'https://auth.x.ai/oauth2/token';
+const GROK_OAUTH_SCOPES = 'openid profile email offline_access grok-cli:access api:access';
+
+function normalizeExpiresAt(data) {
+  if (typeof data.expires_at === 'number' && Number.isFinite(data.expires_at)) {
+    return data.expires_at > 10_000_000_000 ? data.expires_at : data.expires_at * 1000;
+  }
+  if (typeof data.expires_in === 'number' && Number.isFinite(data.expires_in)) {
+    return Date.now() + (data.expires_in * 1000);
+  }
+  return null;
+}
+
+function persistEnvValue(key, value) {
+  if (!value) return;
+  try {
+    const { ENV_FILE } = require('../../../../runtime/paths');
+    const safeKey = String(key).replace(/[\r\n]/g, '');
+    const safeValue = String(value).replace(/[\r\n]/g, '');
+    const raw = fs.existsSync(ENV_FILE) ? fs.readFileSync(ENV_FILE, 'utf8') : '';
+    const lines = raw ? raw.split('\n') : [];
+    let replaced = false;
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].startsWith(`${safeKey}=`)) {
+        lines[i] = `${safeKey}=${safeValue}`;
+        replaced = true;
+        break;
+      }
+    }
+    if (!replaced) lines.push(`${safeKey}=${safeValue}`);
+    const output = lines.filter((_, idx, arr) => idx !== arr.length - 1 || arr[idx] !== '').join('\n') + '\n';
+    fs.mkdirSync(path.dirname(ENV_FILE), { recursive: true });
+    fs.writeFileSync(ENV_FILE, output, { mode: 0o600 });
+  } catch { }
+}
+
+async function refreshGrokOAuthAccessToken(refreshToken, fetchImpl = fetch) {
+  if (!refreshToken) return null;
+  const response = await fetchImpl(GROK_OAUTH_TOKEN_URL, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/x-www-form-urlencoded',
+      'Accept': 'application/json',
+    },
+    body: new URLSearchParams({
+      grant_type: 'refresh_token',
+      refresh_token: refreshToken,
+      client_id: GROK_OAUTH_CLIENT_ID,
+    }),
+  });
+
+  const text = await response.text();
+  let data = {};
+  try {
+    data = text ? JSON.parse(text) : {};
+  } catch {
+    data = {};
+  }
+
+  if (!response.ok) {
+    if (data?.error === 'invalid_grant') {
+      throw new Error('Grok OAuth refresh token is invalid or expired. Re-run `neoagent login grok-oauth` to re-authenticate.');
+    }
+    const detail = data?.error_description || data?.error || text || 'Unknown error';
+    throw new Error(`Grok OAuth refresh failed: HTTP ${response.status} ${detail}`);
+  }
+  if (!data.access_token) {
+    throw new Error('Grok OAuth refresh succeeded but no access_token was returned.');
+  }
+
+  return {
+    access: data.access_token,
+    refresh: data.refresh_token || refreshToken,
+    expires: normalizeExpiresAt(data),
+  };
+}
+
+class GrokOAuthProvider extends GrokProvider {
+  constructor(config = {}) {
+    const authToken = config.apiKey || process.env.GROK_OAUTH_ACCESS_TOKEN;
+    super({
+      ...config,
+      apiKey: authToken,
+      baseUrl: GROK_OAUTH_BASE_URL,
+    });
+    this.name = 'grok-oauth';
+    this.models = ['grok-4', 'grok-4-mini'];
+
+    if (!authToken) {
+      console.warn('[GrokOAuth] No access token. Run `neoagent login grok-oauth` to authenticate.');
+    }
+
+    this.authToken = authToken || null;
+    this.refreshToken = config.refreshToken || process.env.GROK_OAUTH_REFRESH_TOKEN || null;
+    this.fetchImpl = config.fetch || fetch;
+  }
+
+  async refreshClient() {
+    const refreshed = await refreshGrokOAuthAccessToken(this.refreshToken, this.fetchImpl);
+    if (!refreshed?.access) return false;
+    this.authToken = refreshed.access;
+    this.refreshToken = refreshed.refresh || this.refreshToken;
+    process.env.GROK_OAUTH_ACCESS_TOKEN = this.authToken;
+    persistEnvValue('GROK_OAUTH_ACCESS_TOKEN', this.authToken);
+    if (this.refreshToken) {
+      process.env.GROK_OAUTH_REFRESH_TOKEN = this.refreshToken;
+      persistEnvValue('GROK_OAUTH_REFRESH_TOKEN', this.refreshToken);
+    }
+    this.client = new OpenAI({ apiKey: this.authToken, baseURL: GROK_OAUTH_BASE_URL });
+    return true;
+  }
+
+  async chat(messages, tools = [], options = {}) {
+    try {
+      return await super.chat(messages, tools, options);
+    } catch (err) {
+      if (err?.status !== 401 || !this.refreshToken) throw err;
+      await this.refreshClient();
+      return await super.chat(messages, tools, options);
+    }
+  }
+
+  async *stream(messages, tools = [], options = {}) {
+    try {
+      yield* super.stream(messages, tools, options);
+    } catch (err) {
+      if (err?.status !== 401 || !this.refreshToken) throw err;
+      await this.refreshClient();
+      yield* super.stream(messages, tools, options);
+    }
+  }
+}
+
+module.exports = { GrokOAuthProvider, refreshGrokOAuthAccessToken, GROK_OAUTH_SCOPES, GROK_OAUTH_CLIENT_ID };