neoagent 2.4.1-beta.36 → 2.4.1-beta.38

package/server/services/ai/logFormat.js

@@ -0,0 +1,46 @@
+'use strict';
+
+// Small, dependency-free helpers for shaping values into safe log lines and
+// for tolerant JSON parsing. Shared across the AI engine and its sibling
+// modules so log formatting stays consistent and testable.
+
+function shortenRunId(runId) {
+  const value = String(runId || '').trim();
+  if (!value) return 'unknown';
+  return value.length <= 8 ? value : value.slice(0, 8);
+}
+
+function summarizeForLog(value, maxChars = 220) {
+  if (value == null) return '';
+
+  let text = '';
+  if (typeof value === 'string') {
+    text = value;
+  } else {
+    try {
+      text = JSON.stringify(value);
+    } catch {
+      text = String(value);
+    }
+  }
+
+  const normalized = text.replace(/\s+/g, ' ').trim();
+  if (normalized.length <= maxChars) return normalized;
+  return `${normalized.slice(0, maxChars)}...`;
+}
+
+function parseMaybeJson(value, fallback = null) {
+  if (!value) return fallback;
+  if (typeof value === 'object') return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return fallback;
+  }
+}
+
+module.exports = {
+  shortenRunId,
+  summarizeForLog,
+  parseMaybeJson,
+};

package/server/services/ai/messagingFallback.js

