@goodandready/dsh-subscriptions 0.6.91 → 0.7.3

package/lib/index.js

@@ -12,8 +12,11 @@ import { getVendor, registerCustomVendor, clearCustomVendors } from './vendors/i
 import { generateOnce, SIZES as IMAGE_SIZES } from './images.js'
 import { parseBlob } from './blob.js'
 import { createVendorFromProfile, validateProfiles } from './vendor-factory.js'
+import { registerVendorPack } from './vendor-pack.js'
 import { registerCustomProviderIds, registerDisplayName } from './refs.js'
 import { createSubscriptionsService } from './subscriptions.js'
+import { registerSubscriptionTools } from './native-tools.js'
+import { detectConflicts, readProfilePluginNames, setActiveConflicts } from './coexistence.js'
 import { createAccountStore, normalizeSlots, vendorConfig } from './accounts.js'
 import { OllamaAdapter, ollamaAlive, ollamaModels, ollamaBase } from './ollama.js'
 import { createResetCreditService } from './reset-credits.js'
@@ -39,7 +42,7 @@ export { pushToWebdav, pullFromWebdav, pushToGist, pullFromGist, buildS3SigV4Hea
 import { syncVaultPush, syncVaultPull, getVaultSyncStatus } from './vault-sync.js'
 
 export const name = '@goodandready/dsh-subscriptions'
-export const inject = ['llm', 'credentials', 'webServer', 'settings']
+export const inject = ['llm', 'credentials', 'webServer', 'settings', 'tools']
 
 const NS = 'dsh-subscriptions'
 
@@ -75,6 +78,11 @@ const OK_HTML = `<!doctype html>
 
 export function apply(ctx, rawConfig) {
   const logger = typeof ctx.logger === 'function' ? ctx.logger('subscriptions') : (ctx.logger || undefined)
+  const conflicts = detectConflicts({ dependencies: readProfilePluginNames() })
+  setActiveConflicts(conflicts)
+  if (conflicts.length && logger && logger.warn) {
+    logger.warn('[dsh-subscriptions] conflicting subscription plugins detected: ' + conflicts.join(', ') + '; keep one provider owner')
+  }
 
   // rawConfig still holds Volatile boxes, so unwrap before validating.
   const resolveEntry = () => {
@@ -98,6 +106,17 @@ export function apply(ctx, rawConfig) {
         if (logger && logger.warn) logger.warn('[dsh-subscriptions] customVendors[' + profile.id + ']: ' + String(e && e.message || e))
       }
     }
+    for (const pack of (live().providerPacks || [])) {
+      try {
+        registerVendorPack(pack, {
+          registerVendor: registerCustomVendor,
+          registerProviderId: registerCustomProviderIds,
+          registerDisplayName,
+        })
+      } catch (e) {
+        if (logger && logger.warn) logger.warn('[dsh-subscriptions] providerPacks[' + (pack && pack.id) + ']: ' + String(e && e.message || e))
+      }
+    }
   }
   syncCustomVendors()
 
@@ -377,6 +396,10 @@ export function apply(ctx, rawConfig) {
       })
     },
   }), 'dsh-subscriptions: image generation service')
+  ctx.effect(() => registerSubscriptionTools(ctx, {
+    subscriptions,
+    images: () => ctx.subscriptionImages,
+  }), 'dsh-subscriptions: native tools')
 
   const pending = new Map()
 

package/lib/messages.js

@@ -301,7 +301,7 @@ export function codexResponsesBody(options, fallbackInstructions, vendorCfg) {
     ...(vendorCfg && /^(low|medium|high)$/.test(String(vendorCfg.verbosity || ''))
       ? { text: { verbosity: String(vendorCfg.verbosity) } } : {}),
     // #92: Fast Mode = 1.5x speed billing tier on the Codex backend.
-    ...(vendorCfg && vendorCfg.fastMode ? { service_tier: 'priority' } : {}),
+    ...((vendorCfg && vendorCfg.fastMode) || options.service_tier === 'priority' ? { service_tier: 'priority' } : {}),
     ...(options.maxTokens != null ? { max_output_tokens: options.maxTokens } : {}),
     ...(options.temperature != null ? { temperature: options.temperature } : {}),
   }

package/lib/model-settings.js

@@ -0,0 +1,49 @@
+function rowsFor(rows, provider) {
+  return (Array.isArray(rows) ? rows : []).filter((row) => row && row.provider === provider)
+}
+
+const PLAN_RANK = { free: 0, plus: 1, pro: 2, max: 3, team: 3, enterprise: 4 }
+
+export function planRank(name) {
+  return PLAN_RANK[String(name || '').toLowerCase()] ?? 0
+}
+
+export function bestAccountPlan(accounts) {
+  let best = null
+  for (const account of accounts || []) {
+    const plan = account && (account.plan || account.paidTierName)
+    if (!plan) continue
+    if (!best || planRank(plan) > planRank(best)) best = String(plan)
+  }
+  return best
+}
+
+export function applyModelSettings(provider, models, cfg = {}, accountPlan = null) {
+  const list = Array.isArray(models) ? models : []
+  const hidden = new Set(rowsFor(cfg.hiddenModels, provider).map((row) => String(row.id)))
+  const plans = new Map(rowsFor(cfg.modelPlans, provider).map((row) => [String(row.id), String(row.minPlan || '')]))
+  const accountRank = accountPlan ? planRank(accountPlan) : null
+  const names = new Map(rowsFor(cfg.modelDisplayNames, provider).map((row) => [String(row.id), String(row.name)]))
+  const contexts = new Map(rowsFor(cfg.modelContextWindows, provider).map((row) => [String(row.id), Number(row.contextWindow)]))
+  const efforts = new Map(rowsFor(cfg.modelReasoningDefaults, provider).map((row) => [String(row.id), String(row.effort).toLowerCase()]))
+  return list
+    .filter((model) => {
+      if (!model || hidden.has(String(model.id))) return false
+      const minPlan = plans.get(String(model.id))
+      if (minPlan && accountRank != null && planRank(minPlan) > accountRank) return false
+      return true
+    })
+    .map((model) => {
+      const id = String(model.id)
+      const minPlan = plans.get(id)
+      const contextWindow = contexts.get(id)
+      const effort = efforts.get(id)
+      return {
+        ...model,
+        name: names.get(id) || model.name || model.id,
+        ...(Number.isFinite(contextWindow) && contextWindow > 0 ? { contextWindow } : {}),
+        ...(effort ? { reasoning: { ...(model.reasoning || {}), defaultEffort: effort } } : {}),
+        ...(minPlan ? { plan: minPlan, minPlan } : {}),
+      }
+    })
+}

package/lib/native-tools.js

@@ -0,0 +1,220 @@
+import { mkdir, writeFile } from 'node:fs/promises'
+import path from 'node:path'
+
+const TOOL_OUTPUT = {
+  schema: {
+    type: 'object',
+    additionalProperties: true,
+    properties: { text: { type: 'string' } },
+    required: ['text'],
+  },
+  render(_args, value) {
+    return [{ type: 'text', text: String((value && value.text) || '') }]
+  },
+}
+
+function textResult(text) {
+  return { text: String(text) }
+}
+
+export function extractResponseText(payload) {
+  const body = payload && typeof payload === 'object' ? payload : {}
+  if (typeof body.output_text === 'string' && body.output_text) return body.output_text
+  if (typeof body.answer === 'string' && body.answer) return body.answer
+  if (Array.isArray(body.output)) {
+    const parts = []
+    for (const item of body.output) {
+      for (const content of (item && item.content) || []) {
+        if (content && typeof content.text === 'string') parts.push(content.text)
+      }
+    }
+    if (parts.length) return parts.join('\n')
+  }
+  if (Array.isArray(body.choices)) {
+    return body.choices.map((choice) => choice && choice.message && choice.message.content)
+      .filter((value) => typeof value === 'string').join('\n')
+  }
+  return JSON.stringify(body).slice(0, 4000)
+}
+
+function outputDir(exec) {
+  const cwd = (exec && exec.agent && exec.agent.session && exec.agent.session.header
+    && exec.agent.session.header.cwd) || process.cwd()
+  return path.join(cwd, 'generated', 'subscriptions')
+}
+
+async function saveImages(images, exec) {
+  const dir = outputDir(exec)
+  await mkdir(dir, { recursive: true })
+  const out = []
+  for (let i = 0; i < images.length; i += 1) {
+    const image = images[i]
+    if (!image || typeof image.b64_json !== 'string') continue
+    const file = path.join(dir, `image-${Date.now()}-${i}.png`)
+    await writeFile(file, Buffer.from(image.b64_json, 'base64'))
+    out.push(file)
+  }
+  return out
+}
+
+export function registerSubscriptionTools(ctx, deps) {
+  const tools = ctx && ctx.tools
+  if (!tools || typeof tools.register !== 'function') return () => {}
+  const disposers = []
+  const register = (definition) => {
+    try {
+      const off = tools.register(definition)
+      if (typeof off === 'function') disposers.push(off)
+    } catch (err) {
+      // Another plugin may already own this tool name (for example x_search
+      // from a Grok search plugin or image_generate from an image plugin).
+      // Keep our remaining tools registered instead of failing the whole plugin.
+      if (!/already registered/i.test(String(err && err.message || err))) throw err
+    }
+  }
+
+  register({
+    name: 'image_generate',
+    description: 'Generate an image with the active ChatGPT/Codex or Grok subscription. Returns saved file paths.',
+    output: TOOL_OUTPUT,
+    parameters: {
+      type: 'object',
+      properties: {
+        prompt: { type: 'string', description: 'Image prompt' },
+        provider: { type: 'string', enum: ['gpt', 'codex', 'grok'], description: 'Preferred provider' },
+        size: { type: 'string', description: 'Image size, e.g. 1024x1024' },
+        quality: { type: 'string', description: 'low, medium or high' },
+      },
+      required: ['prompt'],
+    },
+    async execute(args, exec) {
+      const images = deps.images && deps.images()
+      if (!images || typeof images.generate !== 'function') throw new Error('subscription image service is unavailable')
+      const preferred = String((args && args.provider) || 'gpt').toLowerCase()
+      const order = preferred === 'grok' ? ['grok', 'codex'] : ['codex', 'grok']
+      let lastError = null
+      for (const provider of order) {
+        try {
+          const rows = await images.generate({
+            provider,
+            prompt: args && args.prompt,
+            size: args && args.size,
+            quality: args && args.quality,
+            signal: exec && exec.signal,
+          })
+          const files = await saveImages(rows, exec)
+          if (!files.length) throw new Error('image response contained no images')
+          return textResult(files.map((file) => `Generated image: ${file}`).join('\n'))
+        } catch (err) {
+          lastError = err
+        }
+      }
+      throw lastError || new Error('no subscription image provider is available')
+    },
+  })
+
+  register({
+    name: 'x_search',
+    description: 'Search X posts through the active Grok subscription and return an answer with citations.',
+    output: TOOL_OUTPUT,
+    parameters: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Search query' },
+        model: { type: 'string', description: 'Optional Grok model id' },
+      },
+      required: ['query'],
+    },
+    async execute(args, exec) {
+      const res = await deps.subscriptions.request({
+        provider: 'grok',
+        path: '/v1/responses',
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+        body: {
+          model: (args && args.model) || 'grok-4.6',
+          input: args && args.query,
+          tools: [{ type: 'x_search' }],
+          stream: false,
+        },
+        signal: exec && exec.signal,
+      })
+      const data = await res.json().catch(() => ({}))
+      if (!res.ok) throw new Error(`x_search HTTP ${res.status}: ${extractResponseText(data)}`)
+      return textResult(extractResponseText(data))
+    },
+  })
+
+  register({
+    name: 'web_search',
+    description: 'Search the web through the active ChatGPT/Codex subscription and return an answer with citations.',
+    output: TOOL_OUTPUT,
+    parameters: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Search query' },
+        model: { type: 'string', description: 'Optional Codex model id' },
+      },
+      required: ['query'],
+    },
+    async execute(args, exec) {
+      const res = await deps.subscriptions.request({
+        provider: 'codex',
+        path: '/responses',
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+        body: {
+          model: (args && args.model) || 'gpt-5.6',
+          input: args && args.query,
+          tools: [{ type: 'web_search_preview' }],
+          stream: false,
+        },
+        signal: exec && exec.signal,
+      })
+      const data = await res.json().catch(() => ({}))
+      if (!res.ok) throw new Error(`web_search HTTP ${res.status}: ${extractResponseText(data)}`)
+      return textResult(extractResponseText(data))
+    },
+  })
+
+  register({
+    name: 'video_generate',
+    description: 'Submit a short video generation request through the active Grok subscription.',
+    output: TOOL_OUTPUT,
+    parameters: {
+      type: 'object',
+      properties: {
+        prompt: { type: 'string', description: 'Video prompt' },
+        duration: { type: 'number', description: 'Duration in seconds (1-15)' },
+        aspect_ratio: { type: 'string', description: 'e.g. 16:9, 1:1, 9:16' },
+        image_url: { type: 'string', description: 'Optional source image URL' },
+      },
+      required: ['prompt'],
+    },
+    async execute(args, exec) {
+      const res = await deps.subscriptions.request({
+        provider: 'grok',
+        path: '/v1/videos',
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+        body: {
+          model: 'grok-imagine-video-1.5',
+          prompt: args && args.prompt,
+          duration: args && args.duration,
+          aspect_ratio: args && args.aspect_ratio,
+          image_url: args && args.image_url,
+        },
+        signal: exec && exec.signal,
+      })
+      const data = await res.json().catch(() => ({}))
+      if (!res.ok) throw new Error(`video_generate HTTP ${res.status}: ${extractResponseText(data)}`)
+      return textResult(`Video request submitted: ${JSON.stringify(data).slice(0, 1000)}`)
+    },
+  })
+
+  return () => {
+    for (const off of disposers) {
+      try { off() } catch { /* best-effort cleanup */ }
+    }
+  }
+}

package/lib/reset-clock.js

@@ -80,15 +80,25 @@ export function resolveAccurateReset(err, account, provider, nowMs = Date.now(),
     return targetReset + (Number(safetyBufferMs) || 0)
   }
 
-  const p = String(provider || (account && account.provider) || '').toLowerCase()
-  const windowDefault = VENDOR_WINDOW_MS[p]
-  if (windowDefault && err && (err.status === 429 || err.code === 'RATE_LIMIT' || err.code === 'QUOTA')) {
-    return now + windowDefault + (Number(safetyBufferMs) || 0)
-  }
-
+  // #684: a 429 without a disclosed reset is a local backoff, not a whole
+  // vendor window. Parking on a guessed 2-24h window burns a healthy account.
   return null
 }
 
+export function nextCooldownMs(accounts, now = Date.now()) {
+  const current = Number(now) || Date.now()
+  let next = null
+  for (const account of accounts || []) {
+    if (!account) continue
+    const candidates = [account.cooldownUntil, account.quarantineUntil, account.quota && account.quota.resetAt]
+    for (const value of candidates) {
+      const ts = Number(value)
+      if (Number.isFinite(ts) && ts > current) next = next === null ? ts : Math.min(next, ts)
+    }
+  }
+  return next === null ? null : next - current
+}
+
 export function formatRollingCountdown(resetAt, lang = 'en', now = Date.now()) {
   const ts = Number(resetAt)
   if (!Number.isFinite(ts) || ts <= 0) return ''

package/lib/route-report.js

@@ -0,0 +1,28 @@
+export function buildRouteReport(last, accounts, now = Date.now()) {
+  if (!last || !last.provider) return null
+  const current = Number(now) || Date.now()
+  const account = (Array.isArray(accounts) ? accounts : []).find((row) => row && row.ref === last.ref)
+  const source = (account && account.quota && account.quota.source) || account && account.quotaSource || 'unknown'
+  return {
+    at: last.at || last.timestamp || null,
+    route: {
+      provider: last.provider,
+      model: last.model || null,
+      path: last.path || null,
+      account: last.ref || null,
+    },
+    billing: {
+      provider: last.billingProvider || last.provider,
+      route: last.billingRoute || last.path || null,
+    },
+    quota: {
+      usedPercent: account && account.usagePercent != null ? account.usagePercent : null,
+      source,
+      ageMs: account && account.usageAt ? Math.max(0, current - Number(account.usageAt)) : null,
+      resetAt: (account && account.quota && account.quota.resetAt) || null,
+      confidence: source === 'unknown' ? 'unknown' : 'measured',
+    },
+    healthScore: account && account.healthScore != null ? account.healthScore : null,
+    stale: Boolean(account && account.usageAt && current - Number(account.usageAt) > 5 * 60 * 1000),
+  }
+}

package/lib/routes/status.js

@@ -10,6 +10,10 @@ import {
 } from '../reasoning-effort.js'
 import { defaultConcurrencyQueue } from '../concurrency-queue.js'
 import { calculateAnalytics } from '../analytics.js'
+import { setSpeedMode, getSpeedMode, clearSpeedMode } from '../speed-mode.js'
+import { getActiveConflicts } from '../coexistence.js'
+import { buildUsageRows, buildCallRows, toCsv } from '../usage-export.js'
+import { buildRouteReport } from '../route-report.js'
 import { runDiagnosticWizard } from '../diagnostic-wizard.js'
 import { buildEnrichedCatalog } from '../models-catalog.js'
 // #374: Sensitive GET routes protected by same-origin check
@@ -254,7 +258,8 @@ export function registerStatusRoutes(ctx, state) {
         labels,
         expiryNotifyDays: live().expiryNotifyDays,
         fastMode: !!live().codexFastMode,
-        composerQuota: String(live().composerQuota || 'off'),
+        composerQuota: String(live().composerQuota || 'off'),        composerQuotaDisplay: String(live().composerQuotaDisplay || 'current'),
+        quotaWidget: String(live().quotaWidget || 'docked'),
         active,
       })
     }),
@@ -297,7 +302,14 @@ export function registerStatusRoutes(ctx, state) {
         writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
         return
       }
-      writeJson(res, 200, { ok: true, report: await diagnosticsReport() })
+      const accounts = await accountsView()
+      const last = history.recent(1)[0]
+      writeJson(res, 200, {
+        ok: true,
+        report: await diagnosticsReport(),
+        conflicts: getActiveConflicts(),
+        route: buildRouteReport(last, accounts),
+      })
     }),
   }), 'dsh-subscriptions: /diagnostics')
 
@@ -436,6 +448,45 @@ export function registerStatusRoutes(ctx, state) {
     }),
   }), 'dsh-subscriptions: /history')
 
+  // #687: quota snapshot and per-call ledger export for DSH quota plugins.
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-subscriptions/usage',
+    handler: safeJsonHandler(async (req, res) => {
+      if (req.method !== 'GET') {
+        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'GET only' } })
+        return
+      }
+      if (!isTrustedSettingsRequest(req, ctx)) {
+        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
+        return
+      }
+      const q = queryOf(req)
+      const type = q.get('type') === 'calls' ? 'calls' : 'accounts'
+      const format = String(q.get('format') || 'json').toLowerCase()
+      const now = Date.now()
+      const accounts = await accountsView()
+      const calls = history.recent(500)
+      const rows = type === 'calls' ? buildCallRows(calls) : buildUsageRows(accounts, now)
+      if (format === 'csv') {
+        res.writeHead(200, {
+          'Content-Type': 'text/csv; charset=utf-8',
+          'Content-Disposition': 'attachment; filename="dsh-subscriptions-' + type + '.csv"',
+          'Cache-Control': 'no-store',
+        })
+        res.end(toCsv(rows))
+        return
+      }
+      writeJson(res, 200, {
+        ok: true,
+        generatedAt: now,
+        type,
+        rows,
+        summary: { accounts: Array.isArray(accounts) ? accounts.length : 0, calls: Array.isArray(calls) ? calls.length : 0 },
+      })
+    }),
+  }), 'dsh-subscriptions: /usage')
+
   // Telemetry summary route for UI stat cards (requests, latency, success rate)
   ctx.effect(() => ctx.webServer.register({
     kind: 'exact',
@@ -716,6 +767,41 @@ export function registerStatusRoutes(ctx, state) {
     }),
   }), 'dsh-subscriptions: /queue')
 
+  // #681: per-session Codex Speed/Fast toggle.
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-subscriptions/speed',
+    handler: safeJsonHandler(async (req, res) => {
+      if (!isTrustedSettingsRequest(req, ctx)) {
+        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
+        return
+      }
+      if (req.method === 'GET') {
+        const sid = queryOf(req).get('sessionId') || 'default'
+        writeJson(res, 200, { ok: true, sessionId: sid, mode: getSpeedMode(sid) || 'standard' })
+        return
+      }
+      if (req.method !== 'POST') {
+        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'GET or POST only' } })
+        return
+      }
+      let body = {}
+      try { body = JSON.parse((await readBody(req, 16 * 1024)).toString('utf8') || '{}') } catch {
+        writeJson(res, 400, { ok: false, error: { code: 'json', message: 'invalid json' } })
+        return
+      }
+      const sid = String(body.sessionId || 'default').slice(0, 200)
+      const mode = String(body.mode || '').toLowerCase()
+      if (mode !== 'fast' && mode !== 'standard' && mode !== 'off') {
+        writeJson(res, 400, { ok: false, error: { code: 'mode', message: 'mode must be fast or standard' } })
+        return
+      }
+      if (mode === 'fast') setSpeedMode(sid, 'fast')
+      else clearSpeedMode(sid)
+      writeJson(res, 200, { ok: true, sessionId: sid, mode: mode === 'fast' ? 'fast' : 'standard' })
+    }),
+  }), 'dsh-subscriptions: /speed')
+
   // #519: Interactive Diagnostic Wizard for accounts and connectivity
   ctx.effect(() => ctx.webServer.register({
     kind: 'exact',

package/lib/speed-mode.js

@@ -0,0 +1,17 @@
+const modes = new Map()
+
+export function setSpeedMode(sessionId, mode) {
+  const id = String(sessionId || '').trim()
+  if (!id) return
+  const value = String(mode || '').toLowerCase()
+  if (value === 'fast') modes.set(id, 'fast')
+  else modes.delete(id)
+}
+
+export function getSpeedMode(sessionId) {
+  return modes.get(String(sessionId || '').trim()) || null
+}
+
+export function clearSpeedMode(sessionId) {
+  modes.delete(String(sessionId || '').trim())
+}

package/lib/stream-rotate.js

@@ -7,7 +7,7 @@ import { notifySessionExpired, notifyQuarantineEntered } from './alerts.js'
 import { withRunawayGuard } from './runaway-guard.js'
 import { defaultErrorBuffer } from './error-buffer.js'
 import { withSoftFailureSentinel } from './sentinel.js'
-import { resolveAccurateReset } from './reset-clock.js'
+import { resolveAccurateReset, nextCooldownMs } from './reset-clock.js'
 
 export async function* streamWithRotation({
   accounts,
@@ -88,7 +88,15 @@ export async function* streamWithRotation({
         return
       }
       syncTrace('exhausted')
-      if (lastError) throw lastError
+      if (lastError) {
+        const wait = nextCooldownMs(pool, nowMs())
+        if (wait != null && options && options.rateLimitWait !== false) {
+          const maxWait = Number(options.rateLimitMaxWaitMs) || 6 * 3600 * 1000
+          lastError.retryAfterMs = Math.min(wait, maxWait)
+          lastError.resetAt = nowMs() + lastError.retryAfterMs
+        }
+        throw lastError
+      }
       const err = /** @type {Error & { code?: string }} */ (new Error('no usable subscription account for this provider'))
       err.code = 'RATE_LIMIT'
       throw err

package/lib/subscriptions.js

@@ -20,7 +20,7 @@ const OPENAI_COMPAT = [
 export const ALLOWLIST = {
   codex: ["/responses", "/models", "/images/generations", "/backend-api/codex/responses", "/backend-api/codex/models", "/backend-api/codex/images/generations"],
   claude: ["/v1/messages", "/api/oauth/profile", "/api/oauth/usage", "/v1/models"],
-  grok: ["/v1/models", "/responses", "/v1/responses", "/v1/billing", "/v1/chat/completions", "/images/generations", "/v1/images/generations"],
+  grok: ["/v1/models", "/responses", "/v1/responses", "/v1/billing", "/v1/chat/completions", "/images/generations", "/v1/images/generations", "/v1/videos"],
   antigravity: ["/v1/models", "/v1/generateContent", "/v1/streamGenerateContent", "/v1/loadCodeAssist", "/v1/fetchAvailableModels", "/v1/countTokens", "/v1/internal:loadCodeAssist"],
   kimi: OPENAI_COMPAT,
   glm: [...OPENAI_COMPAT, "/api/paas/v4/chat/completions", "/api/paas/v4/models"],

package/lib/usage-export.js

@@ -0,0 +1,52 @@
+function csvCell(value) {
+  const text = value == null ? '' : String(value)
+  return /[",\n\r]/.test(text) ? '"' + text.replace(/"/g, '""') + '"' : text
+}
+
+export function toCsv(rows) {
+  const list = Array.isArray(rows) ? rows : []
+  if (!list.length) return ''
+  const headers = Object.keys(list[0])
+  const lines = [headers.map(csvCell).join(',')]
+  for (const row of list) lines.push(headers.map((key) => csvCell(row[key])).join(','))
+  return lines.join('\n') + '\n'
+}
+
+export function buildUsageRows(accounts, now = Date.now()) {
+  const current = Number(now) || Date.now()
+  return (Array.isArray(accounts) ? accounts : []).map((account) => ({
+    ref: account.ref || '',
+    provider: account.provider || '',
+    index: account.index ?? '',
+    label: account.label || '',
+    plan: account.plan || account.paidTierName || '',
+    configured: Boolean(account.hasToken || account.configured),
+    usagePercent: account.usagePercent ?? '',
+    remainingPercent: account.usagePercent != null ? Math.max(0, 100 - Number(account.usagePercent)) : '',
+    quotaSource: (account.quota && account.quota.source) || 'unknown',
+    usageAgeMs: account.usageAt ? Math.max(0, current - Number(account.usageAt)) : '',
+    resetAt: (account.quota && account.quota.resetAt) || '',
+    cooldownUntil: account.cooldownUntil || '',
+    quarantineUntil: account.quarantineUntil || '',
+    quarantineReason: account.quarantineReason || '',
+    healthScore: account.healthScore ?? '',
+    monthlyCost: account.monthlyCost ?? '',
+  }))
+}
+
+export function buildCallRows(calls) {
+  return (Array.isArray(calls) ? calls : []).map((call) => ({
+    at: call.at || call.timestamp || '',
+    provider: call.provider || '',
+    ref: call.ref || '',
+    model: call.model || '',
+    path: call.path || '',
+    ok: call.ok !== false,
+    status: call.status ?? '',
+    inputTokens: call.inputTokens ?? '',
+    outputTokens: call.outputTokens ?? '',
+    cacheReadTokens: call.cacheReadTokens ?? '',
+    durationMs: call.durationMs ?? '',
+    error: call.error || '',
+  }))
+}