dsh-plugin-subscription-oauth 0.8.2 → 0.8.4

package/lib/providers/antigravity.d.ts

@@ -32,6 +32,9 @@ export declare const ANTIGRAVITY_AUTHORIZE_URL = "https://accounts.google.com/o/
 export declare const ANTIGRAVITY_TOKEN_URL = "https://oauth2.googleapis.com/token";
 /** Google's profile endpoint, used for the account label. */
 export declare const ANTIGRAVITY_USERINFO_URL = "https://www.googleapis.com/oauth2/v2/userinfo";
+/** Minimum beat between Antigravity dispatch attempts, so a refused account is not re-hit
+ *  at once and a sweep across the pool does not become a burst. */
+export declare const ANTIGRAVITY_PACING_MS = 2000;
 /** Default Cloud Code Assist origin. */
 export declare const ANTIGRAVITY_BASE_URL = "https://daily-cloudcode-pa.googleapis.com";
 /** Production origin, tried when the daily one is unavailable. */

package/lib/providers/antigravity.js

@@ -34,6 +34,34 @@ export const ANTIGRAVITY_AUTHORIZE_URL = 'https://accounts.google.com/o/oauth2/v
 export const ANTIGRAVITY_TOKEN_URL = 'https://oauth2.googleapis.com/token';
 /** Google's profile endpoint, used for the account label. */
 export const ANTIGRAVITY_USERINFO_URL = 'https://www.googleapis.com/oauth2/v2/userinfo';
+/** Minimum beat between Antigravity dispatch attempts, so a refused account is not re-hit
+ *  at once and a sweep across the pool does not become a burst. */
+export const ANTIGRAVITY_PACING_MS = 2_000;
+/** The last moment an Antigravity dispatch started; the next waits out the beat. */
+let lastAntigravityDispatchAt = 0;
+/**
+ * Wait out the Antigravity pacing beat before a dispatch attempt.
+ *
+ * A request right after a refused one is what turns a transient Google safety check into
+ * a sustained block; a short, provider-scoped pause between attempts is the discipline
+ * that keeps the pool reachable. Aborts when the caller's signal fires.
+ *
+ * @param signal - the caller's abort signal.
+ */
+async function paceAntigravityAttempt(signal) {
+    const wait = lastAntigravityDispatchAt + ANTIGRAVITY_PACING_MS - Date.now();
+    lastAntigravityDispatchAt = Date.now();
+    if (wait <= 0 || signal.aborted)
+        return;
+    await new Promise((resolve) => {
+        const onAbort = () => { clearTimeout(timer); resolve(); };
+        const timer = setTimeout(() => {
+            signal.removeEventListener('abort', onAbort);
+            resolve();
+        }, wait);
+        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. */
@@ -439,6 +467,11 @@ export class AntigravityAdapter extends LlmAdapter {
                     continue;
                 tried.add(accountKey);
                 token = await this.options.tokens.resolve(accountKey);
+                // Pacing: a connect attempt right after a refused one is what turns a transient
+                // Google safety check into a sustained block, so the streamer waits out a short
+                // 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);
                 if (response.status === 401 || response.status === 403) {
                     // The stored token was accepted locally but refused on the wire; force one

package/lib/providers/responses-stream.d.ts

@@ -15,6 +15,12 @@ import type { GenerateOptions, StreamChunk } from '@deepseek-ai/dsh-llm';
 import type { SessionBase } from '../auth/store.js';
 import type { TokenManager } from '../auth/tokens.js';
 import type { UsageWindow } from '../protocol.js';
+/**
+ * Minimum beat between dispatch attempts on one route, so a refused account is not
+ * re-hit at once and a sweep across the pool does not become a burst. opencodex keeps
+ * this discipline with a request pacer; this is the same idea narrowed to one plugin.
+ */
+export declare const DISPATCH_PACING_MS = 2000;
 /**
  * Build the cross-account hooks one route needs to draw on its whole account pool.
  *

package/lib/providers/responses-stream.js

@@ -15,6 +15,35 @@ import { EMPTY_RESPONSE_CODE, LlmError } from '@deepseek-ai/dsh-llm';
 import { allowanceScheduler } from '../auth/allowance-scheduler.js';
 import { streamResponses } from '../translate/responses.js';
 import { httpLlmError, idleWatchdog, mapFetchFailure } from './common.js';
+/**
+ * Minimum beat between dispatch attempts on one route, so a refused account is not
+ * re-hit at once and a sweep across the pool does not become a burst. opencodex keeps
+ * this discipline with a request pacer; this is the same idea narrowed to one plugin.
+ */
+export const DISPATCH_PACING_MS = 2_000;
+/** Per-route last-dispatch instants, so each route paces its own attempts. */
+const lastDispatchAt = new Map();
+/**
+ * Wait out a route's pacing beat before a dispatch attempt.
+ *
+ * @param route - the route key pacing its own attempts.
+ * @param signal - the caller's abort signal.
+ */
+async function paceDispatch(route, signal) {
+    const last = lastDispatchAt.get(route) ?? 0;
+    const wait = last + DISPATCH_PACING_MS - Date.now();
+    lastDispatchAt.set(route, Date.now());
+    if (wait <= 0 || signal.aborted)
+        return;
+    await new Promise((resolve) => {
+        const onAbort = () => { clearTimeout(timer); resolve(); };
+        const timer = setTimeout(() => {
+            signal.removeEventListener('abort', onAbort);
+            resolve();
+        }, wait);
+        signal.addEventListener('abort', onAbort, { once: true });
+    });
+}
 /**
  * Build the cross-account hooks one route needs to draw on its whole account pool.
  *
@@ -130,6 +159,10 @@ export async function* streamProviderResponses(options, input) {
             : accounts;
         for (const accountKey of tryAccounts) {
             let token = await tokens.resolve(accountKey);
+            // Pace each dispatch: a request right after a refused one is what turns a
+            // transient safety check into a sustained block, so the streamer waits out a
+            // short beat before each attempt (the same discipline opencodex keeps).
+            await paceDispatch(label, watchdog.signal);
             // Track which accounts a spent-allowance already moved past, so a later model
             // in the chain does not re-try an account known to be exhausted.
             const spent = new Set();

package/package.json

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