dsh-plugin-subscription-oauth 0.8.5 → 0.8.7

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.
@@ -111,6 +116,19 @@ function agentIds(payload) {
             push(id);
         }
     }
+    // The response also carries models under API_PROVIDER_GOOGLE_GEMINI /
+    // ANTHROPIC_VERTEX / OPENAI_VERTEX that the agent grouping does not name (3.1 Pro,
+    // 3 Flash, the flash family). Keep every one of those; NON_AGENT surfaces stay out.
+    for (const [id, value] of Object.entries(models)) {
+        if (NON_AGENT.test(id))
+            continue;
+        if (!isRecord(value))
+            continue;
+        const api = value.apiProvider;
+        if (api === 'API_PROVIDER_GOOGLE_GEMINI' || api === 'API_PROVIDER_ANTHROPIC_VERTEX' || api === 'API_PROVIDER_OPENAI_VERTEX') {
+            push(id);
+        }
+    }
     return ids;
 }
 /** Surfaces the agent envelope cannot call. */
@@ -131,6 +149,18 @@ export function parseAntigravityModels(payload) {
     if (!isRecord(payload) || !isRecord(payload.models))
         return [];
     const models = payload.models;
+    // TEMP diagnostics: write the raw model-id list to a file so an over-eager filter is
+    // inspectable after a discovery run, since the node half's stdout is unreachable in
+    // the desktop shell.
+    try {
+        const all = Object.keys(models);
+        const kept = agentIds(payload);
+        const { writeFileSync } = require('node:fs');
+        const { homedir } = require('node:os');
+        const { join } = require('node:path');
+        writeFileSync(join(homedir(), '.dsh', 'antigravity-models-debug.json'), JSON.stringify({ all, kept, dropped: all.filter((id) => !kept.includes(id)) }, null, 2), 'utf8');
+    }
+    catch { /* diagnostics never break parsing */ }
     const entries = [];
     for (const wireId of agentIds(payload)) {
         const info = modelInfo(models[wireId]);

package/lib/providers/antigravity.d.ts

@@ -170,6 +170,7 @@ export declare function fetchAntigravityModels(input: {
         remainingFraction?: number;
         resetTime?: string;
     }>;
+    raw: Record<string, unknown>;
 }>;
 /** Constructor dependencies for {@link AntigravityAdapter}. */
 export interface AntigravityAdapterOptions {

package/lib/providers/antigravity.js

@@ -329,6 +329,16 @@ export async function fetchAntigravityModels(input) {
     if (typeof models !== 'object' || models === null) {
         throw new LlmError('Antigravity models endpoint returned no models object', 'MALFORMED_RESPONSE');
     }
+    // TEMP diagnostics: write the raw model-id list to a file so an over-eager filter is
+    // inspectable after a discovery run, since the node half's stdout is unreachable in
+    // the desktop shell.
+    try {
+        const { writeFileSync } = require('node:fs');
+        const { homedir } = require('node:os');
+        const { join } = require('node:path');
+        writeFileSync(join(homedir(), '.dsh', 'antigravity-raw-models.json'), JSON.stringify(Object.keys(models), null, 2), 'utf8');
+    }
+    catch { /* diagnostics never break parsing */ }
     // The response names far more than the agent may call; the filter keeps the
     // callable grouping and reports the per-model quota for the fallback path.
     const entries = parseAntigravityModels(payload);
@@ -341,7 +351,7 @@ export async function fetchAntigravityModels(input) {
         if (quota !== undefined)
             quotas.set(id, quota);
     }
-    return { entries, quotas };
+    return { entries, quotas, raw: models };
 }
 /** One quota window in the shape the protocol uses. */
 function quotaWindow(scope, quota) {
@@ -522,8 +532,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-subscription-oauth",
-  "version": "0.8.5",
+  "version": "0.8.7",
   "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",