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

package/server/services/ai/provider_selector.js

@@ -0,0 +1,166 @@
+'use strict';
+
+const { getAiSettings } = require('./settings');
+const { createProviderInstance, getSupportedModels } = require('./models');
+const {
+  getRawModelId,
+  normalizeModelSelections,
+  resolveModelSelection,
+} = require('./model_identity');
+const { isModelCoolingDown } = require('./model_failure_cache');
+
+function buildSelection(model, userId, providerConfig) {
+  return {
+    provider: createProviderInstance(model.provider, userId, providerConfig),
+    model: getRawModelId(model),
+    modelSelectionId: model.id,
+    providerName: model.provider,
+  };
+}
+
+async function getProviderForUser(
+  userId,
+  _task = '',
+  isSubagent = false,
+  modelOverride = null,
+  providerConfig = {},
+) {
+  const agentId = providerConfig.agentId || null;
+  const aiSettings = getAiSettings(userId, agentId);
+  const models = await getSupportedModels(userId, agentId, {
+    signal: providerConfig.signal,
+  });
+  const selectableModels = models.filter((model) => model.available !== false);
+  const readyModels = selectableModels.filter(
+    (model) => !isModelCoolingDown(userId, agentId, model.id),
+  );
+
+  if (modelOverride && typeof modelOverride === 'string') {
+    const requested = resolveModelSelection(selectableModels, modelOverride);
+    if (!requested) {
+      throw new Error(`Requested model '${modelOverride.trim()}' is not available.`);
+    }
+    if (isModelCoolingDown(userId, agentId, requested.id) && readyModels.length > 0) {
+      const configuredFallback = resolveModelSelection(
+        readyModels,
+        aiSettings.fallback_model_id,
+      );
+      const fallback = configuredFallback
+        || readyModels.find((model) => model.provider !== requested.provider)
+        || readyModels[0];
+      providerConfig.onStatus?.({
+        phase: 'model_fallback',
+        message: `Skipping recently unavailable model ${requested.id}; using ${fallback.id}.`,
+      });
+      return buildSelection(fallback, userId, providerConfig);
+    }
+    return buildSelection(requested, userId, providerConfig);
+  }
+
+  const configuredEnabledIds = Array.isArray(aiSettings.enabled_models)
+    ? aiSettings.enabled_models.map((id) => String(id).trim()).filter(Boolean)
+    : [];
+  const enabledIds = normalizeModelSelections(selectableModels, configuredEnabledIds);
+  let availableModels = configuredEnabledIds.length > 0
+    ? readyModels.filter((model) => enabledIds.includes(model.id))
+    : readyModels;
+
+  if (
+    availableModels.length === 0
+    && configuredEnabledIds.length > 0
+    && enabledIds.length > 0
+  ) {
+    const configuredFallback = resolveModelSelection(
+      readyModels,
+      aiSettings.fallback_model_id,
+    );
+    if (configuredFallback) {
+      providerConfig.onStatus?.({
+        phase: 'model_fallback',
+        message: `Enabled models are temporarily unavailable; using ${configuredFallback.id}.`,
+      });
+      availableModels = [configuredFallback];
+    }
+  }
+
+  // If every configured model is cooling down and there is no alternative,
+  // allow one retry instead of making the installation permanently unavailable.
+  if (availableModels.length === 0 && readyModels.length === 0) {
+    availableModels = configuredEnabledIds.length > 0
+      ? selectableModels.filter((model) => enabledIds.includes(model.id))
+      : selectableModels;
+  }
+
+  if (availableModels.length === 0) {
+    const message = configuredEnabledIds.length > 0
+      ? 'None of the enabled AI models are currently available. Check model and provider settings.'
+      : 'No AI providers are currently available. Open Settings and configure at least one provider.';
+    throw new Error(message);
+  }
+
+  const fallbackModel = availableModels[0];
+  const userSelectedDefault = isSubagent
+    ? (aiSettings.default_subagent_model || 'auto')
+    : (aiSettings.default_chat_model || 'auto');
+  const smarterSelection = aiSettings.smarter_model_selector !== false
+    && aiSettings.smarter_model_selector !== 'false';
+
+  let selectedModel = fallbackModel;
+  if (userSelectedDefault !== 'auto') {
+    selectedModel = resolveModelSelection(availableModels, userSelectedDefault) || fallbackModel;
+    const configuredDefault = resolveModelSelection(selectableModels, userSelectedDefault);
+    if (
+      configuredDefault
+      && configuredDefault.id !== selectedModel.id
+      && isModelCoolingDown(userId, agentId, configuredDefault.id)
+    ) {
+      providerConfig.onStatus?.({
+        phase: 'model_fallback',
+        message: `Skipping recently unavailable model ${configuredDefault.id}; using ${selectedModel.id}.`,
+      });
+    }
+  } else {
+    const selectionHint = providerConfig.selectionHint && typeof providerConfig.selectionHint === 'object'
+      ? providerConfig.selectionHint
+      : {};
+    const preferredPurpose = String(selectionHint.purpose || '').trim().toLowerCase();
+    const highAutonomy = selectionHint.autonomyLevel === 'high'
+      || selectionHint.complexity === 'complex';
+    const requiredConfidence = String(selectionHint.requiredConfidence || '').trim().toLowerCase();
+    const costMode = String(selectionHint.costMode || aiSettings.cost_mode || 'balanced_auto')
+      .trim()
+      .toLowerCase();
+    const requestedPurpose = ['planning', 'coding', 'general', 'fast'].includes(preferredPurpose)
+      ? preferredPurpose
+      : '';
+    const priceRank = { free: 0, cheap: 1, medium: 2, expensive: 3 };
+    const chooseForPurpose = (purpose) => {
+      const candidates = availableModels.filter((model) => model.purpose === purpose);
+      if (candidates.length === 0) return null;
+      if (['economy', 'cost_saver', 'lowest_cost'].includes(costMode)) {
+        return [...candidates].sort((left, right) => (
+          (priceRank[left.priceTier] ?? 99) - (priceRank[right.priceTier] ?? 99)
+        ))[0];
+      }
+      if (['quality', 'highest_quality'].includes(costMode) || requiredConfidence === 'high') {
+        return candidates.find((model) => model.priceTier !== 'free' && model.priceTier !== 'cheap')
+          || candidates[0];
+      }
+      return candidates[0];
+    };
+
+    if (smarterSelection && requestedPurpose) {
+      selectedModel = chooseForPurpose(requestedPurpose) || fallbackModel;
+    } else if (smarterSelection && highAutonomy) {
+      selectedModel = chooseForPurpose('planning') || chooseForPurpose('general') || fallbackModel;
+    } else if (isSubagent) {
+      selectedModel = chooseForPurpose('fast') || fallbackModel;
+    } else {
+      selectedModel = chooseForPurpose('general') || fallbackModel;
+    }
+  }
+
+  return buildSelection(selectedModel, userId, providerConfig);
+}
+
+module.exports = { getProviderForUser };

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

