neoagent 3.2.1-beta.0 → 3.2.1-beta.10

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

@@ -1,5 +1,62 @@
-const { GoogleGenerativeAI } = require('@google/generative-ai');
+'use strict';
+
+const { GoogleGenAI } = require('@google/genai');
 const { BaseProvider } = require('./base');
+const { fetchResponseText } = require('../../network/http');
+
+function parseToolArguments(value) {
+  try {
+    const parsed = JSON.parse(value || '{}');
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+      ? parsed
+      : {};
+  } catch {
+    return {};
+  }
+}
+
+function normalizeUsage(usage) {
+  if (!usage) return null;
+  return {
+    inputTokens: usage.promptTokenCount || 0,
+    outputTokens: usage.candidatesTokenCount || 0,
+    reasoningTokens: usage.thoughtsTokenCount || 0,
+    cachedReadTokens: usage.cachedContentTokenCount || 0,
+    cacheWriteTokens: 0,
+    promptTokens: usage.promptTokenCount || 0,
+    completionTokens: usage.candidatesTokenCount || 0,
+    totalTokens: usage.totalTokenCount || 0
+  };
+}
+
+function collectResponseParts(response, toolCalls, seenToolCalls = null) {
+  let content = '';
+  for (const candidate of response?.candidates || []) {
+    for (const part of candidate.content?.parts || []) {
+      if (part.text && part.thought !== true) content += part.text;
+      if (!part.functionCall?.name) continue;
+
+      const args = part.functionCall.args || {};
+      const providerCallId = String(part.functionCall.id || '').trim();
+      const signature = providerCallId
+        || `${part.functionCall.name}:${JSON.stringify(args)}`;
+      if (seenToolCalls?.has(signature)) continue;
+      seenToolCalls?.add(signature);
+
+      toolCalls.push({
+        id: providerCallId
+          || `call_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+        type: 'function',
+        function: {
+          name: part.functionCall.name,
+          arguments: JSON.stringify(args),
+          thought_signature: part.thoughtSignature
+        }
+      });
+    }
+  }
+  return content;
+}
 
 class GoogleProvider extends BaseProvider {
   constructor(config = {}) {
@@ -28,16 +85,33 @@ class GoogleProvider extends BaseProvider {
       'gemini-1.5-flash': 1048576,
     };
     this.apiKey = config.apiKey || process.env.GOOGLE_AI_KEY;
-    this.genAI = new GoogleGenerativeAI(this.apiKey);
+    this.genAI = new GoogleGenAI({ apiKey: this.apiKey });
   }
 
-  async listModels() {
+  async listModels(signal = null) {
     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`
+    const { response, text } = await fetchResponseText(
+      'https://generativelanguage.googleapis.com/v1beta/models?pageSize=200',
+      {
+        headers: { 'x-goog-api-key': this.apiKey },
+        maxResponseBytes: 5 * 1024 * 1024,
+        serviceName: 'Google model catalog',
+        signal,
+      },
     );
-    if (!res.ok) throw new Error(`Google models API returned ${res.status}`);
-    const { models = [] } = await res.json();
+    if (!response.ok) {
+      const error = new Error(`Google models API returned ${response.status}`);
+      error.status = response.status;
+      error.headers = response.headers;
+      throw error;
+    }
+    let payload;
+    try {
+      payload = JSON.parse(text || '{}');
+    } catch {
+      throw new Error('Google models API returned invalid JSON.');
+    }
+    const { models = [] } = payload;
     return models
       .filter((m) => {
         const id = m.name.replace('models/', '');
@@ -60,11 +134,23 @@ class GoogleProvider extends BaseProvider {
       functionDeclarations: tools.map(tool => ({
         name: tool.name,
         description: tool.description,
-        parameters: tool.parameters || { type: 'object', properties: {} }
+        parametersJsonSchema: tool.parameters || { type: 'object', properties: {} }
       }))
     }];
   }
 
+  buildGenerateConfig(systemInstruction, tools, options) {
+    const config = {};
+    if (systemInstruction) config.systemInstruction = systemInstruction;
+    if (tools.length > 0) config.tools = this.formatTools(tools);
+    if (options.signal) config.abortSignal = options.signal;
+    const maxOutputTokens = Number(options.maxTokens);
+    if (Number.isFinite(maxOutputTokens) && maxOutputTokens > 0) {
+      config.maxOutputTokens = Math.floor(maxOutputTokens);
+    }
+    return config;
+  }
+
   convertMessages(messages) {
     let systemInstruction = '';
     const history = [];
@@ -75,14 +161,16 @@ class GoogleProvider extends BaseProvider {
         continue;
       }
       if (msg.role === 'tool') {
+        const functionResponse = {
+          name: msg.name || 'tool',
+          response: { result: msg.content }
+        };
+        if (msg.tool_call_id) functionResponse.id = msg.tool_call_id;
         history.push({
-          role: 'function',
-          parts: [{
-            functionResponse: {
-              name: msg.name || 'tool',
-              response: { result: msg.content }
-            }
-          }]
+          // The current Gemini API represents tool results as functionResponse
+          // parts on a user turn.
+          role: 'user',
+          parts: [{ functionResponse }]
         });
         continue;
       }
@@ -93,9 +181,10 @@ class GoogleProvider extends BaseProvider {
           const functionCallPart = {
             functionCall: {
               name: tc.function.name,
-              args: JSON.parse(tc.function.arguments || '{}')
+              args: parseToolArguments(tc.function.arguments)
             }
           };
+          if (tc.id) functionCallPart.functionCall.id = tc.id;
           if (tc.function.thought_signature) {
             functionCallPart.thoughtSignature = tc.function.thought_signature;
           }
@@ -129,6 +218,18 @@ class GoogleProvider extends BaseProvider {
       normalizedHistory.push({ role: currentRole, parts: currentParts });
     }
 
+    // Structured helpers can consist entirely of system instructions. Gemini
+    // still requires a user turn to trigger generation.
+    if (
+      normalizedHistory.length === 0
+      || normalizedHistory[normalizedHistory.length - 1].role === 'model'
+    ) {
+      normalizedHistory.push({
+        role: 'user',
+        parts: [{ text: 'Provide the requested response using the system instructions.' }]
+      });
+    }
+
     if (normalizedHistory.length > 0 && normalizedHistory[0].role !== 'user') {
       normalizedHistory.unshift({
         role: 'user',
@@ -142,53 +243,18 @@ class GoogleProvider extends BaseProvider {
   async chat(messages, tools = [], options = {}) {
     const model = options.model || this.config.model || this.getDefaultModel();
     const { systemInstruction, history } = this.convertMessages(messages);
-
-    const genModel = this.genAI.getGenerativeModel({
+    const response = await this.genAI.models.generateContent({
       model,
-      systemInstruction: systemInstruction || undefined,
-      tools: tools.length > 0 ? this.formatTools(tools) : undefined
+      contents: history,
+      config: this.buildGenerateConfig(systemInstruction, tools, options)
     });
-
-    const lastMessage = history.pop();
-    const chat = genModel.startChat({ history });
-    const result = await chat.sendMessage(lastMessage.parts);
-    const response = result.response;
-
-    let content = '';
     const toolCalls = [];
-
-    for (const candidate of response.candidates || []) {
-      for (const part of candidate.content?.parts || []) {
-        if (part.text) content += part.text;
-        if (part.functionCall) {
-          toolCalls.push({
-            id: `call_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
-            type: 'function',
-            function: {
-              name: part.functionCall.name,
-              arguments: JSON.stringify(part.functionCall.args || {}),
-              thought_signature: part.thoughtSignature
-            }
-          });
-        }
-      }
-    }
-
-    const usage = response.usageMetadata;
+    const content = collectResponseParts(response, toolCalls);
     return {
       content,
       toolCalls,
       finishReason: toolCalls.length > 0 ? 'tool_calls' : 'stop',
-      usage: usage ? {
-        inputTokens: usage.promptTokenCount || 0,
-        outputTokens: usage.candidatesTokenCount || 0,
-        reasoningTokens: usage.thoughtsTokenCount || 0,
-        cachedReadTokens: usage.cachedContentTokenCount || 0,
-        cacheWriteTokens: 0,
-        promptTokens: usage.promptTokenCount || 0,
-        completionTokens: usage.candidatesTokenCount || 0,
-        totalTokens: usage.totalTokenCount || 0
-      } : null,
+      usage: normalizeUsage(response.usageMetadata),
       model
     };
   }
@@ -196,60 +262,32 @@ class GoogleProvider extends BaseProvider {
   async *stream(messages, tools = [], options = {}) {
     const model = options.model || this.config.model || this.getDefaultModel();
     const { systemInstruction, history } = this.convertMessages(messages);
-
-    const genModel = this.genAI.getGenerativeModel({
+    const responseStream = await this.genAI.models.generateContentStream({
       model,
-      systemInstruction: systemInstruction || undefined,
-      tools: tools.length > 0 ? this.formatTools(tools) : undefined
+      contents: history,
+      config: this.buildGenerateConfig(systemInstruction, tools, options)
     });
-
-    const lastMessage = history.pop();
-    const chat = genModel.startChat({ history });
-    const result = await chat.sendMessageStream(lastMessage.parts);
-
     let content = '';
     const toolCalls = [];
+    const seenToolCalls = new Set();
+    let usage = null;
 
-    for await (const chunk of result.stream) {
-      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)}`,
-              type: 'function',
-              function: {
-                name: part.functionCall.name,
-                arguments: JSON.stringify(part.functionCall.args || {}),
-                thought_signature: part.thoughtSignature
-              }
-            });
-          }
-        }
+    for await (const chunk of responseStream) {
+      const chunkContent = collectResponseParts(chunk, toolCalls, seenToolCalls);
+      if (chunkContent) {
+        content += chunkContent;
+        yield { type: 'content', content: chunkContent };
       }
+      if (chunk.usageMetadata) usage = chunk.usageMetadata;
     }
 
-    const finalResponse = await result.response;
-    const usage = finalResponse.usageMetadata;
-
     yield {
       type: 'done',
       content,
       toolCalls,
       finishReason: toolCalls.length > 0 ? 'tool_calls' : 'stop',
-      usage: usage ? {
-        inputTokens: usage.promptTokenCount || 0,
-        outputTokens: usage.candidatesTokenCount || 0,
-        reasoningTokens: usage.thoughtsTokenCount || 0,
-        cachedReadTokens: usage.cachedContentTokenCount || 0,
-        cacheWriteTokens: 0,
-        promptTokens: usage.promptTokenCount || 0,
-        completionTokens: usage.candidatesTokenCount || 0,
-        totalTokens: usage.totalTokenCount || 0
-      } : null
+      usage: normalizeUsage(usage),
+      model
     };
   }
 }

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

@@ -1,5 +1,6 @@
 const OpenAI = require('openai');
 const { OpenAICompatibleProvider } = require('./openaiCompatible');
+const { wrapProviderError } = require('./provider_error');
 
 class GrokProvider extends OpenAICompatibleProvider {
   constructor(config = {}) {
@@ -11,15 +12,15 @@ class GrokProvider extends OpenAICompatibleProvider {
     });
   }
 
-  async listModels() {
+  async listModels(signal = null) {
     try {
-      const res = await this.client.models.list();
+      const res = await this.client.models.list({ signal });
       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)}`);
+      throw wrapProviderError(err, 'Failed to list Grok models', { signal });
     }
   }
 
@@ -61,7 +62,7 @@ class GrokProvider extends OpenAICompatibleProvider {
     const model = options.model || 'grok-4-1-fast-reasoning';
     const params = this._buildParams(model, messages, tools, options);
 
-    const response = await this.client.chat.completions.create(params);
+    const response = await this.client.chat.completions.create(params, { signal: options.signal });
     return this.normalizeResponse(response);
   }
 
@@ -73,7 +74,7 @@ class GrokProvider extends OpenAICompatibleProvider {
       stream_options: { include_usage: true }
     };
 
-    const stream = await this.client.chat.completions.create(params);
+    const stream = await this.client.chat.completions.create(params, { signal: options.signal });
 
     let toolCalls = [];
     let content = '';

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

@@ -1,12 +1,14 @@
-const fs = require('fs');
-const path = require('path');
 const OpenAI = require('openai');
+const { ENV_FILE, upsertEnvValue } = require('../../../../runtime/paths');
+const { fetchResponseText } = require('../../network/http');
 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';
+const OAUTH_REFRESH_TIMEOUT_MS = 30000;
+const OAUTH_MAX_RESPONSE_BYTES = 256 * 1024;
 
 function normalizeExpiresAt(data) {
   if (typeof data.expires_at === 'number' && Number.isFinite(data.expires_at)) {
@@ -21,29 +23,14 @@ function normalizeExpiresAt(data) {
 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 });
+    upsertEnvValue(ENV_FILE, key, value);
   } catch { }
 }
 
-async function refreshGrokOAuthAccessToken(refreshToken, fetchImpl = fetch) {
+async function refreshGrokOAuthAccessToken(refreshToken, fetchImpl = fetch, signal = null) {
   if (!refreshToken) return null;
-  const response = await fetchImpl(GROK_OAUTH_TOKEN_URL, {
+  const { response, text } = await fetchResponseText(GROK_OAUTH_TOKEN_URL, {
+    fetchImpl,
     method: 'POST',
     headers: {
       'Content-Type': 'application/x-www-form-urlencoded',
@@ -54,9 +41,14 @@ async function refreshGrokOAuthAccessToken(refreshToken, fetchImpl = fetch) {
       refresh_token: refreshToken,
       client_id: GROK_OAUTH_CLIENT_ID,
     }),
+    signal,
+    timeoutMs: OAUTH_REFRESH_TIMEOUT_MS,
+    maxResponseBytes: OAUTH_MAX_RESPONSE_BYTES,
+    serviceName: 'Grok OAuth refresh',
+    timeoutCode: 'PROVIDER_OAUTH_TIMEOUT',
+    tooLargeCode: 'PROVIDER_OAUTH_RESPONSE_TOO_LARGE',
   });
 
-  const text = await response.text();
   let data = {};
   try {
     data = text ? JSON.parse(text) : {};
@@ -68,7 +60,7 @@ async function refreshGrokOAuthAccessToken(refreshToken, fetchImpl = fetch) {
     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';
+    const detail = String(data?.error_description || data?.error || text || 'Unknown error').slice(0, 2000);
     throw new Error(`Grok OAuth refresh failed: HTTP ${response.status} ${detail}`);
   }
   if (!data.access_token) {
@@ -102,8 +94,8 @@ class GrokOAuthProvider extends GrokProvider {
     this.fetchImpl = config.fetch || fetch;
   }
 
-  async refreshClient() {
-    const refreshed = await refreshGrokOAuthAccessToken(this.refreshToken, this.fetchImpl);
+  async refreshClient(signal = null) {
+    const refreshed = await refreshGrokOAuthAccessToken(this.refreshToken, this.fetchImpl, signal);
     if (!refreshed?.access) return false;
     this.authToken = refreshed.access;
     this.refreshToken = refreshed.refresh || this.refreshToken;
@@ -122,7 +114,7 @@ class GrokOAuthProvider extends GrokProvider {
       return await super.chat(messages, tools, options);
     } catch (err) {
       if (err?.status !== 401 || !this.refreshToken) throw err;
-      await this.refreshClient();
+      await this.refreshClient(options.signal);
       return await super.chat(messages, tools, options);
     }
   }
@@ -132,7 +124,7 @@ class GrokOAuthProvider extends GrokProvider {
       yield* super.stream(messages, tools, options);
     } catch (err) {
       if (err?.status !== 401 || !this.refreshToken) throw err;
-      await this.refreshClient();
+      await this.refreshClient(options.signal);
       yield* super.stream(messages, tools, options);
     }
   }

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

@@ -1,5 +1,6 @@
 const OpenAI = require('openai');
 const { OpenAICompatibleProvider } = require('./openaiCompatible');
+const { wrapProviderError } = require('./provider_error');
 
 const NVIDIA_BASE_URL = 'https://integrate.api.nvidia.com/v1';
 
@@ -32,15 +33,15 @@ class NvidiaProvider extends OpenAICompatibleProvider {
     });
   }
 
-  async listModels() {
+  async listModels(signal = null) {
     try {
-      const res = await this.client.models.list();
+      const res = await this.client.models.list({ signal });
       const DROP = /embed|bge|e5-|rerank|guard|safety|moderat|diffus|flux|stable|imagen|vision-enc|whisper|tts|speech|paraphrase|classif/i;
       return res.data
         .filter((m) => !DROP.test(m.id))
         .map((m) => ({ id: m.id, name: m.id }));
     } catch (err) {
-      throw new Error(`NVIDIA NIM request failed: ${err?.message || String(err)}`);
+      throw wrapProviderError(err, 'NVIDIA NIM request failed', { signal });
     }
   }
 
@@ -76,9 +77,11 @@ class NvidiaProvider extends OpenAICompatibleProvider {
     const params = this._buildParams(model, messages, tools, options);
     let response;
     try {
-      response = await this.client.chat.completions.create(params);
+      response = await this.client.chat.completions.create(params, { signal: options.signal });
     } catch (err) {
-      throw new Error(`NVIDIA NIM request failed: ${err?.message || String(err)}`);
+      throw wrapProviderError(err, 'NVIDIA NIM request failed', {
+        signal: options.signal,
+      });
     }
     return this.normalizeResponse(response);
   }
@@ -93,9 +96,11 @@ class NvidiaProvider extends OpenAICompatibleProvider {
 
     let stream;
     try {
-      stream = await this.client.chat.completions.create(params);
+      stream = await this.client.chat.completions.create(params, { signal: options.signal });
     } catch (err) {
-      throw new Error(`NVIDIA NIM request failed: ${err?.message || String(err)}`);
+      throw wrapProviderError(err, 'NVIDIA NIM request failed', {
+        signal: options.signal,
+      });
     }
 
     let toolCalls = [];