mixdog 0.8.0 → 0.9.0

package/src/runtime/agent/orchestrator/providers/oauth-usage.mjs

@@ -1,13 +1,7 @@
 import {
-  closeSync,
   existsSync,
-  openSync,
   readFileSync,
-  readdirSync,
-  readSync,
-  statSync,
 } from 'fs';
-import { homedir } from 'os';
 import { join } from 'path';
 import { updateJsonAtomicSync } from '../../../shared/atomic-file.mjs';
 import { resolvePluginData } from '../../../shared/plugin-paths.mjs';
@@ -16,12 +10,10 @@ import { getLlmDispatcher } from '../../../shared/llm/http-agent.mjs';
 const CACHE_FILE = 'gateway-oauth-usage-cache.json';
 const LIVE_CACHE_TTL_MS = 60_000;
 const DISK_CACHE_TTL_MS = 10 * 60_000;
+const STALE_DISK_CACHE_TTL_MS = 7 * 24 * 60 * 60_000;
 const NEGATIVE_CACHE_TTL_MS = 5 * 60_000;
 const FETCH_TIMEOUT_MS = 4500;
 const WARN_TTL_MS = 5 * 60_000;
-const MAX_ROLLOUT_FILES = 8;
-const MAX_ROLLOUT_SCAN_FILES = 2500;
-const MAX_TAIL_BYTES = 2 * 1024 * 1024;
 
 const memoryCache = new Map();
 const inflight = new Map();
@@ -55,6 +47,17 @@ function routeKey(routeInfo = {}) {
   return `${providerKey(routeInfo)}\u0001${String(routeInfo?.model || '')}`;
 }
 
+function cacheModelId(value) {
+  const model = cleanString(value);
+  if (!model) return null;
+  // Route cache keys are model identifiers, not free-form display/user text.
+  // A malformed route once copied a user prompt into the provider-wide OAuth
+  // cache; keeping cache keys/display model IDs single-token prevents that
+  // poison from persisting or winning provider fallback lookups.
+  if (model.length > 160 || /\s/.test(model)) return null;
+  return model;
+}
+
 function cachePath() {
   return join(resolvePluginData(), CACHE_FILE);
 }
@@ -134,17 +137,41 @@ function freshSnapshot(snapshot, ttlMs) {
   return snapshot;
 }
 
-export function readCachedOAuthUsageSnapshot(routeInfo) {
+function newestProviderSnapshot(entries, provider, ttlMs) {
+  const providerOnly = String(provider || '').toLowerCase();
+  if (!providerOnly) return null;
+  const routePrefix = `${providerOnly}\u0001`;
+  let best = null;
+  let bestAt = 0;
+  const iterable = entries instanceof Map ? entries.entries() : Object.entries(entries || {});
+  for (const [key, snapshot] of iterable) {
+    if (key !== providerOnly && !String(key).startsWith(routePrefix)) continue;
+    const fresh = freshSnapshot(snapshot, ttlMs);
+    const at = num(fresh?.cachedAt, 0);
+    if (fresh && at >= bestAt) {
+      best = fresh;
+      bestAt = at;
+    }
+  }
+  return best;
+}
+
+export function readCachedOAuthUsageSnapshot(routeInfo, options = {}) {
   const key = routeKey(routeInfo);
   const providerOnlyKey = providerKey(routeInfo);
+  const diskTtlMs = options?.allowStale === true
+    ? STALE_DISK_CACHE_TTL_MS
+    : DISK_CACHE_TTL_MS;
   const mem = freshSnapshot(memoryCache.get(key), LIVE_CACHE_TTL_MS)
-    || freshSnapshot(memoryCache.get(providerOnlyKey), LIVE_CACHE_TTL_MS);
+    || freshSnapshot(memoryCache.get(providerOnlyKey), LIVE_CACHE_TTL_MS)
+    || newestProviderSnapshot(memoryCache, providerOnlyKey, LIVE_CACHE_TTL_MS);
   if (mem) return mem;
 
   const raw = readJsonFile(cachePath());
   const routes = raw?.routes && typeof raw.routes === 'object' ? raw.routes : {};
-  return freshSnapshot(routes[key], DISK_CACHE_TTL_MS)
-    || freshSnapshot(routes[providerOnlyKey], DISK_CACHE_TTL_MS)
+  return freshSnapshot(routes[key], diskTtlMs)
+    || freshSnapshot(routes[providerOnlyKey], diskTtlMs)
+    || newestProviderSnapshot(routes, providerOnlyKey, diskTtlMs)
     || null;
 }
 
@@ -366,105 +393,16 @@ function normalizeAnthropicUsage(data, source = 'anthropic-oauth') {
   };
 }
 
