@aiworker/web 1.22.0 → 1.23.0

package/server/lib/quota/providers/hyper.test.js

@@ -0,0 +1,126 @@
+import { describe, expect, it } from 'vitest';
+import { fetchQuota, isConfigured } from './hyper.js';
+
+const readAuth = () => ({ hyper: { key: 'test-token' } });
+
+// https://hyper.charm.land/docs/api/credits.html documents the balance payload.
+// https://hyper.charm.land/faq defines one Hypercredit as $0.05.
+describe('Charm Hyper quota provider', () => {
+  it.each([
+    [100, '100', '$5.00'],
+    ['50', '50', '$2.50'],
+    [25.5, '25.50', '$1.28'],
+    [0, '0', '$0.00'],
+    ['0', '0', '$0.00'],
+  ])('formats balance %s without an untranslated unit', async (balance, credits, dollars) => {
+    const result = await fetchQuota({
+      readAuth,
+      fetchImpl: async () => Response.json({ balance }),
+    });
+
+    expect(result.ok).toBe(true);
+    expect(result.providerId).toBe('hyper');
+    expect(result.configured).toBe(true);
+    expect(result.usage.windows.credits.valueLabel).toBe(credits);
+    expect(result.usage.windows.credits_balance.valueLabel).toBe(dollars);
+    for (const window of Object.values(result.usage.windows)) {
+      expect(window.usedPercent).toBeNull();
+      expect(window.remainingPercent).toBeNull();
+      expect(window.windowSeconds).toBeNull();
+      expect(window.resetAt).toBeNull();
+      expect(window.resetAfterSeconds).toBeNull();
+    }
+  });
+
+  it.each([
+    {}, null, [], { balance: '' }, { balance: ' \t ' }, { balance: 'NaN' },
+    { balance: 'Infinity' }, { balance: null }, { balance: true }, { balance: [] },
+    { balance: {} },
+  ])('rejects invalid payload %j instead of showing zero', async (payload) => {
+    const result = await fetchQuota({ readAuth, fetchImpl: async () => Response.json(payload) });
+
+    expect(result.ok).toBe(false);
+    expect(result.configured).toBe(true);
+    expect(result.error).toBe('No quota data in response');
+    expect(result.usage).toBeNull();
+  });
+
+  it.each([
+    { hyper: { key: 'test-token' } },
+    { hyper: { token: 'test-token' } },
+    { hyper: 'test-token' },
+    { hyper: { key: '  ', token: 'test-token' } },
+    { hyper: { key: 42, token: 'test-token' } },
+  ])('uses a validated credential for the documented request', async (auth) => {
+    expect(isConfigured(auth)).toBe(true);
+    let requests = 0;
+    const result = await fetchQuota({
+      readAuth: () => auth,
+      fetchImpl: async (url, options) => {
+        requests += 1;
+        expect(url).toBe('https://hyper.charm.land/v1/credits');
+        expect(options.method).toBe('GET');
+        expect(new Headers(options.headers).get('Authorization')).toBe('Bearer test-token');
+        expect(options.signal).toBeInstanceOf(AbortSignal);
+        return Response.json({ balance: 100 });
+      },
+    });
+
+    expect(requests).toBe(1);
+    expect(result.ok).toBe(true);
+    expect(JSON.stringify(result)).not.toContain('test-token');
+  });
+
+  it.each([{}, { hyper: { key: '' } }, { hyper: { key: '  ' } }, { hyper: { key: 42 } }])(
+    'does not request usage without a valid credential',
+    async (auth) => {
+      expect(isConfigured(auth)).toBe(false);
+      let requests = 0;
+      const result = await fetchQuota({
+        readAuth: () => auth,
+        fetchImpl: async () => {
+          requests += 1;
+          return Response.json({ balance: 100 });
+        },
+      });
+
+      expect(requests).toBe(0);
+      expect(result.ok).toBe(false);
+      expect(result.configured).toBe(false);
+      expect(result.error).toBe('Not configured');
+    },
+  );
+
+  it.each([
+    [401, 'Session expired — please re-authenticate with Charm Hyper'],
+    [403, 'Session expired — please re-authenticate with Charm Hyper'],
+    [429, 'API error: 429'],
+    [500, 'API error: 500'],
+  ])('reports HTTP %s as a failure', async (status, error) => {
+    const result = await fetchQuota({ readAuth, fetchImpl: async () => new Response(null, { status }) });
+
+    expect(result.ok).toBe(false);
+    expect(result.configured).toBe(true);
+    expect(result.error).toBe(error);
+    expect(result.usage).toBeNull();
+  });
+
+  it('reports invalid JSON as a parse failure', async () => {
+    const result = await fetchQuota({ readAuth, fetchImpl: async () => new Response('{') });
+    expect(result.error).toBe('Invalid response from provider');
+    expect(result.ok).toBe(false);
+    expect(result.configured).toBe(true);
+    expect(result.usage).toBeNull();
+  });
+
+  it.each([
+    [new DOMException('Timed out', 'TimeoutError'), 'Request timed out'],
+    [new Error('Network unavailable'), 'Network unavailable'],
+  ])('reports request failure', async (failure, message) => {
+    const result = await fetchQuota({ readAuth, fetchImpl: async () => { throw failure; } });
+    expect(result.error).toBe(message);
+    expect(result.ok).toBe(false);
+    expect(result.configured).toBe(true);
+    expect(result.usage).toBeNull();
+  });
+});

