vibehacker 4.1.0 → 4.2.0

package/src/src/api.js

@@ -0,0 +1,314 @@
+'use strict';
+
+const axios = require('axios');
+const config = require('./config');
+
+// ── Error Types ──────────────────────────────────────────────────────────────
+const ERR = {
+  DAILY_LIMIT: 'DAILY_LIMIT',
+  RATE_LIMIT:  'RATE_LIMIT',
+  AUTH:        'AUTH',
+  NOT_FOUND:   'NOT_FOUND',
+  CREDITS:     'CREDITS',
+  SERVER:      'SERVER',
+  TIMEOUT:     'TIMEOUT',
+  ABORTED:     'ABORTED',
+  UNKNOWN:     'UNKNOWN',
+};
+
+// ── Provider Health Tracker ──────────────────────────────────────────────────
+// Tracks success/failure rates, latency, and circuit breaker state per provider.
+// Persists across requests within a session. Enables smart provider selection.
+
+const _providerHealth = new Map(); // key: baseURL → { successes, failures, avgLatency, lastFailure, circuitOpen }
+
+function getHealth(url) {
+  if (!_providerHealth.has(url)) {
+    _providerHealth.set(url, {
+      successes: 0, failures: 0,
+      avgLatency: 0, lastFailure: 0,
+      circuitOpen: false, circuitOpenUntil: 0,
+    });
+  }
+  return _providerHealth.get(url);
+}
+
+function recordSuccess(url, latencyMs) {
+  const h = getHealth(url);
+  h.successes++;
+  h.avgLatency = h.avgLatency ? (h.avgLatency * 0.7 + latencyMs * 0.3) : latencyMs;
+  h.circuitOpen = false;
+  h.failures = Math.max(0, h.failures - 1); // decay failures on success
+}
+
+function recordFailure(url) {
+  const h = getHealth(url);
+  h.failures++;
+  h.lastFailure = Date.now();
+  // Circuit breaker: open after 3 consecutive failures, cool down 30s
+  if (h.failures >= 3) {
+    h.circuitOpen = true;
+    h.circuitOpenUntil = Date.now() + 30000;
+  }
+}
+
+function isCircuitOpen(url) {
+  const h = getHealth(url);
+  if (!h.circuitOpen) return false;
+  if (Date.now() > h.circuitOpenUntil) {
+    h.circuitOpen = false; // half-open: allow one request to test
+    h.failures = 2; // almost open again if it fails
+    return false;
+  }
+  return true;
+}
+
+// ── Provider Detection (cached per baseURL) ──────────────────────────────────
+const _providerCache = new Map();
+
+function currentProviderType() {
+  const url = config.baseURL || '';
+  if (_providerCache.has(url)) return _providerCache.get(url);
+
+  const lower = url.toLowerCase();
+  let type = 'openai_compat';
+  if (lower.includes('vibsecurity.com'))     type = 'vibehacker';
+  else if (lower.includes('anthropic.com'))  type = 'anthropic';
+  else if (lower.includes('openai.com'))     type = 'openai';
+  else if (lower.includes('groq.com'))       type = 'groq';
+  else if (lower.includes('cerebras.ai'))    type = 'cerebras';
+  else if (lower.includes('mistral.ai'))     type = 'mistral';
+  else if (lower.includes('generativelanguage')) type = 'gemini';
+
+  _providerCache.set(url, type);
+  return type;
+}
+
+// ── Error Classification ─────────────────────────────────────────────────────
+function classifyError(err, providerType) {
+  if (err.message?.includes('aborted') || err.code === 'ERR_CANCELED') {
+    return { type: ERR.ABORTED };
+  }
+  if (err.code === 'ECONNABORTED' || err.code === 'ETIMEDOUT' || err.code === 'ECONNREFUSED') {
+    return { type: ERR.TIMEOUT, msg: 'Connection failed — trying next provider.' };
+  }
+
+  const status  = err.response?.status;
+  const errBody = err.response?.data?.error || err.response?.data || {};
+  const rawMsg  = errBody.message || errBody.msg || err.message || '';
+  const lower   = rawMsg.toLowerCase();
+
+  if (status === 401 || status === 403) return { type: ERR.AUTH, msg: 'Invalid API key. Run /key to update.' };
+  if (status === 402) return { type: ERR.CREDITS, msg: 'Insufficient credits.' };
+  if (status === 404 || status === 410) return { type: ERR.NOT_FOUND, msg: 'Model unavailable.' };
+  if (status === 408) return { type: ERR.TIMEOUT, msg: 'Request timed out.' };
+
+  if (status === 429 || status === 529) {
+    if (lower.includes('free-models-per-day') || lower.includes('per-day') || lower.includes('daily') || lower.includes('limit exceeded')) {
+      return { type: ERR.DAILY_LIMIT, msg: rawMsg || 'Daily limit reached.' };
+    }
+    return { type: ERR.RATE_LIMIT, msg: rawMsg.substring(0, 100) || 'Rate limited.' };
+  }
+  if (status >= 500) return { type: ERR.SERVER, msg: `Server error (${status}).` };
+  return { type: ERR.UNKNOWN, msg: `Error ${status || '?'}: ${rawMsg.substring(0, 100)}` };
+}
+
+// ── Unified SSE Stream Parser ────────────────────────────────────────────────
+// Single optimized parser for both OpenAI and Anthropic SSE formats.
+// Uses indexOf() scanning instead of split() for O(n) instead of O(n²).
+
+function parseSseStream(stream, { isAnthropic, onToken, onDone, onError, signal }) {
+  let done   = false;
+  let buffer = '';
+  let full   = '';
+  let pendingEvent = '';
+
+  const finish = (fn, ...args) => { if (!done) { done = true; fn(...args); } };
+
+  stream.on('data', (chunk) => {
+    if (done) return;
+    buffer += chunk.toString('utf8');
+
+    // Optimized line parsing: indexOf instead of split
+    let nlIdx;
+    while ((nlIdx = buffer.indexOf('\n')) !== -1) {
+      const line = buffer.substring(0, nlIdx).trim();
+      buffer = buffer.substring(nlIdx + 1);
+
+      if (!line) continue;
+
+      // Anthropic event tracking
+      if (isAnthropic && line.startsWith('event: ')) {
+        pendingEvent = line.substring(7).trim();
+        continue;
+      }
+
+      if (!line.startsWith('data: ')) continue;
+      const raw = line.substring(6).trim();
+
+      if (raw === '[DONE]') { finish(onDone, full); return; }
+
+      try {
+        const parsed = JSON.parse(raw);
+
+        if (parsed.error) {
+          const errStatus = parsed.error.code || parsed.error.type === 'rate_limit_error' ? 429 : 500;
+          finish(onError, classifyError({ response: { status: errStatus, data: { error: parsed.error } } }));
+          return;
+        }
+
+        if (isAnthropic) {
+          if (pendingEvent === 'content_block_delta' && parsed.delta?.text) {
+            const token = parsed.delta.text;
+            full += token;
+            onToken(token, full);
+          }
+          if (pendingEvent === 'message_stop' || parsed.type === 'message_stop') {
+            finish(onDone, full);
+          }
+        } else {
+          const token  = parsed.choices?.[0]?.delta?.content;
+          if (token) { full += token; onToken(token, full); }
+          const reason = parsed.choices?.[0]?.finish_reason;
+          if (reason && reason !== 'null') { finish(onDone, full); }
+        }
+      } catch (_) {}
+    }
+  });
+
+  stream.on('end',   () => finish(onDone, full));
+  stream.on('error', (err) => finish(onError, axios.isCancel(err) ? { type: ERR.ABORTED } : classifyError(err)));
+}
+
+// ── Stream Chat — Unified Entry Point ────────────────────────────────────────
+async function streamChat({ messages, model, signal, maxTokens, onToken, onDone, onError }) {
+  const ptype    = currentProviderType();
+  const isAnth   = ptype === 'anthropic';
+  const startMs  = Date.now();
+  let finished   = false;
+
+  // Circuit breaker check
+  if (isCircuitOpen(config.baseURL)) {
+    onError({ type: ERR.RATE_LIMIT, msg: 'Provider temporarily unavailable (circuit breaker).' });
+    return;
+  }
+
+  // Abort handling
+  const cancelSource = axios.CancelToken.source();
+  if (signal) {
+    if (signal.aborted) { onError({ type: ERR.ABORTED }); return; }
+    signal.addEventListener('abort', () => cancelSource.cancel('aborted'), { once: true });
+  }
+
+  // Build headers
+  const headers = { 'Content-Type': 'application/json' };
+  if (isAnth) {
+    headers['x-api-key']         = config.apiKey;
+    headers['anthropic-version'] = '2023-06-01';
+  } else {
+    headers['Authorization'] = `Bearer ${config.apiKey}`;
+    if (ptype === 'openai_compat' || ptype === 'vibehacker') {
+      headers['HTTP-Referer'] = config.httpReferer;
+      headers['X-Title']      = config.xTitle;
+    }
+  }
+
+  // Build body
+  let body, url;
+  if (isAnth) {
+    let system = '';
+    const chatMsgs = messages.filter(m => {
+      if (m.role === 'system') { system = m.content; return false; }
+      return true;
+    });
+    body = { model, max_tokens: maxTokens || config.maxTokens, stream: true, messages: chatMsgs };
+    if (system) body.system = system;
+    url = `${config.baseURL}/messages`;
+  } else {
+    body = {
+      model, messages,
+      stream:      true,
+      temperature: config.temperature,
+      max_tokens:  maxTokens || config.maxTokens,
+    };
+    // OpenRouter optimizations
+    if (ptype === 'openai_compat' || ptype === 'vibehacker') {
+      body.provider = { sort: 'throughput', allow_fallbacks: true, require_parameters: false };
+    }
+    url = `${config.baseURL}/chat/completions`;
+  }
+
+  // Make request
+  let source;
+  try {
+    source = await axios({
+      method: 'POST', url, headers, data: body,
+      responseType: 'stream',
+      timeout: isAnth ? 120000 : 90000,
+      cancelToken: cancelSource.token,
+    });
+  } catch (err) {
+    recordFailure(config.baseURL);
+    if (axios.isCancel(err)) { onError({ type: ERR.ABORTED }); return; }
+    onError(classifyError(err, ptype));
+    return;
+  }
+
+  // Parse stream
+  parseSseStream(source.data, {
+    isAnthropic: isAnth,
+    signal,
+    onToken,
+    onDone: (full) => {
+      if (!finished) {
+        finished = true;
+        recordSuccess(config.baseURL, Date.now() - startMs);
+        onDone(full);
+      }
+    },
+    onError: (err) => {
+      if (!finished) {
+        finished = true;
+        recordFailure(config.baseURL);
+        onError(err);
+      }
+    },
+  });
+}
+
+// ── Key Validation ───────────────────────────────────────────────────────────
+async function checkKey(apiKey) {
+  const ptype = currentProviderType();
+  try {
+    if (ptype === 'anthropic') {
+      await axios.post(`${config.baseURL}/messages`, {
+        model: 'claude-haiku-3-5', max_tokens: 1,
+        messages: [{ role: 'user', content: 'hi' }],
+      }, {
+        headers: { 'x-api-key': apiKey, 'anthropic-version': '2023-06-01', 'Content-Type': 'application/json' },
+        timeout: 8000,
+      });
+      return { ok: true, data: { label: 'Anthropic key valid' } };
+    }
+    const r = await axios.get(`${config.baseURL}/auth/key`, {
+      headers: { 'Authorization': `Bearer ${apiKey}` }, timeout: 8000,
+    });
+    return { ok: true, data: r.data?.data };
+  } catch (e) {
+    const status = e.response?.status;
+    if (status === 401 || status === 403) return { ok: false, status, msg: 'Invalid API key' };
+    if (status && status !== 401 && status !== 403) return { ok: true, data: { label: 'Key accepted' } };
+    return { ok: false, status, msg: e.response?.data?.error?.message || e.message };
+  }
+}
+
+async function fetchFreeModels(apiKey) {
+  try {
+    const r = await axios.get('https://openrouter.ai/api/v1/models', {
+      headers: { 'Authorization': `Bearer ${apiKey || config.apiKey}` }, timeout: 12000,
+    });
+    return (r.data?.data || []).filter(m => m.id.endsWith(':free') && m.pricing?.prompt === '0');
+  } catch (_) { return []; }
+}
+
+module.exports = { streamChat, checkKey, fetchFreeModels, ERR, currentProviderType, isCircuitOpen, getHealth };