-function parseStatuslineRateLimits(raw, source) {
-  if (!raw || typeof raw !== 'object') return null;
-  const rateLimits = raw.rate_limits || raw.rateLimits;
-  if (!rateLimits || typeof rateLimits !== 'object') return null;
-  const windows = [
-    windowFromPercent('5H', rateLimits.five_hour || rateLimits.primary, source),
-    windowFromPercent('7D', rateLimits.seven_day || rateLimits.secondary, source),
-  ].filter(Boolean);
-  if (!windows.length) return null;
-  return { quotaWindows: windows, source };
-}
-
-function tailFileText(file, maxBytes = MAX_TAIL_BYTES) {
-  let fd = null;
-  try {
-    const st = statSync(file);
-    const size = st.size || 0;
-    const start = Math.max(0, size - maxBytes);
-    const len = size - start;
-    const buf = Buffer.alloc(len);
-    fd = openSync(file, 'r');
-    readSync(fd, buf, 0, len, start);
-    return buf.toString('utf8');
-  } catch {
-    return '';
-  } finally {
-    if (fd != null) {
-      try { closeSync(fd); } catch {}
-    }
-  }
-}
-
-function newestRolloutFiles(root) {
-  const out = [];
-  const stack = [root];
-  let seen = 0;
-  while (stack.length && seen < MAX_ROLLOUT_SCAN_FILES) {
-    const dir = stack.pop();
-    let entries = [];
-    try { entries = readdirSync(dir, { withFileTypes: true }); } catch { continue; }
-    for (const ent of entries) {
-      if (seen++ >= MAX_ROLLOUT_SCAN_FILES) break;
-      const full = join(dir, ent.name);
-      if (ent.isDirectory()) {
-        stack.push(full);
-      } else if (ent.isFile() && /^rollout-.*\.jsonl$/i.test(ent.name)) {
-        try {
-          const st = statSync(full);
-          out.push({ file: full, mtimeMs: st.mtimeMs || 0 });
-        } catch {}
-      }
-    }
-  }
-  return out
-    .sort((a, b) => b.mtimeMs - a.mtimeMs)
-    .slice(0, MAX_ROLLOUT_FILES)
-    .map(x => x.file);
-}
-
-function latestCodexRateLimitsFromRollout() {
-  const root = join(homedir(), '.codex', 'sessions');
-  if (!existsSync(root)) return null;
-  for (const file of newestRolloutFiles(root)) {
-    const lines = tailFileText(file).split(/\r?\n/).filter(Boolean);
-    for (let i = lines.length - 1; i >= 0; i--) {
-      try {
-        const row = JSON.parse(lines[i]);
-        const rateLimits = row?.payload?.rate_limits || row?.rate_limits;
-        const snap = normalizeCodexRateLimits(rateLimits, 'openai-codex-rollout');
-        if (snap && hasFutureWindow(snap)) return snap;
-      } catch {}
-    }
-  }
-  return null;
-}
-
 function latestClaudeStatuslineUsage() {
-  // Standalone CLI must not borrow Claude Code's rendered statusline cache.
+  // Standalone CLI must not borrow a host-agent rendered statusline cache.
   // Anthropic quota should come from the OAuth usage endpoint above.
   return null;
 }
 
