nex-code 0.3.4 → 0.3.7

package/cli/providers/openai.js

@@ -1,237 +0,0 @@
-/**
- * cli/providers/openai.js — OpenAI-compatible Provider
- * Supports GPT-4o, o1, o3, GPT-4o-mini via OpenAI API with SSE streaming.
- */
-
-const axios = require('axios');
-const { BaseProvider } = require('./base');
-
-const OPENAI_MODELS = {
-  'gpt-4o': { id: 'gpt-4o', name: 'GPT-4o', maxTokens: 16384, contextWindow: 128000 },
-  'gpt-4o-mini': { id: 'gpt-4o-mini', name: 'GPT-4o Mini', maxTokens: 16384, contextWindow: 128000 },
-  'gpt-4.1': { id: 'gpt-4.1', name: 'GPT-4.1', maxTokens: 32768, contextWindow: 128000 },
-  'gpt-4.1-mini': { id: 'gpt-4.1-mini', name: 'GPT-4.1 Mini', maxTokens: 32768, contextWindow: 128000 },
-  'gpt-4.1-nano': { id: 'gpt-4.1-nano', name: 'GPT-4.1 Nano', maxTokens: 16384, contextWindow: 128000 },
-  'o1': { id: 'o1', name: 'o1', maxTokens: 100000, contextWindow: 200000 },
-  'o3': { id: 'o3', name: 'o3', maxTokens: 100000, contextWindow: 200000 },
-  'o3-mini': { id: 'o3-mini', name: 'o3 Mini', maxTokens: 65536, contextWindow: 200000 },
-  'o4-mini': { id: 'o4-mini', name: 'o4 Mini', maxTokens: 100000, contextWindow: 200000 },
-};
-
-class OpenAIProvider extends BaseProvider {
-  constructor(config = {}) {
-    super({
-      name: 'openai',
-      baseUrl: config.baseUrl || 'https://api.openai.com/v1',
-      models: config.models || OPENAI_MODELS,
-      defaultModel: config.defaultModel || 'gpt-4o',
-      ...config,
-    });
-    this.timeout = config.timeout || 180000;
-    this.temperature = config.temperature ?? 0.2;
-  }
-
-  isConfigured() {
-    return !!this.getApiKey();
-  }
-
-  getApiKey() {
-    return process.env.OPENAI_API_KEY || null;
-  }
-
-  _getHeaders() {
-    const key = this.getApiKey();
-    if (!key) throw new Error('OPENAI_API_KEY not set');
-    return {
-      Authorization: `Bearer ${key}`,
-      'Content-Type': 'application/json',
-    };
-  }
-
-  formatMessages(messages) {
-    return {
-      messages: messages.map((msg) => {
-        if (msg.role === 'assistant' && msg.tool_calls) {
-          return {
-            role: 'assistant',
-            content: msg.content || null,
-            tool_calls: msg.tool_calls.map((tc) => ({
-              id: tc.id || `call-${Date.now()}`,
-              type: 'function',
-              function: {
-                name: tc.function.name,
-                arguments:
-                  typeof tc.function.arguments === 'string'
-                    ? tc.function.arguments
-                    : JSON.stringify(tc.function.arguments),
-              },
-            })),
-          };
-        }
-        if (msg.role === 'tool') {
-          return {
-            role: 'tool',
-            content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
-            tool_call_id: msg.tool_call_id,
-          };
-        }
-        return { role: msg.role, content: msg.content };
-      }),
-    };
-  }
-
-  async chat(messages, tools, options = {}) {
-    const model = options.model || this.defaultModel;
-    const modelInfo = this.getModel(model);
-    const maxTokens = options.maxTokens || modelInfo?.maxTokens || 16384;
-    const { messages: formatted } = this.formatMessages(messages);
-
-    const body = {
-      model,
-      messages: formatted,
-      max_tokens: maxTokens,
-      temperature: options.temperature ?? this.temperature,
-    };
-
-    if (tools && tools.length > 0) {
-      body.tools = tools;
-    }
-
-    const response = await axios.post(`${this.baseUrl}/chat/completions`, body, {
-      timeout: options.timeout || this.timeout,
-      headers: this._getHeaders(),
-    });
-
-    return this.normalizeResponse(response.data);
-  }
-
-  async stream(messages, tools, options = {}) {
-    const model = options.model || this.defaultModel;
-    const modelInfo = this.getModel(model);
-    const maxTokens = options.maxTokens || modelInfo?.maxTokens || 16384;
-    const onToken = options.onToken || (() => {});
-    const { messages: formatted } = this.formatMessages(messages);
-
-    const body = {
-      model,
-      messages: formatted,
-      max_tokens: maxTokens,
-      temperature: options.temperature ?? this.temperature,
-      stream: true,
-    };
-
-    if (tools && tools.length > 0) {
-      body.tools = tools;
-    }
-
-    let response;
-    try {
-      response = await axios.post(`${this.baseUrl}/chat/completions`, body, {
-        timeout: options.timeout || this.timeout,
-        headers: this._getHeaders(),
-        responseType: 'stream',
-        signal: options.signal,
-      });
-    } catch (err) {
-      if (err.name === 'CanceledError' || err.name === 'AbortError' || err.code === 'ERR_CANCELED') throw err;
-      const msg = err.response?.data?.error?.message || err.message;
-      throw new Error(`API Error: ${msg}`);
-    }
-
-    return new Promise((resolve, reject) => {
-      let content = '';
-      const toolCallsMap = {}; // index -> { id, name, arguments }
-      let buffer = '';
-
-      // Abort listener: destroy stream on signal
-      if (options.signal) {
-        options.signal.addEventListener('abort', () => {
-          response.data.destroy();
-          reject(new DOMException('The operation was aborted', 'AbortError'));
-        }, { once: true });
-      }
-
-      response.data.on('data', (chunk) => {
-        buffer += chunk.toString();
-        const lines = buffer.split('\n');
-        buffer = lines.pop() || '';
-
-        for (const line of lines) {
-          const trimmed = line.trim();
-          if (!trimmed || !trimmed.startsWith('data: ')) continue;
-          const data = trimmed.slice(6);
-          if (data === '[DONE]') {
-            resolve({ content, tool_calls: this._buildToolCalls(toolCallsMap) });
-            return;
-          }
-
-          let parsed;
-          try {
-            parsed = JSON.parse(data);
-          } catch {
-            continue;
-          }
-
-          const delta = parsed.choices?.[0]?.delta;
-          if (!delta) continue;
-
-          if (delta.content) {
-            onToken(delta.content);
-            content += delta.content;
-          }
-
-          if (delta.tool_calls) {
-            for (const tc of delta.tool_calls) {
-              const idx = tc.index ?? 0;
-              if (!toolCallsMap[idx]) {
-                toolCallsMap[idx] = { id: tc.id || '', name: '', arguments: '' };
-              }
-              if (tc.id) toolCallsMap[idx].id = tc.id;
-              if (tc.function?.name) toolCallsMap[idx].name += tc.function.name;
-              if (tc.function?.arguments) toolCallsMap[idx].arguments += tc.function.arguments;
-            }
-          }
-        }
-      });
-
-      response.data.on('error', (err) => {
-        if (options.signal?.aborted) return; // Ignore errors after abort
-        reject(new Error(`Stream error: ${err.message}`));
-      });
-
-      response.data.on('end', () => {
-        resolve({ content, tool_calls: this._buildToolCalls(toolCallsMap) });
-      });
-    });
-  }
-
-  normalizeResponse(data) {
-    const choice = data.choices?.[0]?.message || {};
-    const toolCalls = (choice.tool_calls || []).map((tc) => ({
-      id: tc.id,
-      function: {
-        name: tc.function.name,
-        arguments: tc.function.arguments,
-      },
-    }));
-
-    return {
-      content: choice.content || '',
-      tool_calls: toolCalls,
-    };
-  }
-
-  _buildToolCalls(toolCallsMap) {
-    return Object.values(toolCallsMap)
-      .filter((tc) => tc.name)
-      .map((tc) => ({
-        id: tc.id || `openai-${Date.now()}`,
-        function: {
-          name: tc.name,
-          arguments: tc.arguments,
-        },
-      }));
-  }
-}
-
-module.exports = { OpenAIProvider, OPENAI_MODELS };

