dsh-plugin-subscription-oauth 0.17.3 → 0.17.5

package/lib/providers/antigravity.d.ts

@@ -254,6 +254,16 @@ export declare class AntigravityAdapter extends LlmAdapter {
     /** Translate an auth failure into the message a user can act on. */
     private refreshHint;
     /** Build and send one streaming request for one model. */
+    /**
+     * One dispatch attempt, retrying transient network faults before giving up on the account.
+     *
+     * A connect timeout or a dropped socket is a transport hiccup, not a refusal — the
+     * account is fine and the request never arrived, so it is worth a few backoff retries
+     * before the sweep moves on. An HTTP response (even a 429/403) is returned as-is: those
+     * drive the account-switch logic in {@link stream}, and must not be swallowed here.
+     * Non-network errors propagate untouched.
+     */
+    private requestWithRetry;
     private request;
     /** Resolve image blocks through the attachment service, when it is present. */
     private imageResolver;

package/lib/providers/antigravity.js

@@ -62,6 +62,40 @@ async function paceAntigravityAttempt(signal) {
         signal.addEventListener('abort', onAbort, { once: true });
     });
 }
+/** How many times a transient network fault is retried before the account is skipped. */
+const NETWORK_RETRY_ATTEMPTS = 3;
+/** Base delay between network retries; it doubles each attempt. */
+const NETWORK_RETRY_BASE_MS = 800;
+/**
+ * Whether an error from `fetch` is a transient network fault worth retrying.
+ *
+ * The Antigravity call is a single long-lived POST: a connect timeout, a reset, or a
+ * dropped socket is a transport hiccup, not a refusal — the account is fine, the request
+ * just never arrived. A thrown HTTP-shaped error or a non-network TypeError is not.
+ */
+function isTransientNetworkFault(error) {
+    if (error instanceof LlmError)
+        return false;
+    const text = errorChain(error).toLowerCase();
+    return /fetch failed|connect timeout|connection reset|econnreset|etimedout|econnrefused|socket hang up|network error|timed out/.test(text);
+}
+/**
+ * Sleep for a backoff beat, honouring the caller's abort.
+ * @param ms - how long to wait.
+ * @param signal - the caller's abort signal.
+ */
+function backoff(ms, signal) {
+    return new Promise((resolve) => {
+        if (signal.aborted)
+            return resolve();
+        const onAbort = () => { clearTimeout(timer); resolve(); };
+        const timer = setTimeout(() => {
+            signal.removeEventListener('abort', onAbort);
+            resolve();
+        }, ms);
+        signal.addEventListener('abort', onAbort, { once: true });
+    });
+}
 /** Default Cloud Code Assist origin. */
 export const ANTIGRAVITY_BASE_URL = 'https://daily-cloudcode-pa.googleapis.com';
 /** Production origin, tried when the daily one is unavailable. */