@@ -31,8 +31,8 @@ class AnthropicProvider extends BaseProvider {
     });
   }
 
-  async listModels() {
-    const res = await this.client.models.list({ limit: 100 });
+  async listModels(signal = null) {
+    const res = await this.client.models.list({ limit: 100 }, { signal });
     return (res.data || []).map((m) => ({ id: m.id, name: m.display_name || m.id }));
   }
 
@@ -169,7 +169,7 @@ class AnthropicProvider extends BaseProvider {
 
     if (system.length > 0) params.system = system;
     if (tools.length > 0) params.tools = this.formatTools(tools);
-    const response = await this.client.messages.create(params);
+    const response = await this.client.messages.create(params, { signal: options.signal });
     const responseBlocks = Array.isArray(response?.content)
       ? response.content
       : (response?.content && typeof response.content === 'object' ? [response.content] : []);
@@ -225,7 +225,7 @@ class AnthropicProvider extends BaseProvider {
 
     if (system.length > 0) params.system = system;
     if (tools.length > 0) params.tools = this.formatTools(tools);
-    const stream = await this.client.messages.stream(params);
+    const stream = await this.client.messages.stream(params, { signal: options.signal });
 
     let content = '';
     let currentToolCalls = [];

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

@@ -2,6 +2,8 @@ const os = require('os');
 const fs = require('fs');
 const path = require('path');
 const Anthropic = require('@anthropic-ai/sdk');
+const { ENV_FILE, upsertEnvValue } = require('../../../../runtime/paths');
+const { fetchResponseText } = require('../../network/http');
 const { AnthropicProvider } = require('./anthropic');
 
 const CLAUDE_CLI_CREDS_PATH = path.join(os.homedir(), '.claude', '.credentials.json');
@@ -12,6 +14,8 @@ const CLAUDE_CODE_SYSTEM_PROMPT = "You are Claude Code, Anthropic's official CLI
 const CLAUDE_CODE_CLIENT_ID = '9d1c250a-e61b-44d9-88ed-5944d1962f5e';
 const CLAUDE_CODE_TOKEN_URL = 'https://platform.claude.com/v1/oauth/token';
 const CLAUDE_CODE_SCOPES = 'user:inference user:profile org:create_api_key user:sessions:claude_code user:mcp_servers';
+const OAUTH_REFRESH_TIMEOUT_MS = 30000;
+const OAUTH_MAX_RESPONSE_BYTES = 256 * 1024;
 
 function readTokenRecord(data) {
   const tokens = data?.claudeAiOauthTokens || data?.claudeAiOauth || {};
@@ -71,40 +75,17 @@ function normalizeExpiresAt(data) {
   return null;
 }
 
-function sanitizeEnvKey(key) {
-  return String(key).replace(/[\r\n]/g, '');
-}
-
-function sanitizeEnvValue(value) {
-  return String(value).replace(/[\r\n]/g, '');
-}
-
 function persistEnvValue(key, value) {
   if (!value) return;
   try {
-    const { ENV_FILE } = require('../../../../runtime/paths');
-    const safeKey = sanitizeEnvKey(key);
-    const safeValue = sanitizeEnvValue(value);
-    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 refreshClaudeCodeAccessToken(refreshToken, fetchImpl = fetch) {
+async function refreshClaudeCodeAccessToken(refreshToken, fetchImpl = fetch, signal = null) {
   if (!refreshToken) return null;
-  const response = await fetchImpl(CLAUDE_CODE_TOKEN_URL, {
+  const { response, text } = await fetchResponseText(CLAUDE_CODE_TOKEN_URL, {
+    fetchImpl,
     method: 'POST',
     headers: {
       'Content-Type': 'application/json',
@@ -116,9 +97,14 @@ async function refreshClaudeCodeAccessToken(refreshToken, fetchImpl = fetch) {
       refresh_token: refreshToken,
       client_id: CLAUDE_CODE_CLIENT_ID,
     }),
+    signal,
+    timeoutMs: OAUTH_REFRESH_TIMEOUT_MS,
+    maxResponseBytes: OAUTH_MAX_RESPONSE_BYTES,
+    serviceName: 'Claude Code 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) : {};
@@ -127,7 +113,9 @@ async function refreshClaudeCodeAccessToken(refreshToken, fetchImpl = fetch) {
   }
 
   if (!response.ok) {
-    const detail = data?.error?.message || data?.error_description || data?.error || text || 'Unknown error';
+    const detail = String(
+      data?.error?.message || data?.error_description || data?.error || text || 'Unknown error',
+    ).slice(0, 2000);
     throw new Error(`Claude Code OAuth refresh failed: HTTP ${response.status} ${detail}`);
   }
   if (!data.access_token) {
@@ -209,8 +197,8 @@ class ClaudeCodeProvider extends AnthropicProvider {
     });
   }
 
-  async refreshClient() {
-    const refreshed = await refreshClaudeCodeAccessToken(this.refreshToken, this.fetchImpl);
+  async refreshClient(signal = null) {
+    const refreshed = await refreshClaudeCodeAccessToken(this.refreshToken, this.fetchImpl, signal);
     if (!refreshed?.access) return false;
     this.authToken = refreshed.access;
     this.refreshToken = refreshed.refresh || this.refreshToken;
@@ -244,7 +232,7 @@ class ClaudeCodeProvider extends AnthropicProvider {
       if ((!isAuthenticationError(err) && !isInferenceScopeError(err)) || !this.refreshToken) {
         throw formatClaudeCodeCredentialError(err);
       }
-      await this.refreshClient();
+      await this.refreshClient(options.signal);
       try {
         return await super.chat(messages, tools, options);
       } catch (retryErr) {
@@ -260,7 +248,7 @@ class ClaudeCodeProvider extends AnthropicProvider {
       if ((!isAuthenticationError(err) && !isInferenceScopeError(err)) || !this.refreshToken) {
         throw formatClaudeCodeCredentialError(err);
       }
-      await this.refreshClient();
+      await this.refreshClient(options.signal);
       try {
         yield* super.stream(messages, tools, options);
       } catch (retryErr) {

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

@@ -1,4 +1,9 @@
 const { OpenAIProvider } = require('./openai');
+const {
+  fetchResponseText,
+  waitForAbortableResult,
+} = require('../../network/http');
+const { sanitizeProviderErrorDetail } = require('./provider_error');
 
 class GithubCopilotProvider extends OpenAIProvider {
   constructor(config = {}) {
@@ -26,35 +31,47 @@ class GithubCopilotProvider extends OpenAIProvider {
     this._refreshPromise = null;
   }
 
-  async _refreshCopilotToken() {
-    if (this._refreshPromise) return this._refreshPromise;
-
+  async _refreshCopilotToken(signal = null) {
     const now = Math.floor(Date.now() / 1000);
     // Refresh token if missing or expiring in less than 5 minutes
     if (this.copilotToken && this.tokenExpiresAt >= now + 300) {
       return;
     }
 
-    this._refreshPromise = (async () => {
-      try {
+    if (!this._refreshPromise) {
+      this._refreshPromise = (async () => {
         if (!this.githubToken) {
           throw new Error('GitHub Copilot access token is missing. Please run `neoagent login github-copilot`.');
         }
 
-        const res = await fetch('https://api.github.com/copilot_internal/v2/token', {
+        const { response, text } = await fetchResponseText(
+          'https://api.github.com/copilot_internal/v2/token',
+          {
           headers: {
             'Authorization': `token ${this.githubToken}`,
             'Accept': 'application/json',
             'User-Agent': 'NeoAgent/1.0.0'
-          }
-        });
-
-        if (!res.ok) {
-          const errorText = await res.text().catch(() => 'Unknown error');
-          throw new Error(`Failed to refresh GitHub Copilot token: HTTP ${res.status} - ${errorText}`);
+          },
+            maxResponseBytes: 1024 * 1024,
+            serviceName: 'GitHub Copilot token refresh',
+          },
+        );
+
+        if (!response.ok) {
+          const error = new Error(
+            `Failed to refresh GitHub Copilot token: HTTP ${response.status} - ${sanitizeProviderErrorDetail(text.slice(0, 500))}`,
+          );
+          error.status = response.status;
+          error.headers = response.headers;
+          throw error;
         }
 
-        const data = await res.json();
+        let data;
+        try {
+          data = JSON.parse(text || '{}');
+        } catch {
+          throw new Error('Invalid token response from GitHub Copilot.');
+        }
         if (!data || typeof data.token !== 'string' || !data.token) {
           throw new Error('Invalid token response from GitHub Copilot.');
         }
@@ -70,26 +87,30 @@ class GithubCopilotProvider extends OpenAIProvider {
 
         // Update the client's API key
         this.client.apiKey = this.copilotToken;
-      } finally {
+      })().finally(() => {
         this._refreshPromise = null;
-      }
-    })();
+      });
+    }
 
-    return this._refreshPromise;
+    return waitForAbortableResult(
+      this._refreshPromise,
+      signal,
+      'GitHub Copilot token refresh aborted.',
+    );
   }
 
   async chat(messages, tools = [], options = {}) {
-    await this._refreshCopilotToken();
+    await this._refreshCopilotToken(options.signal);
     return super.chat(messages, tools, options);
   }
 
   async *stream(messages, tools = [], options = {}) {
-    await this._refreshCopilotToken();
+    await this._refreshCopilotToken(options.signal);
     yield* super.stream(messages, tools, options);
   }
 
   async analyzeImage(options = {}) {
-    await this._refreshCopilotToken();
+    await this._refreshCopilotToken(options.signal);
     return super.analyzeImage(options);
   }
 }