package/cli/providers/registry.js

@@ -1,454 +0,0 @@
-/**
- * cli/providers/registry.js — Provider Registry + Model Resolution
- * Central hub for multi-provider model management.
- *
- * Model specs: 'provider:model' (e.g. 'openai:gpt-4o', 'anthropic:claude-sonnet', 'local:llama3')
- * Short specs: 'model' (resolved against active provider)
- */
-
-const { OllamaProvider } = require('./ollama');
-const { OpenAIProvider } = require('./openai');
-const { AnthropicProvider } = require('./anthropic');
-const { GeminiProvider } = require('./gemini');
-const { LocalProvider } = require('./local');
-const { checkBudget } = require('../costs');
-
-// ─── Model Equivalence Map ─────────────────────────────────────
-// Maps models across providers by capability tier (top/strong/fast).
-// Used during fallback to pick an equivalent model on a different provider.
-
-const MODEL_EQUIVALENTS = {
-  top:    { ollama: 'kimi-k2.5',        openai: 'gpt-4.1',      anthropic: 'claude-sonnet-4-5', gemini: 'gemini-2.5-pro' },
-  strong: { ollama: 'qwen3-coder:480b', openai: 'gpt-4o',        anthropic: 'claude-sonnet',     gemini: 'gemini-2.5-flash' },
-  fast:   { ollama: 'devstral-small-2:24b', openai: 'gpt-4.1-mini', anthropic: 'claude-haiku',   gemini: 'gemini-2.0-flash' },
-};
-
-// Reverse lookup: model → tier
-const _modelToTier = {};
-for (const [tier, mapping] of Object.entries(MODEL_EQUIVALENTS)) {
-  for (const model of Object.values(mapping)) {
-    _modelToTier[model] = tier;
-  }
-}
-
-/**
- * Resolve the equivalent model for a target provider.
- * If sourceModel exists in MODEL_EQUIVALENTS, returns the target provider's
- * equivalent. Otherwise returns sourceModel unchanged.
- *
- * @param {string} sourceModel - The model ID to map (e.g. 'kimi-k2.5')
- * @param {string} targetProviderName - Target provider (e.g. 'openai')
- * @returns {string} resolved model ID
- */
-function resolveModelForProvider(sourceModel, targetProviderName) {
-  const tier = _modelToTier[sourceModel];
-  if (!tier) return sourceModel; // Unknown model — pass through unchanged
-  const equivalent = MODEL_EQUIVALENTS[tier][targetProviderName];
-  return equivalent || sourceModel; // No mapping for this provider — pass through
-}
-
-// ─── Registry State ────────────────────────────────────────────
-
-const providers = {};
-let activeProviderName = null;
-let activeModelId = null;
-let fallbackChain = [];
-
-// ─── Initialize Default Providers ──────────────────────────────
-
-function initDefaults() {
-  if (Object.keys(providers).length > 0) return;
-
-  registerProvider('ollama', new OllamaProvider());
-  registerProvider('openai', new OpenAIProvider());
-  registerProvider('anthropic', new AnthropicProvider());
-  registerProvider('gemini', new GeminiProvider());
-  registerProvider('local', new LocalProvider());
-
-  // Determine active provider from env or default to ollama
-  const defaultProvider = process.env.DEFAULT_PROVIDER || 'ollama';
-  const defaultModel = process.env.DEFAULT_MODEL || null;
-
-  if (providers[defaultProvider]) {
-    activeProviderName = defaultProvider;
-    activeModelId = defaultModel || providers[defaultProvider].defaultModel;
-  } else {
-    activeProviderName = 'ollama';
-    activeModelId = 'kimi-k2.5';
-  }
-
-  // Initialize fallback chain from env
-  const envChain = process.env.FALLBACK_CHAIN;
-  if (envChain) {
-    fallbackChain = envChain.split(',').map((s) => s.trim()).filter(Boolean);
-  }
-}
-
-// ─── Provider Management ───────────────────────────────────────
-
-function registerProvider(name, provider) {
-  providers[name] = provider;
-}
-
-function getProvider(name) {
-  initDefaults();
-  return providers[name] || null;
-}
-
-function getActiveProvider() {
-  initDefaults();
-  return providers[activeProviderName] || null;
-}
-
-function getActiveProviderName() {
-  initDefaults();
-  return activeProviderName;
-}
-
-function getActiveModelId() {
-  initDefaults();
-  return activeModelId;
-}
-
-/**
- * Get active model info (compatible with old getActiveModel format)
- * @returns {{ id: string, name: string, provider: string, maxTokens?: number, contextWindow?: number }}
- */
-function getActiveModel() {
-  initDefaults();
-  const provider = getActiveProvider();
-  if (!provider) return { id: activeModelId, name: activeModelId, provider: activeProviderName };
-
-  const model = provider.getModel(activeModelId);
-  if (model) {
-    return { ...model, provider: activeProviderName };
-  }
-
-  return { id: activeModelId, name: activeModelId, provider: activeProviderName };
-}
-
-// ─── Model Resolution ──────────────────────────────────────────
-
-/**
- * Parse a model spec like 'openai:gpt-4o' or just 'gpt-4o'
- * @param {string} spec
- * @returns {{ provider: string|null, model: string }}
- */
-function parseModelSpec(spec) {
-  if (!spec) return { provider: null, model: null };
-  const colonIdx = spec.indexOf(':');
-  if (colonIdx > 0) {
-    const prefix = spec.slice(0, colonIdx);
-    // Only treat as provider:model if prefix is a known provider name
-    if (providers[prefix] || ['ollama', 'openai', 'anthropic', 'gemini', 'local'].includes(prefix)) {
-      return { provider: prefix, model: spec.slice(colonIdx + 1) };
-    }
-  }
-  return { provider: null, model: spec };
-}
-
-/**
- * Set active model. Accepts 'provider:model' or just 'model'.
- * @param {string} spec - Model spec (e.g. 'openai:gpt-4o', 'kimi-k2.5')
- * @returns {boolean} true if model was set successfully
- */
-function setActiveModel(spec) {
-  initDefaults();
-  const { provider: providerName, model: modelId } = parseModelSpec(spec);
-
-  if (providerName) {
-    const provider = providers[providerName];
-    if (!provider) return false;
-
-    const model = provider.getModel(modelId);
-    if (!model) {
-      // Allow setting model even if not in predefined list (for local models)
-      if (providerName === 'local') {
-        activeProviderName = providerName;
-        activeModelId = modelId;
-        return true;
-      }
-      return false;
-    }
-
-    activeProviderName = providerName;
-    activeModelId = modelId;
-    return true;
-  }
-
-  // No provider prefix — search in active provider first, then all providers
-  const active = getActiveProvider();
-  if (active && active.getModel(modelId)) {
-    activeModelId = modelId;
-    return true;
-  }
-
-  for (const [name, provider] of Object.entries(providers)) {
-    if (provider.getModel(modelId)) {
-      activeProviderName = name;
-      activeModelId = modelId;
-      return true;
-    }
-  }
-
-  return false;
-}
-
-/**
- * Get all model names across all providers (for tab completion, etc.)
- * Returns just the model ids without provider prefix.
- */
-function getModelNames() {
-  initDefaults();
-  const names = new Set();
-  for (const provider of Object.values(providers)) {
-    for (const name of provider.getModelNames()) {
-      names.add(name);
-    }
-  }
-  return Array.from(names);
-}
-
-/**
- * Get all models grouped by provider
- * @returns {Array<{ provider: string, configured: boolean, models: Array }>}
- */
-function listProviders() {
-  initDefaults();
-  return Object.entries(providers).map(([name, provider]) => ({
-    provider: name,
-    configured: provider.isConfigured(),
-    models: Object.values(provider.getModels()).map((m) => ({
-      ...m,
-      active: name === activeProviderName && m.id === activeModelId,
-    })),
-  }));
-}
-
-/**
- * Get flat list of all models with provider prefix
- * @returns {Array<{ spec: string, name: string, provider: string, configured: boolean }>}
- */
-function listAllModels() {
-  initDefaults();
-  const result = [];
-  for (const [provName, provider] of Object.entries(providers)) {
-    const configured = provider.isConfigured();
-    for (const model of Object.values(provider.getModels())) {
-      result.push({
-        spec: `${provName}:${model.id}`,
-        name: model.name,
-        provider: provName,
-        configured,
-      });
-    }
-  }
-  return result;
-}
-
-// ─── Fallback Chain ─────────────────────────────────────────────
-
-function setFallbackChain(chain) {
-  fallbackChain = Array.isArray(chain) ? chain : [];
-}
-
-function getFallbackChain() {
-  return [...fallbackChain];
-}
-
-// ─── Streaming Call (convenience) ──────────────────────────────
-
-/**
- * Check if an error is retryable (rate limit, server error, or network failure).
- */
-function isRetryableError(err) {
-  const msg = err.message || '';
-  const code = err.code || '';
-
-  // HTTP status errors
-  if (msg.includes('429') || msg.includes('500') || msg.includes('502') ||
-      msg.includes('503') || msg.includes('504')) return true;
-
-  // Network/TLS/socket errors — transient, retryable
-  if (code === 'ECONNABORTED' || code === 'ETIMEDOUT' || code === 'ECONNREFUSED' ||
-      code === 'ECONNRESET' || code === 'EHOSTUNREACH' || code === 'ENETUNREACH' ||
-      code === 'EPIPE' || code === 'ERR_SOCKET_CONNECTION_TIMEOUT') return true;
-
-  if (msg.includes('socket disconnected') || msg.includes('TLS') ||
-      msg.includes('ECONNRESET') || msg.includes('ECONNABORTED') ||
-      msg.includes('network') || msg.includes('ETIMEDOUT')) return true;
-
-  return false;
-}
-
-/**
- * Make a streaming call through the active provider.
- * Falls back to next provider in chain on retryable errors.
- * Skips providers that are over budget.
- */
-async function callStream(messages, tools, options = {}) {
-  initDefaults();
-  const providersToTry = [activeProviderName, ...fallbackChain.filter((p) => p !== activeProviderName)];
-
-  let lastError;
-  let budgetBlockedCount = 0;
-  let configuredCount = 0;
-  for (let idx = 0; idx < providersToTry.length; idx++) {
-    const provName = providersToTry[idx];
-    const provider = providers[provName];
-    if (!provider || !provider.isConfigured()) continue;
-    configuredCount++;
-
-    // Budget gate: skip providers that are over budget
-    const budget = checkBudget(provName);
-    if (!budget.allowed) {
-      budgetBlockedCount++;
-      lastError = new Error(`Budget limit reached for ${provName}: $${budget.spent.toFixed(2)} / $${budget.limit.toFixed(2)}`);
-      continue;
-    }
-
-    try {
-      const isFallback = idx > 0;
-      const model = isFallback ? resolveModelForProvider(activeModelId, provName) : activeModelId;
-      if (isFallback && model !== activeModelId) {
-        process.stderr.write(`  [fallback: ${provName}:${model}]\n`);
-      }
-      return await provider.stream(messages, tools, { model, signal: options.signal, ...options });
-    } catch (err) {
-      lastError = err;
-      if (isRetryableError(err) && idx < providersToTry.length - 1) {
-        continue;
-      }
-      throw err;
-    }
-  }
-
-  if (budgetBlockedCount > 0 && budgetBlockedCount === configuredCount) {
-    throw new Error('All providers are over budget. Use /budget to check limits or /budget <provider> off to remove a limit.');
-  }
-  throw lastError || new Error('No configured provider available');
-}
-
-/**
- * Make a non-streaming call through the active provider.
- * Falls back to next provider in chain on retryable errors.
- * Skips providers that are over budget.
- */
-async function callChat(messages, tools, options = {}) {
-  initDefaults();
-
-  // Direct provider override: skip fallback chain
-  if (options.provider) {
-    const provider = providers[options.provider];
-    if (!provider || !provider.isConfigured()) {
-      throw new Error(`Provider '${options.provider}' is not available`);
-    }
-    const chatOpts = { model: options.model || activeModelId, ...options };
-    try {
-      return await provider.chat(messages, tools, chatOpts);
-    } catch (chatErr) {
-      // Fallback: some providers handle stream:true better than stream:false
-      // Use streaming endpoint but collect the full response silently
-      if (typeof provider.stream === 'function') {
-        try {
-          return await provider.stream(messages, tools, { ...chatOpts, onToken: () => {} });
-        } catch { /* stream fallback also failed — throw original error */ }
-      }
-      throw chatErr;
-    }
-  }
-
-  const providersToTry = [activeProviderName, ...fallbackChain.filter((p) => p !== activeProviderName)];
-
-  let lastError;
-  let budgetBlockedCount = 0;
-  let configuredCount = 0;
-  for (let idx = 0; idx < providersToTry.length; idx++) {
-    const provName = providersToTry[idx];
-    const provider = providers[provName];
-    if (!provider || !provider.isConfigured()) continue;
-    configuredCount++;
-
-    // Budget gate: skip providers that are over budget
-    const budget = checkBudget(provName);
-    if (!budget.allowed) {
-      budgetBlockedCount++;
-      lastError = new Error(`Budget limit reached for ${provName}: $${budget.spent.toFixed(2)} / $${budget.limit.toFixed(2)}`);
-      continue;
-    }
-
-    try {
-      const isFallback = idx > 0;
-      const model = isFallback ? resolveModelForProvider(activeModelId, provName) : activeModelId;
-      if (isFallback && model !== activeModelId) {
-        process.stderr.write(`  [fallback: ${provName}:${model}]\n`);
-      }
-      return await provider.chat(messages, tools, { model, ...options });
-    } catch (err) {
-      // Fallback: try streaming endpoint before giving up on this provider
-      const fallbackModel = idx > 0 ? resolveModelForProvider(activeModelId, provName) : activeModelId;
-      if (typeof provider.stream === 'function') {
-        try {
-          return await provider.stream(messages, tools, { model: fallbackModel, ...options, onToken: () => {} });
-        } catch { /* stream fallback also failed — continue with original error */ }
-      }
-      lastError = err;
-      if (isRetryableError(err) && idx < providersToTry.length - 1) {
-        continue;
-      }
-      throw err;
-    }
-  }
-
-  if (budgetBlockedCount > 0 && budgetBlockedCount === configuredCount) {
-    throw new Error('All providers are over budget. Use /budget to check limits or /budget <provider> off to remove a limit.');
-  }
-  throw lastError || new Error('No configured provider available');
-}
-
-/**
- * Get all configured providers with their models.
- * @returns {Array<{ name: string, models: Array<{ id: string, name: string, maxTokens?: number, contextWindow?: number }> }>}
- */
-function getConfiguredProviders() {
-  initDefaults();
-  const result = [];
-  for (const [name, provider] of Object.entries(providers)) {
-    if (provider.isConfigured()) {
-      result.push({ name, models: Object.values(provider.getModels()) });
-    }
-  }
-  return result;
-}
-
-// ─── Reset (for testing) ───────────────────────────────────────
-
-function _reset() {
-  for (const key of Object.keys(providers)) {
-    delete providers[key];
-  }
-  activeProviderName = null;
-  activeModelId = null;
-  fallbackChain = [];
-}
-
-module.exports = {
-  registerProvider,
-  getProvider,
-  getActiveProvider,
-  getActiveProviderName,
-  getActiveModelId,
-  getActiveModel,
-  setActiveModel,
-  getModelNames,
-  parseModelSpec,
-  listProviders,
-  listAllModels,
-  callStream,
-  callChat,
-  getConfiguredProviders,
-  setFallbackChain,
-  getFallbackChain,
-  resolveModelForProvider,
-  _reset,
-};