@@ -539,7 +573,7 @@ export class AntigravityAdapter extends LlmAdapter {
                 // beat before each retry. opencodex keeps this discipline with a request pacer;
                 // this is the same idea narrowed to one provider.
                 await paceAntigravityAttempt(watchdog.signal);
-                let response = await this.request(options, model, token.account, token.accessToken, watchdog.signal);
+                let response = await this.requestWithRetry(options, model, token.account, token.accessToken, watchdog.signal);
                 if (response.status === 401 || response.status === 403) {
                     // The stored token was accepted locally but refused on the wire; force one
                     // refresh. A 403 that survives the refresh is Google's "verify your account"
@@ -547,7 +581,7 @@ export class AntigravityAdapter extends LlmAdapter {
                     // so the call moves to the next account rather than failing. Only a 401 marks
                     // the credential as dead.
                     token = await this.options.tokens.resolve(token.account, true);
-                    response = await this.request(options, model, token.account, token.accessToken, watchdog.signal);
+                    response = await this.requestWithRetry(options, model, token.account, token.accessToken, watchdog.signal);
                     if (response.status === 401) {
                         this.options.onCredentialRejected?.(token.account);
                     }
@@ -575,6 +609,13 @@ export class AntigravityAdapter extends LlmAdapter {
                     diag.push(`403 on ${token.account}, another account already cooling; stopping the sweep`);
                 }
                 if (!response.ok) {
+                    if (response.status === 400) {
+                        // Google's 400 puts the offending field in error.details / fieldViolations, which
+                        // the generic errorBodyMessage does not surface; log the whole body so the real
+                        // cause is visible, since a bare "invalid argument" gives nothing to act on.
+                        const body = await response.clone().text().catch(() => '');
+                        this.options.onWarn?.(`antigravity: HTTP 400 body: ${body.slice(0, 600)}`);
+                    }
                     diag.push(`fail ${response.status} on ${token.account} (no switch)`);
                     const error = await httpLlmError(response, 'Antigravity API');
                     // The diagnostic rides the message so it surfaces where the user sees the
@@ -653,6 +694,33 @@ export class AntigravityAdapter extends LlmAdapter {
         return error;
     }
     /** Build and send one streaming request for one model. */
+    /**
+     * One dispatch attempt, retrying transient network faults before giving up on the account.
+     *
+     * A connect timeout or a dropped socket is a transport hiccup, not a refusal — the
+     * account is fine and the request never arrived, so it is worth a few backoff retries
+     * before the sweep moves on. An HTTP response (even a 429/403) is returned as-is: those
+     * drive the account-switch logic in {@link stream}, and must not be swallowed here.
+     * Non-network errors propagate untouched.
+     */
+    async requestWithRetry(options, model, account, accessToken, signal) {
+        let lastError;
+        for (let attempt = 0; attempt < NETWORK_RETRY_ATTEMPTS; attempt++) {
+            try {
+                return await this.request(options, model, account, accessToken, signal);
+            }
+            catch (error) {
+                if (!isTransientNetworkFault(error) || signal.aborted)
+                    throw error;
+                lastError = error;
+                this.options.onWarn?.(`antigravity: transient network fault (${errorChain(error)}); retrying`);
+                if (attempt < NETWORK_RETRY_ATTEMPTS - 1) {
+                    await backoff(NETWORK_RETRY_BASE_MS * 2 ** attempt, signal);
+                }
+            }
+        }
+        throw lastError;
+    }
     async request(options, model, account, accessToken, signal) {
         // Every call is scoped to the account's Cloud AI Companion project.
         const held = await this.options.tokens.session(account);

package/lib/providers/common.js

@@ -96,7 +96,13 @@ async function errorBodyMessage(response) {
                 const record = parsed;
                 const error = record.error;
                 if (typeof error === 'object' && error !== null) {
-                    const message = error.message;
+                    const errorRecord = error;
+                    const message = errorRecord.message;
+                    // Google puts the offending field in details[].fieldViolations, which the bare
+                    // message omits; surface it so a 400 names what to fix instead of "invalid argument".
+                    const detail = extractFieldViolations(errorRecord.details);
+                    if (detail !== undefined)
+                        return `${String(message ?? '').trim()} — ${detail}`;
                     if (typeof message === 'string' && message.trim() !== '')
                         return message.trim();
                 }
@@ -115,6 +121,29 @@ async function errorBodyMessage(response) {
         return undefined;
     }
 }
+/** The offending-field text inside a Google RPC error's `details` list, when present. */
+function extractFieldViolations(details) {
+    if (!Array.isArray(details))
+        return undefined;
+    const out = [];
+    for (const entry of details) {
+        if (typeof entry !== 'object' || entry === null)
+            continue;
+        const violations = entry.fieldViolations;
+        if (!Array.isArray(violations))
+            continue;
+        for (const violation of violations) {
+            if (typeof violation !== 'object' || violation === null)
+                continue;
+            const field = violation.field;
+            const description = violation.description;
+            if (typeof description === 'string' && description.trim() !== '') {
+                out.push(typeof field === 'string' && field.trim() !== '' ? `${field}: ${description.trim()}` : description.trim());
+            }
+        }
+    }
+    return out.length === 0 ? undefined : out.join('; ');
+}
 /**
  * Turn a non-2xx provider response into an LlmError carrying the status and
  * any rate-limit hint the headers disclosed.

package/package.json

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