-function grokCliIdentity(accessToken = '') {
-  const raw = readJsonFile(join(homedir(), '.grok', 'auth.json'));
-  if (!raw || typeof raw !== 'object') return {};
-  const entries = Object.values(raw).filter(v => v && typeof v === 'object');
-  const exact = accessToken ? entries.find(v => v.key === accessToken || v.access_token === accessToken) : null;
-  const entry = exact || entries.find(v => v.key || v.access_token) || null;
-  if (!entry) return {};
-  return {
-    userId: entry.user_id || entry.userId || entry.principal_id || entry.principalId || '',
-    token: entry.key || entry.access_token || entry.accessToken || '',
-  };
-}
-
 async function fetchOpenAICodexUsage(providerObj) {
   const auth = await providerObj?.ensureAuth?.({ reason: 'usage' });
   const token = auth?.access_token || auth?.accessToken;
-  if (!token) return latestCodexRateLimitsFromRollout();
+  if (!token) return null;
   const res = await fetch('https://chatgpt.com/backend-api/wham/usage', fetchOptions({
     Authorization: `Bearer ${token}`,
     originator: 'codex_cli_rs',
@@ -472,9 +410,9 @@ async function fetchOpenAICodexUsage(providerObj) {
     'OpenAI-Beta': 'responses=experimental',
     Accept: 'application/json',
   }));
-  if (!res.ok) throw new Error(`codex usage ${res.status}`);
+  if (!res.ok) throw new Error(`openai-oauth usage ${res.status}`);
   const data = await res.json();
-  return normalizeOpenAIWhamUsage(data) || latestCodexRateLimitsFromRollout();
+  return normalizeOpenAIWhamUsage(data);
 }
 
 async function fetchAnthropicUsage(providerObj) {
@@ -497,8 +435,7 @@ async function fetchGrokUsage(providerObj, routeInfo) {
   const auth = await providerObj?.ensureAuth?.({ reason: 'usage' });
   const token = auth?.access_token || auth?.accessToken || auth?.key;
   if (!token) return null;
-  const cliIdentity = grokCliIdentity(token);
-  const userId = auth?.user_id || auth?.userId || auth?.principal_id || auth?.principalId || cliIdentity.userId || '';
+  const userId = auth?.user_id || auth?.userId || auth?.principal_id || auth?.principalId || '';
   const cliHeaders = {
     Authorization: `Bearer ${token}`,
     'X-XAI-Token-Auth': 'xai-grok-cli',
@@ -583,7 +520,6 @@ export async function fetchOAuthUsageSnapshot(routeInfo, providerObj, log = () =
         snapshot = await fetchGrokUsage(providerObj, routeInfo);
       }
     } catch (err) {
-      if (provider === 'openai-oauth') snapshot = latestCodexRateLimitsFromRollout();
       if (provider === 'anthropic-oauth') snapshot = latestClaudeStatuslineUsage();
       if (!snapshot) {
         warnThrottled(log, `oauth-usage:${provider}`, `gateway ${provider} usage fetch unavailable: ${err?.message || err}`);
@@ -596,17 +532,26 @@ export async function fetchOAuthUsageSnapshot(routeInfo, providerObj, log = () =
       return null;
     }
 
-    const normalized = {
+    const model = cacheModelId(routeInfo?.model) || cacheModelId(snapshot.model);
+    const providerSnapshot = {
       ...snapshot,
       provider: routeInfo?.provider || snapshot.provider || provider,
-      model: routeInfo?.model || snapshot.model || null,
       cachedAt: Date.now(),
     };
-    memoryCache.set(key, normalized);
-    memoryCache.set(providerOnly, normalized);
-    writeSnapshotCache(key, normalized);
-    writeSnapshotCache(providerOnly, normalized);
-    return normalized;
+    delete providerSnapshot.model;
+
+    const routeSnapshot = model
+      ? { ...providerSnapshot, model }
+      : providerSnapshot;
+
+    if (model) {
+      const normalizedKey = `${provider}\u0001${model}`;
+      memoryCache.set(normalizedKey, routeSnapshot);
+      writeSnapshotCache(normalizedKey, routeSnapshot);
+    }
+    memoryCache.set(providerOnly, providerSnapshot);
+    writeSnapshotCache(providerOnly, providerSnapshot);
+    return routeSnapshot;
   })().finally(() => {
     inflight.delete(key);
   });

package/src/runtime/agent/orchestrator/providers/openai-compat-presets.mjs

@@ -0,0 +1,25 @@
+// Lightweight preset table shared by config/registry without importing the
+// OpenAI SDK or compat runtime implementation.
+export const OPENAI_COMPAT_PRESETS = {
+    deepseek: {
+        baseURL: 'https://api.deepseek.com',
+        defaultModel: 'deepseek-v4-pro',
+    },
+    xai: {
+        baseURL: 'https://api.x.ai/v1',
+        defaultModel: 'grok-4.3',
+    },
+    // OpenCode Go - low-cost coding-model subscription gateway.
+    'opencode-go': {
+        baseURL: 'https://opencode.ai/zen/go/v1',
+        defaultModel: 'glm-5.2',
+    },
+    ollama: {
+        baseURL: 'http://localhost:11434/v1',
+        defaultModel: 'llama3.3:latest',
+    },
+    lmstudio: {
+        baseURL: 'http://localhost:1234/v1',
+        defaultModel: 'default',
+    },
+};