@openchambery/web 2.0.0-beta.3 → 2.0.0-beta.30

package/server/lib/question-auto-delegate/core.js

@@ -25,7 +25,8 @@ const normalizeQuestion = (raw, directoryHint = '') => {
   const sessionID = asTrimmedString(raw.sessionID);
   if (!requestID || !sessionID) return null;
   const directory = asTrimmedString(raw.directory) || asTrimmedString(directoryHint);
-  const questions = Array.isArray(raw.questions) ? raw.questions : [];
+  if (Array.isArray(raw.fields) && raw.metadata?.kind !== 'question') return null;
+  const questions = Array.isArray(raw.fields) ? raw.fields : Array.isArray(raw.questions) ? raw.questions : [];
   return {
     requestID,
     sessionID,
@@ -608,18 +609,18 @@ export function createQuestionAutoDelegateCore({
     try {
       if (kind === 'reject') {
         entry.upstreamDispatched = true;
-        upstream = await io.postReject(requestID, directory, input.body);
+        upstream = await io.postReject(requestID, directory, input.body, entry.sessionID);
       } else if (authority === 'manual') {
         entry.upstreamDispatched = true;
         // Forward the caller payload exactly (answers may be empty).
-        upstream = await io.postReply(requestID, directory, input.answers);
+        upstream = await io.postReply(requestID, directory, input.answers, entry.sessionID);
       } else {
         const count = entry.questionCount > 0 ? entry.questionCount : 1;
         const answers = Array.isArray(input.answers) && input.answers.length > 0
           ? input.answers
           : buildAutoDelegateAnswers(count, autoAnswer);
         entry.upstreamDispatched = true;
-        upstream = await io.postReply(requestID, directory, answers);
+        upstream = await io.postReply(requestID, directory, answers, entry.sessionID);
       }
     } catch (error) {
       // Throw before a classified upstream result: treat as pre-send failure → release for retry.
@@ -1157,12 +1158,18 @@ export function createQuestionAutoDelegateCore({
   const processEvent = (payload, directoryHint = '') => {
     if (disposed || !payload || typeof payload !== 'object') return;
     const type = typeof payload.type === 'string' ? payload.type : '';
-    const properties = payload.properties && typeof payload.properties === 'object' ? payload.properties : {};
-    const hint = asTrimmedString(directoryHint);
+    const properties = payload.data && typeof payload.data === 'object'
+      ? payload.data
+      : payload.properties && typeof payload.properties === 'object' ? payload.properties : {};
+    const hint = asTrimmedString(payload.location?.directory) || asTrimmedString(directoryHint);
 
     if (type === 'session.created' || type === 'session.updated') {
-      rememberSession(properties.info, hint);
-      const info = properties.info;
+      const info = properties.info ?? {
+        id: properties.sessionID,
+        parentID: properties.parentID,
+        directory: properties.location?.directory,
+      };
+      rememberSession(info, hint);
       const sessionId = asTrimmedString(info?.id);
       const directory = asTrimmedString(info?.directory) || hint;
       if (sessionId && directory) {
@@ -1176,8 +1183,9 @@ export function createQuestionAutoDelegateCore({
       return;
     }
 
-    if (type === 'question.asked') {
-      const normalized = normalizeQuestion(properties, hint);
+    if (type === 'question.asked' || type === 'form.created') {
+      if (type === 'form.created' && properties.form?.metadata?.kind !== 'question') return;
+      const normalized = normalizeQuestion(type === 'form.created' ? properties.form : properties, hint);
       if (!normalized) return;
       rememberSession({ id: normalized.sessionID, directory: normalized.directory }, normalized.directory || hint);
       if (!normalized.directory) {
@@ -1191,13 +1199,13 @@ export function createQuestionAutoDelegateCore({
       return;
     }
 
-    if (type === 'question.replied' || type === 'question.rejected') {
-      const requestID = asTrimmedString(properties.id) || asTrimmedString(properties.requestID);
+    if (type === 'question.replied' || type === 'question.rejected' || type === 'form.replied' || type === 'form.cancelled') {
+      const requestID = asTrimmedString(properties.formID) || asTrimmedString(properties.id) || asTrimmedString(properties.requestID);
       if (!requestID) return;
       const entry = requests.get(requestID);
       if (!entry) return;
       if (entry.state === TERMINAL_SETTLED) return;
-      const resolution = type === 'question.rejected' ? 'rejected' : 'replied';
+      const resolution = type === 'question.rejected' || type === 'form.cancelled' ? 'rejected' : 'replied';
       if (entry.state === 'uncertain' || entry.state === 'submitting') {
         markSettled(entry, resolution, entry.submittedBy ?? null);
         bump();

package/server/lib/question-auto-delegate/form-io.d.ts

@@ -0,0 +1,6 @@
+import type { QuestionAutoDelegateIO, QuestionAutoDelegateUpstreamResult } from './core.js';
+
+export function createQuestionFormIO(upstream: (
+  path: string,
+  options?: { directory?: string | null; method?: string; body?: unknown },
+) => Promise<QuestionAutoDelegateUpstreamResult>): Pick<QuestionAutoDelegateIO, 'listQuestions' | 'postReply' | 'postReject'>;

package/server/lib/question-auto-delegate/form-io.js

@@ -0,0 +1,39 @@
+/** Native OpenCode form IO shared by Web and the VS Code host. */
+export function createQuestionFormIO(upstream) {
+  const formPath = (sessionID, requestID) => {
+    if (!sessionID) throw new Error('Question form requires a sessionID');
+    return `/session/${encodeURIComponent(sessionID)}/form/${encodeURIComponent(requestID)}`;
+  };
+  return {
+    async listQuestions(directory) {
+      const result = await upstream('/form', { directory });
+      if (!result.ok) return null;
+      const rows = result.body?.data;
+      if (!Array.isArray(rows)) return null;
+      return rows.filter((form) => form?.metadata?.kind === 'question');
+    },
+    async postReply(requestID, directory, answers, sessionID) {
+      const path = formPath(sessionID, requestID);
+      const result = await upstream(path, { directory });
+      // A failed schema read never means the answer POST was dispatched.
+      if (!result.ok) return { ...result, notSent: true, uncertain: false };
+      const form = result.body?.data;
+      if (form?.id !== requestID || form?.sessionID !== sessionID
+        || form.metadata?.kind !== 'question' || !Array.isArray(form.fields) || !form.fields.length) {
+        throw new Error('Invalid question form schema');
+      }
+      const answer = Object.fromEntries(form.fields.map((field, index) => {
+        if (!field.key || (field.type !== 'string' && field.type !== 'multiselect')) {
+          throw new Error('Unsupported question form field');
+        }
+        const values = (answers[index] ?? []).map((value) =>
+          field.options?.find((option) => (option.label || option.value) === value)?.value ?? value);
+        return [field.key, field.type === 'multiselect' ? values : values[0] ?? ''];
+      }));
+      return upstream(`${path}/reply`, { directory, method: 'POST', body: { answer } });
+    },
+    async postReject(requestID, directory, _body, sessionID) {
+      return upstream(`${formPath(sessionID, requestID)}/cancel`, { directory, method: 'POST' });
+    },
+  };
+}

package/server/lib/question-auto-delegate/runtime.js

@@ -2,6 +2,7 @@ import {
   createQuestionAutoDelegateCore,
   QUESTION_AUTO_DELEGATE_DELAY_MS,
 } from './core.js';
+import { createQuestionFormIO } from './form-io.js';
 
 const REQUEST_TIMEOUT_MS = 15_000;
 
@@ -44,7 +45,7 @@ export function createQuestionAutoDelegateRuntime({
 } = {}) {
   const upstream = async (path, { directory, method = 'GET', body } = {}) => {
     const url = new URL(buildOpenCodeUrl(path, ''));
-    if (directory) url.searchParams.set('directory', directory);
+    if (directory) url.searchParams.set('location[directory]', directory);
     let response;
     try {
       response = await fetchImpl(url, {
@@ -149,14 +150,7 @@ export function createQuestionAutoDelegateRuntime({
         }
         return Array.from(dirs);
       },
-      async listQuestions(directory) {
-        const result = await upstream('/question', { directory });
-        if (!result.ok) return null;
-        const payload = result.body;
-        if (Array.isArray(payload)) return payload;
-        if (Array.isArray(payload?.data)) return payload.data;
-        return null;
-      },
+      ...createQuestionFormIO(upstream),
       async getSession(sessionID, directory) {
         const result = await upstream(`/session/${encodeURIComponent(sessionID)}`, { directory });
         if (!result.ok) return null;
@@ -167,23 +161,9 @@ export function createQuestionAutoDelegateRuntime({
         return {
           id: asTrimmedString(info.id) || sessionID,
           parentID: asTrimmedString(info.parentID) || null,
-          directory: asTrimmedString(info.directory) || asTrimmedString(directory) || null,
+          directory: asTrimmedString(info.location?.directory) || asTrimmedString(info.directory) || asTrimmedString(directory) || null,
         };
       },
-      async postReply(requestID, directory, answers) {
-        return upstream(`/question/${encodeURIComponent(requestID)}/reply`, {
-          directory,
-          method: 'POST',
-          body: { answers },
-        });
-      },
-      async postReject(requestID, directory, body) {
-        return upstream(`/question/${encodeURIComponent(requestID)}/reject`, {
-          directory,
-          method: 'POST',
-          body: body && typeof body === 'object' ? body : {},
-        });
-      },
     },
   });
 

package/server/lib/question-auto-delegate/runtime.test.js

@@ -0,0 +1,138 @@
+import { afterEach, expect, it, vi } from 'vitest';
+import { createQuestionAutoDelegateRuntime } from './runtime.js';
+import { QUESTION_AUTO_DELEGATE_ANSWER } from './core.js';
+
+const form = {
+  id: 'frm_question', sessionID: 'ses_test', title: 'Choose',
+  metadata: { kind: 'question' },
+  fields: [{ key: 'approach', type: 'string', custom: true, options: [{ label: 'A', value: 'a' }] }],
+};
+const runtimes = [];
+afterEach(() => {
+  runtimes.splice(0).forEach((runtime) => runtime.dispose());
+  vi.useRealTimers();
+});
+
+const setup = async (pending = []) => {
+  vi.useFakeTimers();
+  let onEvent;
+  const fetchImpl = vi.fn(async (url, options) => {
+    const path = url.pathname;
+    if (path === '/api/form') return Response.json({ data: pending });
+    if (path === '/api/session/ses_test') return Response.json({ data: { id: 'ses_test', location: { directory: '/project' } } });
+    if (path === '/api/session/ses_test/form/frm_question') return Response.json({ data: form });
+    if (path === '/api/session/ses_test/form/frm_question/reply' && options.method === 'POST') return new Response(null, { status: 204 });
+    return Response.json({ error: 'Not found' }, { status: 404 });
+  });
+  const runtime = createQuestionAutoDelegateRuntime({
+    globalEventHub: { subscribeEvent: (fn) => { onEvent = fn; return () => {}; } },
+    buildOpenCodeUrl: (path) => `http://opencode.test/api${path}`,
+    getOpenCodeAuthHeaders: () => ({}),
+    readSettingsFromDiskMigrated: async () => ({ projects: [{ path: '/project' }] }),
+    fetchImpl,
+  });
+  runtimes.push(runtime);
+  runtime.start();
+  await vi.advanceTimersByTimeAsync(0);
+  return {
+    runtime, fetchImpl,
+    emit: (type, data, directory = '/project') => onEvent({ directory: 'global', payload: {
+      type, data, ...(directory ? { location: { directory } } : {}),
+    } }),
+    posts: () => fetchImpl.mock.calls.filter(([, options]) => options.method === 'POST'),
+  };
+};
+
+it('auto-delegates a native question form after exactly 30 seconds without a UI', async () => {
+  const { emit, posts, runtime } = await setup();
+  emit('form.created', { sessionID: form.sessionID, form });
+  await vi.advanceTimersByTimeAsync(29_999);
+  expect(posts()).toHaveLength(0);
+  await vi.advanceTimersByTimeAsync(1);
+  expect(posts()).toHaveLength(1);
+  expect(posts()[0][0].pathname).toBe('/api/session/ses_test/form/frm_question/reply');
+  expect(JSON.parse(posts()[0][1].body)).toEqual({ answer: { approach: QUESTION_AUTO_DELEGATE_ANSWER } });
+  expect(runtime.snapshot().requests[0].state).toBe('settled');
+});
+
+it('recovers pending native question forms on startup', async () => {
+  const { posts } = await setup([form]);
+  await vi.advanceTimersByTimeAsync(30_000);
+  expect(posts()).toHaveLength(1);
+});
+
+it.each(['form.replied', 'form.cancelled'])('cancels the timer on %s', async (type) => {
+  const { emit, posts, runtime } = await setup();
+  emit('form.created', { sessionID: form.sessionID, form });
+  expect(runtime.snapshot().requests).toHaveLength(1);
+  emit(type, { sessionID: form.sessionID, id: form.id });
+  await vi.advanceTimersByTimeAsync(30_000);
+  expect(posts()).toHaveLength(0);
+  expect(runtime.snapshot().requests[0].state).toBe('settled');
+});
+
+it('does not auto-answer non-question forms', async () => {
+  const other = { ...form, metadata: { kind: 'configuration' } };
+  const { emit, posts, runtime } = await setup([other]);
+  emit('form.created', { sessionID: other.sessionID, form: other });
+  await vi.advanceTimersByTimeAsync(30_000);
+  expect(posts()).toHaveLength(0);
+  expect(runtime.snapshot().requests).toEqual([]);
+});
+
+it('resolves a directory-less event through the native session location', async () => {
+  const { emit, posts } = await setup();
+  emit('form.created', { form }, '');
+  await vi.advanceTimersByTimeAsync(30_000);
+  expect(posts()).toHaveLength(1);
+});
+
+it('preserves pending questions when native list reconciliation fails', async () => {
+  const { emit, runtime, fetchImpl, posts } = await setup();
+  emit('form.created', { form });
+  const original = fetchImpl.getMockImplementation();
+  fetchImpl.mockImplementation((url, options) => url.pathname === '/api/form'
+    ? Promise.resolve(new Response(null, { status: 503 })) : original(url, options));
+  await runtime.reconcile();
+  expect(runtime.snapshot().coverage.state).toBe('partial');
+  expect(runtime.snapshot().requests[0].state).toBe('counting');
+  await vi.advanceTimersByTimeAsync(30_000);
+  expect(posts()).toHaveLength(1);
+});
+
+it('pauses for retry when schema lookup fails, without sending an answer', async () => {
+  const { emit, runtime, fetchImpl, posts } = await setup();
+  emit('form.created', { form });
+  const original = fetchImpl.getMockImplementation();
+  fetchImpl.mockImplementation((url, options) => url.pathname.endsWith('/form/frm_question')
+    ? Promise.resolve(new Response(null, { status: 503 })) : original(url, options));
+  await vi.advanceTimersByTimeAsync(30_000);
+  expect(posts()).toHaveLength(0);
+  expect(runtime.snapshot().requests[0].state).toBe('paused');
+});
+
+it('honors user takeover and explicit delegation of native forms', async () => {
+  const { emit, runtime, posts } = await setup();
+  emit('form.created', { form });
+  const identity = { requestID: form.id, sessionID: form.sessionID, directory: '/project' };
+  await runtime.pause({ ...identity, reason: 'interaction' });
+  await vi.advanceTimersByTimeAsync(30_000);
+  expect(posts()).toHaveLength(0);
+  await runtime.delegate(identity);
+  expect(posts()).toHaveLength(1);
+});
+
+it('uses the freshly read schema for multiple fields and array answers', async () => {
+  const { emit, fetchImpl, posts } = await setup();
+  const original = fetchImpl.getMockImplementation();
+  fetchImpl.mockImplementation((url, options) => url.pathname.endsWith('/form/frm_question')
+    ? Promise.resolve(Response.json({ data: { ...form, fields: [
+      { key: 'actual_key', type: 'string', custom: true },
+      { key: 'targets', type: 'multiselect', custom: true, options: [] },
+    ] } })) : original(url, options));
+  emit('form.created', { form: { ...form, fields: [...form.fields, { key: 'old', type: 'multiselect' }] } });
+  await vi.advanceTimersByTimeAsync(30_000);
+  expect(JSON.parse(posts()[0][1].body)).toEqual({ answer: {
+    actual_key: QUESTION_AUTO_DELEGATE_ANSWER, targets: [QUESTION_AUTO_DELEGATE_ANSWER],
+  } });
+});

package/server/lib/quota/DOCUMENTATION.md

@@ -38,6 +38,15 @@ These provider IDs are currently dispatchable via `fetchQuotaForProvider(provide
 - `providers/openai.js` exists for logic parity/reuse but is intentionally not registered for dispatcher ID routing.
 
 ## Response contract
+Provider credentials are read asynchronously from the current OpenCode service via
+`opencode/auth.js`; only the selected credential is used. Account switching and
+logout are observed on the next request, without file fallback or persisted secret
+cache. Credential-list transport/auth/schema failure rejects the configured-provider
+list instead of returning an authoritative empty list; per-provider quota requests
+return `ok: false` with a sanitized error. VS Code uses the same credential adapter.
+OpenChamber-owned quota cookies and Grok/Antigravity-specific stores retain their
+separate explicit sources; they are not legacy OpenCode `auth.json` fallbacks.
+
 All providers should return results via shared helpers to preserve API shape:
 - Required fields: `providerId`, `providerName`, `ok`, `configured`, `usage`, `fetchedAt`
 - Optional field: `error`

package/server/lib/quota/provider-credentials.test.js

@@ -0,0 +1,29 @@
+import { afterEach, expect, it, vi } from 'vitest';
+import { configureOpenCodeCredentials } from '../opencode/auth.js';
+import { fetchQuota as fetchCodexQuota } from './providers/codex.js';
+import { fetchQuotaForProvider, listConfiguredQuotaProviders } from './providers/index.js';
+
+afterEach(() => { configureOpenCodeCredentials(null); vi.unstubAllGlobals(); });
+
+it('quota requests follow the current active account, then stop sending after logout', async () => {
+  let access = 'first-account';
+  configureOpenCodeCredentials(() => ({ credential: { list: async () => access ? [{ id: 'selected', integrationID: 'openai', active: true, value: { type: 'oauth', access, refresh: 'refresh', expires: 123 } }] : [] } }));
+  const fetchMock = vi.fn(async () => Response.json({ rate_limit: { primary_window: { used_percent: 20 } } }));
+  vi.stubGlobal('fetch', fetchMock);
+  await fetchCodexQuota();
+  expect(fetchMock.mock.calls[0][1].headers.Authorization).toBe('Bearer first-account');
+  access = 'second-account';
+  await fetchCodexQuota();
+  expect(fetchMock.mock.calls[1][1].headers.Authorization).toBe('Bearer second-account');
+  access = '';
+  await expect(fetchCodexQuota()).resolves.toMatchObject({ ok: false, configured: false });
+  expect(fetchMock).toHaveBeenCalledTimes(2);
+});
+
+it('quota source failure remains an error with no upstream secret in the response', async () => {
+  configureOpenCodeCredentials(() => ({ credential: { list: async () => { throw new Error('secret-from-upstream'); } } }));
+  await expect(listConfiguredQuotaProviders()).rejects.toThrow('Unable to read OpenCode credentials');
+  const result = await fetchQuotaForProvider('codex');
+  expect(result).toMatchObject({ ok: false, error: 'Unable to read OpenCode credentials' });
+  expect(JSON.stringify(result)).not.toContain('secret-from-upstream');
+});

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

@@ -1,4 +1,4 @@
-import { readAuthFile } from '../../opencode/auth.js';
+import { readOpenCodeCredentials } from '../../opencode/auth.js';
 import {
   getAuthEntry,
   normalizeAuthEntry,
@@ -12,14 +12,14 @@ export const providerId = 'claude';
 export const providerName = 'Claude';
 const aliases = ['anthropic', 'claude'];
 
-export const isConfigured = () => {
-  const auth = readAuthFile();
+export const isConfigured = async () => {
+  const auth = await readOpenCodeCredentials();
   const entry = normalizeAuthEntry(getAuthEntry(auth, aliases));
   return Boolean(entry?.access || entry?.token);
 };
 
 export const fetchQuota = async () => {
-  const auth = readAuthFile();
+  const auth = await readOpenCodeCredentials();
   const entry = normalizeAuthEntry(getAuthEntry(auth, aliases));
   const accessToken = entry?.access ?? entry?.token;
 

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

@@ -1,4 +1,4 @@
-import { readAuthFile } from '../../opencode/auth.js';
+import { readOpenCodeCredentials } from '../../opencode/auth.js';
 import {
   getAuthEntry,
   normalizeAuthEntry,
@@ -14,14 +14,14 @@ export const providerId = 'codex';
 export const providerName = 'Codex';
 const aliases = ['openai', 'codex', 'chatgpt'];
 
-export const isConfigured = () => {
-  const auth = readAuthFile();
+export const isConfigured = async () => {
+  const auth = await readOpenCodeCredentials();
   const entry = normalizeAuthEntry(getAuthEntry(auth, aliases));
   return Boolean(entry?.access || entry?.token);
 };
 
 export const fetchQuota = async () => {
-  const auth = readAuthFile();
+  const auth = await readOpenCodeCredentials();
   const entry = normalizeAuthEntry(getAuthEntry(auth, aliases));
   const accessToken = entry?.access ?? entry?.token;
   const accountId = entry?.accountId;

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

@@ -1,7 +1,7 @@
 import { afterEach, describe, expect, it, vi } from 'vitest';
 
 vi.mock('../../opencode/auth.js', () => ({
-  readAuthFile: () => ({ openai: { access: 'test-token' } }),
+  readOpenCodeCredentials: async () => ({ openai: { access: 'test-token' } }),
 }));
 
 import { fetchQuota } from './codex.js';

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

@@ -1,4 +1,4 @@
-import { readAuthFile } from '../../opencode/auth.js';
+import { readOpenCodeCredentials } from '../../opencode/auth.js';
 import {
   getAuthEntry,
   normalizeAuthEntry,
@@ -42,14 +42,14 @@ export const providerId = 'github-copilot';
 export const providerName = 'GitHub Copilot';
 const aliases = ['github-copilot', 'copilot'];
 
-export const isConfigured = () => {
-  const auth = readAuthFile();
+export const isConfigured = async () => {
+  const auth = await readOpenCodeCredentials();
   const entry = normalizeAuthEntry(getAuthEntry(auth, aliases));
   return Boolean(entry?.access || entry?.token);
 };
 
 export const fetchQuota = async () => {
-  const auth = readAuthFile();
+  const auth = await readOpenCodeCredentials();
   const entry = normalizeAuthEntry(getAuthEntry(auth, aliases));
   const accessToken = entry?.access ?? entry?.token;
 
@@ -107,7 +107,7 @@ export const providerIdAddon = 'github-copilot-addon';
 export const providerNameAddon = 'GitHub Copilot Add-on';
 
 export const fetchQuotaAddon = async () => {
-  const auth = readAuthFile();
+  const auth = await readOpenCodeCredentials();
   const entry = normalizeAuthEntry(getAuthEntry(auth, aliases));
   const accessToken = entry?.access ?? entry?.token;
 

package/server/lib/quota/providers/google/auth.js

@@ -14,7 +14,7 @@ import {
   asNonEmptyString,
   toTimestamp
 } from '../../utils/index.js';
-import { readAuthFile } from '../../../opencode/auth.js';
+import { readOpenCodeCredentials } from '../../../opencode/auth.js';
 import { parseGoogleRefreshToken } from './transforms.js';
 
 const ANTIGRAVITY_GOOGLE_CLIENT_ID =
@@ -90,8 +90,8 @@ const resolveAntigravityAuth = () => {
   return null;
 };
 
-export const resolveGoogleAuthSources = () => {
-  const auth = readAuthFile();
+export const resolveGoogleAuthSources = async () => {
+  const auth = await readOpenCodeCredentials();
   const sources = [];
 
   const geminiAuth = resolveGeminiCliAuth(auth);

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

@@ -17,10 +17,10 @@ export const providerId = 'google';
 export const providerName = 'Google';
 export const aliases = ['google', 'google.oauth'];
 
-export const isConfigured = () => resolveGoogleAuthSources().length > 0;
+export const isConfigured = async () => (await resolveGoogleAuthSources()).length > 0;
 
 export const fetchGoogleQuota = async () => {
-  const authSources = resolveGoogleAuthSources();
+  const authSources = await resolveGoogleAuthSources();
   if (!authSources.length) {
     return buildResult({
       providerId,

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

@@ -130,16 +130,12 @@ const registry = {
   }
 };
 
-export const listConfiguredQuotaProviders = () => {
+export const listConfiguredQuotaProviders = async () => {
   const configured = [];
 
   for (const [id, provider] of Object.entries(registry)) {
-    try {
-      if (provider.isConfigured()) {
-        configured.push(id);
-      }
-    } catch {
-      // Ignore provider-specific config errors in list API.
+    if (await provider.isConfigured()) {
+      configured.push(id);
     }
   }
 

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

@@ -11,7 +11,7 @@ describe('quota provider registry', () => {
     expect(typeof google.resolveGoogleAuthSources).toBe('function');
   });
 
-  it('can list configured providers without missing provider exports', () => {
-    expect(() => listConfiguredQuotaProviders()).not.toThrow();
+  it('reports unavailable credentials instead of an empty configured-provider list', async () => {
+    await expect(listConfiguredQuotaProviders()).rejects.toThrow('Unable to read OpenCode credentials');
   });
 });

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

@@ -1,4 +1,4 @@
-import { readAuthFile } from '../../opencode/auth.js';
+import { readOpenCodeCredentials } from '../../opencode/auth.js';
 import {
   getAuthEntry,
   normalizeAuthEntry,
@@ -14,14 +14,14 @@ export const providerId = 'kimi-for-coding';
 export const providerName = 'Kimi for Coding';
 const aliases = ['kimi-for-coding', 'kimi'];
 
-export const isConfigured = () => {
-  const auth = readAuthFile();
+export const isConfigured = async () => {
+  const auth = await readOpenCodeCredentials();
   const entry = normalizeAuthEntry(getAuthEntry(auth, aliases));
   return Boolean(entry?.key || entry?.token);
 };
 
 export const fetchQuota = async () => {
-  const auth = readAuthFile();
+  const auth = await readOpenCodeCredentials();
   const entry = normalizeAuthEntry(getAuthEntry(auth, aliases));
   const apiKey = entry?.key ?? entry?.token;
 

package/server/lib/quota/providers/minimax-shared.js

@@ -1,4 +1,4 @@
-import { readAuthFile } from '../../opencode/auth.js';
+import { readOpenCodeCredentials } from '../../opencode/auth.js';
 import {
   getAuthEntry,
   normalizeAuthEntry,
@@ -138,14 +138,14 @@ const calculateUsage = (model, isTokenPlan) => {
 };
 
 export const createMiniMaxCodingPlanProvider = ({ providerId, providerName, aliases, tokenPlanUrl, codingPlanUrl }) => {
-  const isConfigured = () => {
-    const auth = readAuthFile();
+  const isConfigured = async () => {
+    const auth = await readOpenCodeCredentials();
     const entry = normalizeAuthEntry(getAuthEntry(auth, aliases));
     return Boolean(entry?.key || entry?.token);
   };
 
   const fetchQuota = async () => {
-    const auth = readAuthFile();
+    const auth = await readOpenCodeCredentials();
     const entry = normalizeAuthEntry(getAuthEntry(auth, aliases));
     const apiKey = entry?.key ?? entry?.token;
 

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

@@ -1,4 +1,4 @@
-import { readAuthFile } from '../../opencode/auth.js';
+import { readOpenCodeCredentials } from '../../opencode/auth.js';
 import {
   getAuthEntry,
   normalizeAuthEntry,
@@ -14,14 +14,14 @@ export const providerId = 'nano-gpt';
 export const providerName = 'NanoGPT';
 const aliases = ['nano-gpt', 'nanogpt', 'nano_gpt'];
 
-export const isConfigured = () => {
-  const auth = readAuthFile();
+export const isConfigured = async () => {
+  const auth = await readOpenCodeCredentials();
   const entry = normalizeAuthEntry(getAuthEntry(auth, aliases));
   return Boolean(entry?.key || entry?.token);
 };
 
 export const fetchQuota = async () => {
-  const auth = readAuthFile();
+  const auth = await readOpenCodeCredentials();
   const entry = normalizeAuthEntry(getAuthEntry(auth, aliases));
   const apiKey = entry?.key ?? entry?.token;
 

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

@@ -1,4 +1,4 @@
-import { readAuthFile } from '../../opencode/auth.js';
+import { readOpenCodeCredentials } from '../../opencode/auth.js';
 import {
   getAuthEntry,
   normalizeAuthEntry,
@@ -12,14 +12,14 @@ const providerId = 'openai';
 const providerName = 'OpenAI';
 const aliases = ['openai', 'codex', 'chatgpt'];
 
-const isConfigured = () => {
-  const auth = readAuthFile();
+const isConfigured = async () => {
+  const auth = await readOpenCodeCredentials();
   const entry = normalizeAuthEntry(getAuthEntry(auth, aliases));
   return Boolean(entry?.access || entry?.token);
 };
 
 export const fetchQuota = async () => {
-  const auth = readAuthFile();
+  const auth = await readOpenCodeCredentials();
   const entry = normalizeAuthEntry(getAuthEntry(auth, aliases));
   const accessToken = entry?.access ?? entry?.token;