@@ -0,0 +1,228 @@
+'use strict';
+
+// Deterministic, model-free helpers for shaping outgoing messages and for
+// constructing honest fallback replies when a run fails or the model returns a
+// blank message. Kept free of engine state so the behavior is pure and unit
+// testable: every function derives its output from its arguments alone.
+
+const {
+  buildPlatformFormattingGuide,
+  normalizeOutgoingMessageForPlatform,
+} = require('../messaging/formatting_guides');
+const { summarizeForLog } = require('./logFormat');
+
+function normalizeOutgoingMessage(content, platform = null, options = {}) {
+  const normalized = normalizeOutgoingMessageForPlatform(platform, content);
+  if (options.collapseWhitespace === false) {
+    return normalized;
+  }
+  return normalized.replace(/\s+/g, ' ').trim();
+}
+
+function clampRunContext(text, maxChars) {
+  const value = normalizeOutgoingMessage(text);
+  if (!value) return '';
+  if (value.length <= maxChars) return value;
+  return `${value.slice(0, maxChars)}...`;
+}
+
+function joinSentMessages(messages = []) {
+  if (!Array.isArray(messages)) return '';
+  return messages
+    .map((message) => String(message || '').trim())
+    .filter(Boolean)
+    .join('\n\n');
+}
+
+function normalizeInterimText(content, platform = null) {
+  return normalizeOutgoingMessageForPlatform(platform, content, {
+    stripNoResponseMarker: false,
+  }).trim();
+}
+
+function buildBlankMessagingReplyPrompt(attempt, platform = null) {
+  const formattingGuide = buildPlatformFormattingGuide(platform);
+  if (attempt <= 1) {
+    return `You must send one non-empty reply for the external messaging user right now. Do not call tools. Give either: (a) the concrete outcome, or (b) a clear blocker. If tool work already happened, summarize what you actually tried and where it got blocked. Do not ask the user to repeat the original request. Do not promise future work unless that work already happened in this run or will happen automatically before this reply is sent.\n\n${formattingGuide}`;
+  }
+
+  return `Your previous reply was empty. Return one non-empty message now. Do not call tools. If needed, apologize briefly and explain the blocker in one sentence. Use the run evidence already in the conversation instead of asking the user to restate the task. Do not promise future work unless that work already happened in this run or will happen automatically before this reply is sent.\n\n${formattingGuide}`;
+}
+
+function parseToolExecutionSummary(item) {
+  if (!item?.summary) return null;
+  try {
+    const parsed = JSON.parse(item.summary);
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function toolWorkDescription(toolName) {
+  const name = String(toolName || '');
+  if (name === 'execute_command') return 'ran shell commands';
+  if (name === 'read_file' || name === 'search_files' || name === 'list_directory') return 'checked files';
+  if (name === 'web_search' || name === 'http_request') return 'looked up supporting information';
+  if (name.startsWith('browser_')) return 'checked the browser state';
+  if (name.startsWith('android_')) return 'checked the Android state';
+  if (name === 'read_health_data' || name.startsWith('recordings_')) return 'checked stored data';
+  return '';
+}
+
+function summarizeRecentWork(toolExecutions = []) {
+  const descriptions = [];
+  for (const item of toolExecutions.slice(-6)) {
+    const description = toolWorkDescription(item?.toolName);
+    if (!description || descriptions.includes(description)) continue;
+    descriptions.push(description);
+    if (descriptions.length >= 2) break;
+  }
+
+  if (descriptions.length === 0) return '';
+  if (descriptions.length === 1) return `I ${descriptions[0]}`;
+  return `I ${descriptions[0]} and ${descriptions[1]}`;
+}
+
+function hasFailureSignal(text) {
+  const normalized = normalizeOutgoingMessage(text);
+  if (!normalized) return false;
+  return /\b(error|failed|failure|traceback|exception|timed out|timeout|not found|no such file|permission denied|unable to|cannot|could not|module not found)\b/i.test(normalized);
+}
+
+function extractToolFailureMessage(item) {
+  const directError = normalizeOutgoingMessage(item?.error || '');
+  if (directError) return directError;
+
+  const summary = parseToolExecutionSummary(item);
+  if (!summary) return '';
+
+  const candidates = [
+    summary.message,
+    summary.note,
+    summary.stderr,
+    summary.stdout,
+    summary.content,
+    summary.excerpt,
+    summary.result,
+    summary.summary,
+  ];
+
+  if (summary.status === 'error') {
+    for (const candidate of candidates) {
+      const normalized = normalizeOutgoingMessage(candidate || '');
+      if (normalized) return normalized;
+    }
+    if (summary.exitCode != null) {
+      return `The last shell command exited with code ${summary.exitCode}`;
+    }
+  }
+
+  for (const candidate of candidates) {
+    const normalized = normalizeOutgoingMessage(candidate || '');
+    if (hasFailureSignal(normalized)) return normalized;
+  }
+
+  return '';
+}
+
+function buildDeterministicMessagingFallback({ failedStepCount, stepIndex, toolExecutions = [] }) {
+  const workSummary = summarizeRecentWork(toolExecutions);
+  const blocker = [...toolExecutions].reverse()
+    .map((item) => extractToolFailureMessage(item))
+    .find(Boolean);
+
+  if (workSummary && blocker) {
+    return `${workSummary}, but I got blocked: ${blocker}. I do not have a confirmed finished result yet.`;
+  }
+  if (blocker) {
+    return `I got blocked while working on this: ${blocker}. I do not have a confirmed finished result yet.`;
+  }
+  if (workSummary && stepIndex > 0) {
+    return `${workSummary}, but I do not have a confirmed finished result yet.`;
+  }
+  if (failedStepCount > 0) {
+    return 'I ran into a tool problem while working on your request, so I do not have a confirmed finished result yet.';
+  }
+  if (stepIndex > 0) {
+    return 'I completed part of the work, but I do not have a confirmed finished result yet.';
+  }
+  return 'I could not produce a reliable final reply just now.';
+}
+
+function buildMessagingFailureScenario({ err, failedStepCount, stepIndex, toolExecutions = [] }) {
+  const parts = [];
+  const runtimeError = normalizeOutgoingMessage(err?.message || '');
+  const workSummary = summarizeRecentWork(toolExecutions);
+  const blocker = [...toolExecutions].reverse()
+    .map((item) => extractToolFailureMessage(item))
+    .find(Boolean);
+
+  if (runtimeError) {
+    parts.push(`Runtime error: ${summarizeForLog(runtimeError, 260)}.`);
+  }
+  if (workSummary) {
+    parts.push(`Observed work before failure: ${workSummary}.`);
+  }
+  if (blocker) {
+    parts.push(`Most specific blocker from run evidence: ${summarizeForLog(blocker, 260)}.`);
+  }
+  if (stepIndex > 0) {
+    parts.push(`Completed steps before failure: ${stepIndex}.`);
+  }
+  if (failedStepCount > 0) {
+    parts.push(`Failed tool steps: ${failedStepCount}.`);
+  }
+
+  return parts.join(' ');
+}
+
+function buildDeterministicMessagingErrorReply({ err, failedStepCount, stepIndex, toolExecutions = [] }) {
+  const message = normalizeOutgoingMessage(err?.message || '');
+  if (/no ai providers? are currently available/i.test(message)) {
+    return 'I cannot continue right now because no AI provider is available for this account. Please check the provider settings.';
+  }
+
+  if (/(timeout|timed out)/i.test(message)) {
+    return 'I hit a timeout while processing your request and could not finish it reliably.';
+  }
+
+  const blocker = [...toolExecutions].reverse()
+    .map((item) => extractToolFailureMessage(item))
+    .find(Boolean);
+  if (blocker) {
+    return `I got blocked while checking this: ${blocker}.`;
+  }
+
+  if (message) {
+    return `I got blocked while working on this: ${message}.`;
+  }
+
+  return buildDeterministicMessagingFallback({ failedStepCount, stepIndex, toolExecutions });
+}
+
+function buildModelFailureLoopPrompt({ failedModel, nextModel, errorMessage }) {
+  return [
+    `The previous model call on "${failedModel}" failed with: ${summarizeForLog(errorMessage, 220)}.`,
+    `Continue on "${nextModel}" and recover autonomously.`,
+    'If a previous plan depended on that failed call, adjust your approach and proceed end-to-end.',
+    'Only ask the user for help if no safe path remains.'
+  ].join(' ');
+}
+
+module.exports = {
+  normalizeOutgoingMessage,
+  clampRunContext,
+  joinSentMessages,
+  normalizeInterimText,
+  buildBlankMessagingReplyPrompt,
+  parseToolExecutionSummary,
+  toolWorkDescription,
+  summarizeRecentWork,
+  hasFailureSignal,
+  extractToolFailureMessage,
+  buildDeterministicMessagingFallback,
+  buildMessagingFailureScenario,
+  buildDeterministicMessagingErrorReply,
+  buildModelFailureLoopPrompt,
+};

package/server/services/ai/models.js

@@ -161,6 +161,12 @@ const STATIC_MODELS = [
         provider: 'google',
         purpose: 'general'
     },
+    {
+        id: 'gemini-3.1-pro',
+        label: 'Gemini 3.1 Pro (High)',
+        provider: 'google',
+        purpose: 'general'
+    },
     {
         id: 'MiniMax-M2.7',
         label: 'MiniMax M2.7 (Coding Plan)',
@@ -172,9 +178,35 @@ const STATIC_MODELS = [
         label: 'Qwen 3.5 4B (Local / Ollama)',
         provider: 'ollama',
         purpose: 'general'
+    },
+    {
+        id: 'gemma4:12b',
+        label: 'Gemma 4 12B (Local / Ollama)',
+        provider: 'ollama',
+        purpose: 'general'
     }
 ];
 
+// Maps a provider id to its class and which runtime fields its constructor takes.
+// Adding a provider is a one-line entry here instead of another dispatch branch.
+// `apiKey`/`baseUrl` mirror exactly what each constructor was historically given;
+// they intentionally do not derive from AI_PROVIDER_DEFINITIONS.supportsBaseUrl,
+// which disagrees for github-copilot/openai-codex (those read their base URL from
+// env, not from per-user config).
+const PROVIDER_FACTORIES = Object.freeze({
+    grok: { Provider: GrokProvider, apiKey: true, baseUrl: true },
+    openai: { Provider: OpenAIProvider, apiKey: true, baseUrl: true },
+    anthropic: { Provider: AnthropicProvider, apiKey: true, baseUrl: true },
+    google: { Provider: GoogleProvider, apiKey: true, baseUrl: false },
+    minimax: { Provider: AnthropicProvider, apiKey: true, baseUrl: true },
+    ollama: { Provider: OllamaProvider, apiKey: false, baseUrl: true },
+    'github-copilot': { Provider: GithubCopilotProvider, apiKey: true, baseUrl: false },
+    'openai-codex': { Provider: OpenAICodexProvider, apiKey: true, baseUrl: false },
+    'claude-code': { Provider: ClaudeCodeProvider, apiKey: true, baseUrl: false },
+    'grok-oauth': { Provider: GrokOAuthProvider, apiKey: true, baseUrl: false },
+    nvidia: { Provider: NvidiaProvider, apiKey: true, baseUrl: true },
+});
+
 const dynamicModelsByBaseUrl = new Map();
 const REFRESH_INTERVAL = 30000; // 30 seconds
 
@@ -395,6 +427,11 @@ async function refreshDynamicModels(baseUrl) {
 }
 
 function createProviderInstance(providerStr, userId = null, configOverrides = {}) {
+    const factory = PROVIDER_FACTORIES[providerStr];
+    if (!factory) {
+        throw new Error(`Unknown provider: ${providerStr}`);
+    }
+
     const { agentId = null, ...providerOverrides } = configOverrides || {};
     const runtime = getProviderRuntimeConfig(userId, providerStr, agentId);
 
@@ -405,34 +442,16 @@ function createProviderInstance(providerStr, userId = null, configOverrides = {}
         throw new Error(`Provider '${providerStr}' is not configured on this deployment.`);
     }
 
-    if (providerStr === 'grok') {
-        return new GrokProvider({ apiKey: runtime.apiKey, baseUrl: runtime.baseUrl, ...providerOverrides });
-    } else if (providerStr === 'openai') {
-        return new OpenAIProvider({ apiKey: runtime.apiKey, baseUrl: runtime.baseUrl, ...providerOverrides });
-    } else if (providerStr === 'anthropic') {
-        return new AnthropicProvider({ apiKey: runtime.apiKey, baseUrl: runtime.baseUrl, ...providerOverrides });
-    } else if (providerStr === 'google') {
-        return new GoogleProvider({ apiKey: runtime.apiKey, ...providerOverrides });
-    } else if (providerStr === 'minimax') {
-        return new AnthropicProvider({ apiKey: runtime.apiKey, baseUrl: runtime.baseUrl, ...providerOverrides });
-    } else if (providerStr === 'ollama') {
-        return new OllamaProvider({ baseUrl: runtime.baseUrl, ...providerOverrides });
-    } else if (providerStr === 'github-copilot') {
-        return new GithubCopilotProvider({ apiKey: runtime.apiKey, ...providerOverrides });
-    } else if (providerStr === 'openai-codex') {
-        return new OpenAICodexProvider({ apiKey: runtime.apiKey, ...providerOverrides });
-    } else if (providerStr === 'claude-code') {
-        return new ClaudeCodeProvider({ apiKey: runtime.apiKey, ...providerOverrides });
-    } else if (providerStr === 'grok-oauth') {
-        return new GrokOAuthProvider({ apiKey: runtime.apiKey, ...providerOverrides });
-    } else if (providerStr === 'nvidia') {
-        return new NvidiaProvider({ apiKey: runtime.apiKey, baseUrl: runtime.baseUrl, ...providerOverrides });
-    }
-    throw new Error(`Unknown provider: ${providerStr}`);
+    const config = {};
+    if (factory.apiKey) config.apiKey = runtime.apiKey;
+    if (factory.baseUrl) config.baseUrl = runtime.baseUrl;
+
+    return new factory.Provider({ ...config, ...providerOverrides });
 }
 
 module.exports = {
     AI_PROVIDER_DEFINITIONS,
+    PROVIDER_FACTORIES,
     SUPPORTED_MODELS: STATIC_MODELS, // Backward compatibility
     createProviderInstance,
     getProviderCatalog,

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/google.js

@@ -10,14 +10,16 @@ class GoogleProvider extends BaseProvider {
       'gemini-2.0-pro',
       'gemini-1.5-pro',
       'gemini-1.5-flash',
-      'gemini-3.1-flash-lite-preview'
+      'gemini-3.1-flash-lite-preview',
+      'gemini-3.1-pro'
     ];
     this.contextWindows = {
       '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
+      'gemini-3.1-flash-lite-preview': 1048576,
+      'gemini-3.1-pro': 2097152
     };
     this.genAI = new GoogleGenerativeAI(config.apiKey || process.env.GOOGLE_AI_KEY);
   }
@@ -177,14 +179,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';
@@ -68,7 +68,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 +97,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 +105,7 @@ class GrokProvider extends BaseProvider {
         yield {
           type: 'done',
           content,
-          usage: this.#normalizeUsage(chunk.usage) || finalUsage
+          usage: this.normalizeUsage(chunk.usage) || finalUsage
         };
         return;
       }
@@ -118,68 +118,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 };