dsh-plugin-subscription-oauth 0.8.4 → 0.8.6

package/lib/auth/provider-controller.d.ts

@@ -163,6 +163,12 @@ export declare class ProviderController<S extends SessionBase> {
      * @throws {ProviderError} with `REAUTH_REQUIRED` when the account must sign in again.
      */
     refresh(account?: string): Promise<ProviderRefreshResult>;
+    /**
+     * Re-read the endpoint's live model list.
+     *
+     * @param force - fetch again even when a list was already read this session.
+     * @returns a fresh status.
+     */
     /**
      * Re-read the endpoint's live model list.
      *

package/lib/auth/provider-controller.js

@@ -271,6 +271,12 @@ export class ProviderController {
         this.lastError = undefined;
         return { account: token.account, expiresAt: token.expiresAt, status: await this.status() };
     }
+    /**
+     * Re-read the endpoint's live model list.
+     *
+     * @param force - fetch again even when a list was already read this session.
+     * @returns a fresh status.
+     */
     /**
      * Re-read the endpoint's live model list.
      *
@@ -287,23 +293,33 @@ export class ProviderController {
         // every startup would be noise.
         if (!await this.options.store.hasAny())
             return this.status();
-        let accessToken;
-        try {
-            accessToken = (await this.options.tokens.resolve()).accessToken;
-        }
-        catch (error) {
-            // Discovery is a convenience: an unusable session is reported by the
-            // card's account list, not as a second failure here.
-            this.options.onWarn?.(`${spec.id} model discovery skipped: ${messageOf(error)}`);
-            return this.status();
+        // The catalog is the union of every signed-in account's live list, because one
+        // model id draws on the whole pool: a model any account can serve must appear, and
+        // which account answers at call time is the scheduler's choice. A model only the
+        // non-default account has is offered, then may fall through to it on dispatch.
+        const discovered = [];
+        for (const account of Object.keys(await this.options.store.list())) {
+            let accessToken;
+            try {
+                accessToken = (await this.options.tokens.resolve(account)).accessToken;
+            }
+            catch (error) {
+                this.options.onWarn?.(`${spec.id} model discovery for ${account} skipped: ${messageOf(error)}`);
+                continue;
+            }
+            const ids = await spec.discover(accessToken);
+            if (ids !== undefined) {
+                for (const id of ids)
+                    if (!discovered.includes(id))
+                        discovered.push(id);
+            }
         }
-        const ids = await spec.discover(accessToken);
-        if (ids !== undefined) {
-            this.discovered = ids;
-            spec.applyDiscovery?.(ids);
+        if (discovered.length > 0) {
+            this.discovered = discovered;
+            spec.applyDiscovery?.(discovered);
             // A model this route now serves is no longer hand-added: keeping the extra
             // entry would list it as manual and invite a pointless "remove" later.
-            await this.forgetDiscovered(ids);
+            await this.forgetDiscovered(discovered);
             this.options.onCatalogChanged?.();
         }
         return this.status();

package/lib/providers/antigravity-catalog.js

@@ -98,9 +98,14 @@ function agentIds(payload) {
                 push(id);
         }
     }
-    if (isRecord(payload.tieredModelIds) && Array.isArray(payload.tieredModelIds.flash)) {
-        for (const id of payload.tieredModelIds.flash)
-            push(id);
+    if (isRecord(payload.tieredModelIds)) {
+        for (const key of Object.keys(payload.tieredModelIds)) {
+            const list = payload.tieredModelIds[key];
+            if (Array.isArray(list)) {
+                for (const id of list)
+                    push(id);
+            }
+        }
     }
     // No usable grouping: fall back to every entry, which is still better than nothing
     // as long as the non-agent surfaces are excluded.

package/lib/providers/antigravity.js

@@ -458,10 +458,11 @@ export class AntigravityAdapter extends LlmAdapter {
             const diag = [`pool=${accounts.join(',') || '(none)'}`];
             const tried = new Set();
             let token = await this.options.tokens.resolve();
-            // Move an account known to be spent (from a past failure) to the back, so a fresh
-            // request starts on one that has allowance. A lone account still serves.
-            const order = [...accounts.filter((a) => a !== token.account && !this.isSpent(a)), token.account,
-                ...accounts.filter((a) => a !== token.account && this.isSpent(a))];
+            // Stay on the default account until it refuses. opencodex keeps account affinity —
+            // a request stays on one account and only moves after a 429 — because switching
+            // accounts on every request is what reads to Google as two accounts in play at once
+            // and trips the verify gate. Reordering here caused exactly that.
+            const order = [token.account, ...accounts.filter((a) => a !== token.account)];
             for (const accountKey of order) {
                 if (tried.has(accountKey))
                     continue;
@@ -521,8 +522,15 @@ export class AntigravityAdapter extends LlmAdapter {
                 yield* streamAntigravity(response.body, () => { watchdog.pulse(); });
                 return;
             }
-            const exhausted = new LlmError(`Antigravity API: every account's allowance is spent [${diag.join(' | ')}]`, EMPTY_RESPONSE_CODE);
-            throw exhausted;
+            // Every account was tried and none served. The headline names the most actionable
+            // refusal — a 403 "verify your account" is something the user can fix in the browser;
+            // a 429 "allowance spent" just means wait for the reset. The diagnostic lists each
+            // account and the status it returned.
+            const last403 = diag.reduce((acc, line) => (line.startsWith('403 on') ? line : acc), undefined);
+            const message = last403 === undefined
+                ? `Antigravity API: every account's allowance is spent [${diag.join(' | ')}]`
+                : `Antigravity API request failed: ${last403.replace(/^403 on /, 'account ')} refused (HTTP 403: Verify your account to continue) [${diag.join(' | ')}]`;
+            throw new LlmError(message, EMPTY_RESPONSE_CODE);
         }
         catch (error) {
             throw mapFetchFailure('Antigravity API', this.refreshHint(error), watchdog, options.signal);

package/lib/providers/responses-stream.js

@@ -130,28 +130,17 @@ export async function* streamProviderResponses(options, input) {
         if (models.length === 0) {
             throw new LlmError(`${label} has no enabled model to dispatch to`, EMPTY_RESPONSE_CODE);
         }
-        // When the provider meters per account and an account's allowance can run out,
-        // every account is a candidate: a spent one falls through to the next, so one
-        // model id draws on the whole pool's allowance. Accounts are tried in order;
-        // the first that serves the request wins.
+        // Stay on the default account until it refuses. opencodex keeps account affinity — a
+        // request stays on one account and only moves after a 429 — because switching accounts
+        // on every request is what reads to a provider as several accounts in play at once and
+        // trips the safety gate. Reordering candidates here caused exactly that.
         let accounts = input.accounts === undefined
             ? undefined
             : [...await input.accounts()];
-        // Send work straight to an account that has allowance: one already known to be
-        // spent until a future reset is moved to the back, so a fresh request does not
-        // fail against it once to find out. This is a preference, not a skip — a lone
-        // account still serves, and the spent-retry below catches a stale record.
-        if (accounts !== undefined && accounts.length > 1 && input.isAccountSpent !== undefined) {
-            const fresh = [];
-            const tired = [];
-            for (const account of accounts) {
-                if (await input.isAccountSpent(account))
-                    tired.push(account);
-                else
-                    fresh.push(account);
-            }
-            if (tired.length > 0 && fresh.length > 0) {
-                accounts = [...fresh, ...tired];
+        if (accounts !== undefined && accounts.length > 1) {
+            const defaultAccount = await tokens.defaultAccount();
+            if (defaultAccount !== undefined) {
+                accounts = [defaultAccount, ...accounts.filter((a) => a !== defaultAccount)];
             }
         }
         const tryAccounts = accounts === undefined || accounts.length === 0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-subscription-oauth",
-  "version": "0.8.4",
+  "version": "0.8.6",
   "description": "Use subscription accounts as DeepSeek Harness LLM providers — Kimi Code (OAuth device flow), Grok / X Premium (OIDC + PKCE), Google Antigravity (Google OAuth + Cloud Code Assist) and GLM / BigModel (ZCode's browser sign-in) — with per-model visibility, drag-to-reorder Auto fallback and plan quotas from the web Settings page",
   "license": "MIT",
   "author": "EricFL1998",