package/server/lib/quota/providers/index.js

@@ -8,12 +8,15 @@
 import { buildResult } from '../utils/index.js';
 
 import * as claude from './claude/index.js';
+import * as clinePass from './cline-pass.js';
 import * as codex from './codex.js';
 import * as copilot from './copilot.js';
 import * as crof from './crof.js';
 import * as cursor from './cursor.js';
 import * as deepseek from './deepseek.js';
+import * as exeDev from './exe-dev.js';
 import * as google from './google/index.js';
+import * as hyper from './hyper.js';
 import * as kimi from './kimi.js';
 import * as nanogpt from './nanogpt.js';
 import * as openai from './openai.js';
@@ -35,6 +38,12 @@ const registry = {
     isConfigured: claude.isConfigured,
     fetchQuota: claude.fetchQuota
   },
+  'cline-pass': {
+    providerId: clinePass.providerId,
+    providerName: clinePass.providerName,
+    isConfigured: clinePass.isConfigured,
+    fetchQuota: clinePass.fetchQuota
+  },
   codex: {
     providerId: codex.providerId,
     providerName: codex.providerName,
@@ -59,12 +68,24 @@ const registry = {
     isConfigured: deepseek.isConfigured,
     fetchQuota: deepseek.fetchQuota
   },
+  'exe-dev': {
+    providerId: exeDev.providerId,
+    providerName: exeDev.providerName,
+    isConfigured: exeDev.isConfigured,
+    fetchQuota: exeDev.fetchQuota
+  },
   google: {
     providerId: google.providerId,
     providerName: google.providerName,
     isConfigured: google.isConfigured,
     fetchQuota: google.fetchGoogleQuota
   },
+  hyper: {
+    providerId: hyper.providerId,
+    providerName: hyper.providerName,
+    isConfigured: hyper.isConfigured,
+    fetchQuota: hyper.fetchQuota
+  },
   'zai-coding-plan': {
     providerId: zai.providerId,
     providerName: zai.providerName,
@@ -213,6 +234,7 @@ export const fetchGoogleQuota = google.fetchGoogleQuota;
 export const fetchCodexQuota = codex.fetchQuota;
 export const fetchCursorQuota = cursor.fetchQuota;
 export const fetchDeepseekQuota = deepseek.fetchQuota;
+export const fetchHyperQuota = hyper.fetchQuota;
 export const fetchCopilotQuota = copilot.fetchQuota;
 export const fetchCopilotAddonQuota = copilot.fetchQuotaAddon;
 export const fetchKimiQuota = kimi.fetchQuota;

package/server/lib/quota/providers/neuralwatt.js

@@ -74,7 +74,6 @@ export const fetchQuota = async () => {
     const subscription = payload?.subscription ?? null;
     const inOverage = Boolean(subscription?.in_overage);
     const allowance = payload?.key?.allowance ?? null;
-    const keyName = payload?.key?.name ?? null;
     const creditsRemaining = toNumber(payload?.balance?.credits_remaining_usd);
 
     const windows = {};
@@ -116,19 +115,17 @@ export const fetchQuota = async () => {
         : (spent !== null && effectiveLimit !== null && effectiveLimit > 0
             ? Math.max(0, Math.min(100, (spent / effectiveLimit) * 100))
             : null);
-      // Window title is the localized period label (daily/weekly/monthly); key
-      // name is attached via valueLabel for identification (wafer precedent).
+      // Window title is the localized period label (daily/weekly/monthly); the
+      // usage value stays a percent so the UI's display-mode toggle applies.
       const periodKey = (period === 'daily' || period === 'weekly' || period === 'monthly' || period === 'month')
         ? (period === 'month' ? 'monthly' : period)
         : 'billing_cycle';
-      const labelName = asNonEmptyString(keyName);
       const resetAt = toTimestamp(allowance.reset_at);
       const windowSeconds = period ? periodToWindowSeconds(period) : null;
       windows[periodKey] = toUsageWindow({
         usedPercent,
         windowSeconds,
-        resetAt,
-        ...(labelName ? { valueLabel: labelName } : {})
+        resetAt
       });
     } else if (creditsRemaining !== null) {
       windows.credits_balance = toUsageWindow({

package/server/lib/quota/providers/neuralwatt.test.js

@@ -89,7 +89,7 @@ describe('NeuralWatt quota provider', () => {
     expect(result.usage.windows.credits_balance.valueLabel).toBe('$32.68');
   });
 
-  it('surfaces subscription and allowance windows (allowance keyed by period, key name in valueLabel)', async () => {
+  it('surfaces subscription and allowance windows (allowance keyed by period, percent value)', async () => {
     const payload = {
       ...DOCUMENTED_SUBSCRIPTION_PAYLOAD,
       balance: { credits_remaining_usd: 200 },
@@ -107,11 +107,11 @@ describe('NeuralWatt quota provider', () => {
     expect(subWindow.usedPercent).toBeCloseTo((13.9023 / 20.0) * 100, 4);
 
     // Allowance window is keyed by the localized period label ("monthly");
-    // key name flows through valueLabel for identification.
+    // the usage value stays a percent — no key-name valueLabel.
     const allowWindow = result.usage.windows.monthly;
     expect(allowWindow).toBeDefined();
     expect(allowWindow.usedPercent).toBe(25);
-    expect(allowWindow.valueLabel).toBe('Prod');
+    expect(allowWindow.valueLabel).toBeUndefined();
     expect(allowWindow.resetAt).toBe(Date.parse('2026-08-01T00:00:00Z'));
 
     // credits_balance suppressed because allowance is present
@@ -137,7 +137,7 @@ describe('NeuralWatt quota provider', () => {
     expect(window.usedPercent).toBeCloseTo((25 / 55) * 100, 4);
     expect(window.windowSeconds).toBe(30 * 86400);
     expect(window.resetAt).toBe(Date.parse('2026-08-01T00:00:00Z'));
-    expect(window.valueLabel).toBe('prod-key');
+    expect(window.valueLabel).toBeUndefined();
     expect(result.usage.windows.credits_balance).toBeUndefined();
   });
 
@@ -176,7 +176,7 @@ describe('NeuralWatt quota provider', () => {
     expect(window).toBeDefined();
     expect(window.windowSeconds).toBe(604800);
     expect(window.resetAt).toBe(Date.parse('2026-07-04T00:00:00Z'));
-    expect(window.valueLabel).toBe('Prod');
+    expect(window.valueLabel).toBeUndefined();
   });
 
   it('uses daily as the allowance key when period is daily', async () => {
@@ -216,7 +216,7 @@ describe('NeuralWatt quota provider', () => {
     expect(window.usedPercent).toBe(25);
   });
 
-  it('marks blocked allowance as 100% with valueLabel set', async () => {
+  it('marks blocked allowance as 100% with percent value', async () => {
     const payload = {
       balance: { credits_remaining_usd: 30 },
       subscription: null,
@@ -231,7 +231,7 @@ describe('NeuralWatt quota provider', () => {
 
     const window = result.usage.windows.monthly;
     expect(window.usedPercent).toBe(100);
-    expect(window.valueLabel).toBe('sample');
+    expect(window.valueLabel).toBeUndefined();
   });
 
   it('falls back to credits_balance when neither subscription nor allowance exists', async () => {

package/server/lib/quota/providers/ollama-cloud.js

@@ -35,6 +35,37 @@ export const parseOllamaSettingsHtml = (html) => {
       valueLabel: `${used ?? 0} / ${total ?? 0}`
     });
   }
+  // Cost-based plans render "Monthly usage" with a dollar amount instead of
+  // session/weekly/premium windows; support both page shapes.
+  const monthlyMatch = html.match(/Monthly\s+usage[\s\S]{0,200}?\$([0-9][0-9,.]*)\s+of\s+\$([0-9][0-9,.]*)/i);
+  if (monthlyMatch) {
+    const used = toNumber(monthlyMatch[1].replace(/,/g, ''));
+    const total = toNumber(monthlyMatch[2].replace(/,/g, ''));
+    const usedPercent = total && used !== null ? Math.min(100, (used / total) * 100) : null;
+    windows.monthly = toUsageWindow({
+      usedPercent,
+      windowSeconds: null,
+      resetAt: null,
+      valueLabel: `$${monthlyMatch[1]} / $${monthlyMatch[2]}`
+    });
+  }
+  // "Extra usage" credits block (visible when credits/auto-reload is enabled):
+  // a balance, not a percent. Anchor on "Balance remaining" — nearby "Add $5"
+  // and auto-reload copy also contain dollar amounts. Surfaced with the
+  // credits_balance key and OpenAI-style plain money label (the UI renders
+  // it as "Credits Balance"); a $0 balance is omitted rather than shown.
+  const balanceMatch = html.match(/Balance\s+remaining[\s\S]{0,200}?\$([0-9][0-9,.]*)/i);
+  if (balanceMatch) {
+    const balance = toNumber(balanceMatch[1].replace(/,/g, ''));
+    if (balance !== 0) {
+      windows.credits_balance = toUsageWindow({
+        usedPercent: null,
+        windowSeconds: null,
+        resetAt: null,
+        valueLabel: `$${balanceMatch[1]}`
+      });
+    }
+  }
   return windows;
 };
 
@@ -45,7 +76,7 @@ export const isConfigured = () => {
 export const fetchOllamaCloudUsage = async (credential, fetchImpl = fetch) => {
   const response = await fetchImpl('https://ollama.com/settings', {
     method: 'GET',
-    headers: { Cookie: credential.cookie, 'User-Agent': 'OpenChamber quota provider' },
+    headers: { Cookie: credential.cookie, 'User-Agent': 'AiWorker quota provider' },
     redirect: 'manual',
     signal: AbortSignal.timeout(15_000),
   });

package/server/lib/quota/providers/ollama-cloud.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'bun:test';
-import { fetchOllamaCloudUsage } from './ollama-cloud.js';
+import { parseOllamaSettingsHtml, fetchOllamaCloudUsage } from './ollama-cloud.js';
 
 describe('Ollama Cloud quota provider', () => {
   it('rejects redirects without forwarding credentials', async () => {
@@ -9,4 +9,36 @@ describe('Ollama Cloud quota provider', () => {
   it('rejects successful pages without usage data', async () => {
     await expect(fetchOllamaCloudUsage({ cookie: 'session=secret' }, async () => new Response('<html></html>'))).rejects.toThrow('could not be parsed');
   });
+
+  it('parses session/weekly/premium windows', () => {
+    const windows = parseOllamaSettingsHtml('<p>Session usage: 42%</p><p>Weekly usage: 7%</p><p>Premium 120 / 1000</p>');
+    expect(windows.session.usedPercent).toBe(42);
+    expect(windows.weekly.usedPercent).toBe(7);
+    expect(windows.premium.usedPercent).toBe(12);
+    expect(windows.premium.valueLabel).toBe('120 / 1000');
+  });
+
+  it('parses the cost-based monthly usage shape', () => {
+    const html = '<span class="text-sm">Monthly usage</span>\n      <span class="text-sm "\n        >$4.39 of $60 used</span\n      >';
+    const windows = parseOllamaSettingsHtml(html);
+    expect(windows.monthly.usedPercent).toBeCloseTo(7.3, 1);
+    expect(windows.monthly.valueLabel).toBe('$4.39 / $60');
+    expect(windows.monthly.remainingPercent).toBeCloseTo(92.7, 1);
+  });
+
+  it('parses the extra-usage credits balance', () => {
+    const html = '<div><span>Balance remaining</span><span>$12.50</span></div><button>Add $5</button>';
+    const windows = parseOllamaSettingsHtml(html);
+    expect(windows.credits_balance.usedPercent).toBeNull();
+    expect(windows.credits_balance.valueLabel).toBe('$12.50');
+  });
+
+  it('omits the credits balance when it is zero', () => {
+    const html = '<div><span>Balance remaining</span><span>$0.00</span></div>';
+    expect(parseOllamaSettingsHtml(html).credits_balance).toBeUndefined();
+  });
+
+  it('ignores nearby dollar amounts that are not the balance', () => {
+    expect(parseOllamaSettingsHtml('<p>Add $5 to your balance when it hits $0</p>').credits_balance).toBeUndefined();
+  });
 });

package/server/lib/quota/providers/opencode-go.js

@@ -25,7 +25,7 @@ export const parseOpenCodeGoUsage = (payload) => {
     if (typeof resetAt !== 'string' || !Number.isFinite(new Date(resetAt).getTime())) continue;
     windows[key] = toUsageWindow({
       usedPercent: Math.min(100, Math.max(0, usedPercent)),
-      resetAt,
+      resetAt: new Date(resetAt).getTime(),
       windowSeconds: null,
     });
   }
@@ -37,7 +37,8 @@ export const fetchOpenCodeGoUsage = async (apiKey, fetchImpl = fetch) => {
     headers: {
       Accept: 'application/json',
       Authorization: `Bearer ${apiKey}`,
-      'User-Agent': 'OpenChamber quota provider',
+      'x-opencode-session': 'openchamber-usage',
+      'User-Agent': 'AiWorker quota provider',
     },
     signal: AbortSignal.timeout(15_000),
   });

package/server/lib/quota/providers/opencode-go.test.js

@@ -3,9 +3,9 @@ import os from 'node:os';
 import path from 'node:path';
 import { afterAll, afterEach, describe, expect, it, vi } from 'vitest';
 
-const previousDataDirectory = process.env.OPENCHAMBER_DATA_DIR;
+const previousDataDirectory = process.env.AIWORKER_DATA_DIR;
 const temporaryDataDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'openchamber-opencode-go-'));
-process.env.OPENCHAMBER_DATA_DIR = temporaryDataDirectory;
+process.env.AIWORKER_DATA_DIR = temporaryDataDirectory;
 
 vi.mock('../../opencode/auth.js', () => ({
   readAuthFile: () => ({ 'opencode-go': { key: 'test-key' } }),
@@ -18,8 +18,8 @@ afterEach(() => {
 });
 
 afterAll(() => {
-  if (previousDataDirectory === undefined) delete process.env.OPENCHAMBER_DATA_DIR;
-  else process.env.OPENCHAMBER_DATA_DIR = previousDataDirectory;
+  if (previousDataDirectory === undefined) delete process.env.AIWORKER_DATA_DIR;
+  else process.env.AIWORKER_DATA_DIR = previousDataDirectory;
   fs.rmSync(temporaryDataDirectory, { recursive: true, force: true });
 });
 
@@ -27,11 +27,36 @@ describe('OpenCode Go quota provider', () => {
   it('parses partial API usage windows', () => {
     const windows = parseOpenCodeGoUsage({ usage: { rolling: { percent: 25, resetsAt: '2026-08-12T12:00:00.000Z' }, weekly: { percent: 40, resetsAt: '2026-08-19T12:00:00.000Z' } } });
     expect(windows['5h'].usedPercent).toBe(25);
-    expect(windows['5h'].resetAt).toBe('2026-08-12T12:00:00.000Z');
+    expect(windows['5h'].resetAt).toBe(Date.parse('2026-08-12T12:00:00.000Z'));
     expect(windows.weekly.usedPercent).toBe(40);
     expect(windows.monthly).toBeUndefined();
   });
 
+  it('returns numeric reset timestamps for all usage windows', async () => {
+    const resetsAt = '2026-10-01T00:00:00.000Z';
+    const windows = await fetchOpenCodeGoUsage('test-key', async () => new Response(JSON.stringify({
+      usage: {
+        rolling: { percent: 25, resetsAt },
+        weekly: { percent: 40, resetsAt },
+        monthly: { percent: 60, resetsAt },
+      },
+    })));
+    expect(Object.keys(windows)).toEqual(['5h', 'weekly', 'monthly']);
+    for (const window of Object.values(windows)) {
+      expect(window.resetAt).toBe(Date.parse(resetsAt));
+    }
+  });
+
+  it('preserves valid windows when another reset date is invalid', () => {
+    const windows = parseOpenCodeGoUsage({ usage: {
+      rolling: { percent: 25, resetsAt: 'invalid' },
+      weekly: { percent: 40, resetsAt: '2026-08-19T12:00:00.000Z' },
+      monthly: { percent: 60, resetsAt: null },
+    } });
+    expect(Object.keys(windows)).toEqual(['weekly']);
+    expect(windows.weekly.resetAt).toBe(Date.parse('2026-08-19T12:00:00.000Z'));
+  });
+
   it('does not expose credentials in authentication errors', async () => {
     await expect(fetchOpenCodeGoUsage('secret', async () => new Response('', { status: 403 }))).rejects.toThrow('authentication failed');
   });
@@ -43,7 +68,11 @@ describe('OpenCode Go quota provider', () => {
       return new Response(JSON.stringify({ usage: { rolling: { percent: 25, resetsAt: '2026-08-12T12:00:00.000Z' } } }));
     });
     expect(request.url).toBe('https://opencode.ai/zen/go/v1/usage');
-    expect(request.options.headers).toMatchObject({ Accept: 'application/json', Authorization: 'Bearer secret' });
+    expect(request.options.headers).toMatchObject({
+      Accept: 'application/json',
+      Authorization: 'Bearer secret',
+      'x-opencode-session': 'openchamber-usage',
+    });
     expect(request.options.headers.Cookie).toBeUndefined();
     expect(usage['5h'].usedPercent).toBe(25);
   });

package/server/lib/quota/providers/openrouter.js

@@ -5,12 +5,30 @@ import {
   buildResult,
   toUsageWindow,
   toNumber,
+  asObject,
   formatMoney
 } from '../utils/index.js';
 
 export const providerId = 'openrouter';
 export const providerName = 'OpenRouter';
-const aliases = ['openrouter'];
+export const aliases = ['openrouter'];
+const OPENROUTER_QUOTA_URL = 'https://openrouter.ai/api/v1/key';
+const PERIOD_SECONDS = { daily: 86400, weekly: 604800, monthly: 30 * 86400 };
+
+export const resolveResetAt = (limitReset, nowMs) => {
+  const now = new Date(nowMs);
+  const y = now.getUTCFullYear();
+  const m = now.getUTCMonth();
+  const d = now.getUTCDate();
+
+  if (limitReset === 'daily') return Date.UTC(y, m, d + 1);
+  if (limitReset === 'weekly') {
+    const dow = now.getUTCDay();
+    return Date.UTC(y, m, d + ((8 - dow) % 7 || 7));
+  }
+  if (limitReset === 'monthly') return Date.UTC(y, m + 1, 1);
+  return null;
+};
 
 export const isConfigured = () => {
   const auth = readAuthFile();
@@ -33,13 +51,16 @@ export const fetchQuota = async () => {
     });
   }
 
+  const timeoutSignal = AbortSignal.timeout(15_000);
+
   try {
-    const response = await fetch('https://openrouter.ai/api/v1/credits', {
+    const response = await fetch(OPENROUTER_QUOTA_URL, {
       method: 'GET',
       headers: {
         Authorization: `Bearer ${apiKey}`,
-        'Content-Type': 'application/json'
-      }
+        'Accept-Encoding': 'identity'
+      },
+      signal: timeoutSignal
     });
 
     if (!response.ok) {
@@ -48,45 +69,119 @@ export const fetchQuota = async () => {
         providerName,
         ok: false,
         configured: true,
-        error: `API error: ${response.status}`
+        error: response.status === 401 || response.status === 403
+          ? 'Session expired — please re-authenticate with OpenRouter'
+          : `API error: ${response.status}`
       });
     }
 
     const payload = await response.json();
-    const credits = payload?.data ?? {};
-    const totalCredits = toNumber(credits.total_credits);
-    const totalUsage = toNumber(credits.total_usage);
-    const remaining = totalCredits !== null && totalUsage !== null
-      ? Math.max(0, totalCredits - totalUsage)
-      : null;
-    let valueLabel = null;
-    if (remaining !== null && totalUsage !== null) {
-      valueLabel = `$${formatMoney(remaining)} left · $${formatMoney(totalUsage)} spent`;
+    const data = asObject(payload?.data);
+
+    if (data === null) {
+      return buildResult({
+        providerId,
+        providerName,
+        ok: false,
+        configured: true,
+        error: 'No quota data in response'
+      });
+    }
+
+    if (data.is_management_key === true) {
+      return buildResult({
+        providerId,
+        providerName,
+        ok: false,
+        configured: true,
+        error: 'Management key configured — quota needs an inference API key'
+      });
     }
 
-    const windows = {
-      credits: toUsageWindow({
-        usedPercent: null,
-        windowSeconds: null,
-        resetAt: null,
-        valueLabel
-      })
-    };
+    const limit = toNumber(data.limit);
+    const limitRemaining = toNumber(data.limit_remaining);
+    if (limit !== null && limitRemaining === null) {
+      return buildResult({
+        providerId,
+        providerName,
+        ok: false,
+        configured: true,
+        error: 'No quota data in response'
+      });
+    }
+
+    const usageMonthly = toNumber(data.usage_monthly);
+    if (limit === null && usageMonthly === null) {
+      return buildResult({
+        providerId,
+        providerName,
+        ok: false,
+        configured: true,
+        error: 'No quota data in response'
+      });
+    }
+
+    const nowMs = Date.now();
+    let windowKey;
+    let windowSeconds;
+    let resetAt;
+    let usedPercent;
+    let valueLabel;
+
+    if (limit === null) {
+      windowKey = 'monthly';
+      windowSeconds = PERIOD_SECONDS.monthly;
+      resetAt = resolveResetAt('monthly', nowMs);
+      usedPercent = null;
+      valueLabel = `$${formatMoney(usageMonthly)} spent`;
+    } else {
+      const used = Math.max(0, limit - limitRemaining);
+      const percent = limit > 0 ? (used / limit) * 100 : null;
+      usedPercent = percent === null ? null : Math.min(100, percent);
+      valueLabel = `$${formatMoney(used)} / $${formatMoney(limit)}`;
+
+      if (Object.hasOwn(PERIOD_SECONDS, data.limit_reset)) {
+        windowKey = data.limit_reset;
+        windowSeconds = PERIOD_SECONDS[data.limit_reset];
+        resetAt = resolveResetAt(data.limit_reset, nowMs);
+      } else {
+        windowKey = 'credits';
+        windowSeconds = null;
+        resetAt = null;
+      }
+    }
 
     return buildResult({
       providerId,
       providerName,
       ok: true,
       configured: true,
-      usage: { windows }
+      usage: {
+        windows: {
+          [windowKey]: toUsageWindow({
+            usedPercent,
+            windowSeconds,
+            resetAt,
+            valueLabel
+          })
+        }
+      }
     });
   } catch (error) {
+    const isTimeout = error instanceof DOMException && (
+      error.name === 'TimeoutError' || (error.name === 'AbortError' && timeoutSignal.aborted)
+    );
+    const isParseError = error instanceof SyntaxError;
     return buildResult({
       providerId,
       providerName,
       ok: false,
       configured: true,
-      error: error instanceof Error ? error.message : 'Request failed'
+      error: isTimeout
+        ? 'Request timed out'
+        : isParseError
+          ? 'Invalid response from provider'
+          : (error instanceof Error ? error.message : 'Request failed')
     });
   }
 };