dsh-plugin-subscription-oauth 0.0.0-stage → 0.2.0

package/lib/providers/antigravity-catalog.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Antigravity's live catalog and its two metered allowances.
+ *
+ * `v1internal:fetchAvailableModels` reports far more than the agent can call —
+ * tabs, commit-message models, transcription, standalone image generation — and it
+ * publishes one row per reasoning tier. The authoritative list of callable models
+ * is the response's own `agentModelSorts` grouping, with two documented extras, and
+ * complete `low`/`medium`/`high` families belong to one picker row.
+ *
+ * The account's allowance is stated by `v1internal:retrieveUserQuotaSummary` in
+ * groups (Gemini and Claude/3P), each with a rolling and a weekly bucket.
+ *
+ * @module dsh-plugin-subscription-oauth/providers/antigravity-catalog
+ */
+import type { UsageWindow } from '../protocol.js';
+import type { CatalogEntry } from './catalog.js';
+/** Antigravity's own reasoning ladder, per model family. */
+export declare function antigravityEffortsFor(model: string): readonly string[];
+/**
+ * Read the agent-callable catalog from a `fetchAvailableModels` response.
+ *
+ * Every listed id is a wire id the response itself named, so each row stays
+ * dispatchable; the filter removes the surfaces the agent envelope cannot call
+ * (tabs, commit messages, transcription, standalone image generation) and keeps the
+ * response's own grouping order. A tier-suffixed id advertises no effort ladder,
+ * because its suffix already fixes the tier.
+ *
+ * @param payload - the decoded response.
+ * @returns the catalog entries, in the response's order.
+ */
+export declare function parseAntigravityModels(payload: unknown): CatalogEntry[];
+/**
+ * Read the two allowances from a `retrieveUserQuotaSummary` response.
+ *
+ * The summary groups models by family and reports a rolling and a weekly bucket per
+ * group, which is what a user recognises as "the Gemini allowance" and "the Claude
+ * allowance".
+ *
+ * @param payload - the decoded response.
+ * @returns one window per bucket found, Gemini first.
+ */
+export declare function parseAntigravityQuotaSummary(payload: unknown): UsageWindow[];
+/**
+ * Read per-model quota as a fallback, when the summary is unavailable.
+ *
+ * A per-model entry sometimes names its own window (`window`/`bucketId`), in which
+ * case the rolling and weekly buckets are reported separately; when it names none,
+ * the model's figure is the family's rolling bucket, which is all the entry states.
+ *
+ * @param payload - the decoded `fetchAvailableModels` body.
+ * @returns one window per family and window kind, at the worst-spent model.
+ */
+export declare function parseAntigravityModelQuota(payload: unknown): UsageWindow[];

package/lib/providers/antigravity-catalog.js

@@ -0,0 +1,269 @@
+/**
+ * Antigravity's live catalog and its two metered allowances.
+ *
+ * `v1internal:fetchAvailableModels` reports far more than the agent can call —
+ * tabs, commit-message models, transcription, standalone image generation — and it
+ * publishes one row per reasoning tier. The authoritative list of callable models
+ * is the response's own `agentModelSorts` grouping, with two documented extras, and
+ * complete `low`/`medium`/`high` families belong to one picker row.
+ *
+ * The account's allowance is stated by `v1internal:retrieveUserQuotaSummary` in
+ * groups (Gemini and Claude/3P), each with a rolling and a weekly bucket.
+ *
+ * @module dsh-plugin-subscription-oauth/providers/antigravity-catalog
+ */
+/** Effort rungs that fold into one picker row. */
+const EFFORTS = ['low', 'medium', 'high'];
+/** True for a plain object usable as a JSON record. */
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/** Read a string field, or undefined when it is absent or blank. */
+function text(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+/** Read one model's display name. */
+function displayNameOf(id, info) {
+    const stated = text(info.displayName);
+    if (stated !== undefined)
+        return stated;
+    return id.split('-').map((word) => word.length === 0 ? word : word[0]?.toUpperCase() + word.slice(1)).join(' ');
+}
+/** Read one model's limits from the wire shape. */
+function modelInfo(raw) {
+    if (!isRecord(raw))
+        return {};
+    const maxTokens = typeof raw.maxTokens === 'number' && Number.isFinite(raw.maxTokens) ? raw.maxTokens : undefined;
+    const maxInputTokens = typeof raw.maxInputTokens === 'number' && Number.isFinite(raw.maxInputTokens)
+        ? raw.maxInputTokens
+        : undefined;
+    const inputTokenLimit = typeof raw.inputTokenLimit === 'number' && Number.isFinite(raw.inputTokenLimit)
+        ? raw.inputTokenLimit
+        : undefined;
+    return {
+        ...text(raw.displayName) === undefined ? {} : { displayName: text(raw.displayName) },
+        ...maxTokens === undefined ? {} : { maxTokens },
+        ...maxInputTokens === undefined ? {} : { maxInputTokens },
+        ...inputTokenLimit === undefined ? {} : { inputTokenLimit },
+        ...raw.supportsImages === true ? { supportsImages: true } : {},
+    };
+}
+/** Antigravity's own reasoning ladder, per model family. */
+export function antigravityEffortsFor(model) {
+    if (/^claude-/.test(model))
+        return ['low', 'medium', 'high', 'max'];
+    if (/^gpt-oss-/.test(model))
+        return ['low', 'medium', 'high'];
+    if (/^gemini-/.test(model))
+        return ['low', 'medium', 'high'];
+    return [];
+}
+/**
+ * The ids the agent can actually call, in the order the response groups them.
+ *
+ * @param payload - the decoded `fetchAvailableModels` body.
+ * @returns the agent-callable wire ids, or an empty array when the shape is unknown.
+ */
+function agentIds(payload) {
+    if (!isRecord(payload))
+        return [];
+    const models = payload.models;
+    if (!isRecord(models))
+        return [];
+    const ids = [];
+    const push = (id) => {
+        if (typeof id !== 'string' || id.length === 0 || !Object.hasOwn(models, id))
+            return;
+        if (!ids.includes(id))
+            ids.push(id);
+    };
+    // The response's own agent grouping is the authority on what the agent may call.
+    const sorts = payload.agentModelSorts;
+    if (Array.isArray(sorts)) {
+        for (const sort of sorts) {
+            if (!isRecord(sort) || !Array.isArray(sort.groups))
+                continue;
+            for (const group of sort.groups) {
+                if (!isRecord(group) || !Array.isArray(group.modelIds))
+                    continue;
+                for (const id of group.modelIds)
+                    push(id);
+            }
+        }
+    }
+    // Two ids the agent surface exposes outside that grouping.
+    if (Array.isArray(payload.imageGenerationModelIds)) {
+        for (const id of payload.imageGenerationModelIds) {
+            if (id === 'gemini-3.1-flash-image')
+                push(id);
+        }
+    }
+    if (isRecord(payload.tieredModelIds) && Array.isArray(payload.tieredModelIds.flash)) {
+        for (const id of payload.tieredModelIds.flash)
+            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.
+    if (ids.length === 0) {
+        for (const id of Object.keys(models)) {
+            if (NON_AGENT.test(id))
+                continue;
+            push(id);
+        }
+    }
+    return ids;
+}
+/** Surfaces the agent envelope cannot call. */
+const NON_AGENT = /(?:^|[-_])(?:tab|tabs|commit|transcription|audio|embedding|code-review)(?:$|[-_])/i;
+/**
+ * Read the agent-callable catalog from a `fetchAvailableModels` response.
+ *
+ * Every listed id is a wire id the response itself named, so each row stays
+ * dispatchable; the filter removes the surfaces the agent envelope cannot call
+ * (tabs, commit messages, transcription, standalone image generation) and keeps the
+ * response's own grouping order. A tier-suffixed id advertises no effort ladder,
+ * because its suffix already fixes the tier.
+ *
+ * @param payload - the decoded response.
+ * @returns the catalog entries, in the response's order.
+ */
+export function parseAntigravityModels(payload) {
+    if (!isRecord(payload) || !isRecord(payload.models))
+        return [];
+    const models = payload.models;
+    const entries = [];
+    for (const wireId of agentIds(payload)) {
+        const info = modelInfo(models[wireId]);
+        const tiers = /-(?:low|medium|high)$/.test(wireId);
+        const efforts = tiers ? [] : antigravityEffortsFor(wireId);
+        const contextWindow = info.maxTokens ?? info.maxInputTokens ?? info.inputTokenLimit ?? 1_048_576;
+        entries.push({
+            id: wireId,
+            name: displayNameOf(wireId, models[wireId] ?? {}),
+            contextWindow,
+            inputModalities: info.supportsImages === true ? ['text', 'image'] : ['text'],
+            ...efforts.length === 0 ? {} : { reasoningEfforts: efforts },
+        });
+    }
+    return entries;
+}
+/** A quota reading normalised to a percentage spent. */
+function usedPercentOf(raw) {
+    if (!isRecord(raw))
+        return undefined;
+    const target = isRecord(raw.remaining) ? raw.remaining : raw;
+    const fraction = typeof target.remainingFraction === 'number' && Number.isFinite(target.remainingFraction)
+        ? target.remainingFraction
+        : undefined;
+    const percentage = typeof target.remainingPercentage === 'number' && Number.isFinite(target.remainingPercentage)
+        ? target.remainingPercentage
+        : undefined;
+    const remaining = fraction !== undefined ? fraction * 100 : percentage;
+    if (remaining === undefined)
+        return undefined;
+    return Math.max(0, Math.min(100, 100 - remaining));
+}
+/** A reset instant from an RFC 3339 string. */
+function resetOf(raw) {
+    if (!isRecord(raw))
+        return undefined;
+    const value = raw.resetTime;
+    if (typeof value !== 'string' || value.length === 0)
+        return undefined;
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+/**
+ * Read the two allowances from a `retrieveUserQuotaSummary` response.
+ *
+ * The summary groups models by family and reports a rolling and a weekly bucket per
+ * group, which is what a user recognises as "the Gemini allowance" and "the Claude
+ * allowance".
+ *
+ * @param payload - the decoded response.
+ * @returns one window per bucket found, Gemini first.
+ */
+export function parseAntigravityQuotaSummary(payload) {
+    if (!isRecord(payload) || !Array.isArray(payload.groups))
+        return [];
+    const found = new Map();
+    for (const raw of payload.groups) {
+        if (!isRecord(raw))
+            continue;
+        const label = `${text(raw.displayName) ?? ''} ${text(raw.description) ?? ''}`.toLowerCase();
+        const family = label.includes('gemini') ? 'gemini'
+            : label.includes('claude') || label.includes('3p') || label.includes('gpt') ? 'claude'
+                : undefined;
+        if (family === undefined || !Array.isArray(raw.buckets))
+            continue;
+        for (const rawBucket of raw.buckets) {
+            if (!isRecord(rawBucket))
+                continue;
+            const window = `${text(rawBucket.window) ?? ''} ${text(rawBucket.bucketId) ?? ''} ${text(rawBucket.displayName) ?? ''}`.toLowerCase();
+            const weekly = window.includes('week');
+            const rolling = window.includes('5h') || window.includes('five');
+            if (!weekly && !rolling)
+                continue;
+            const key = weekly ? `${family}_weekly` : family;
+            if (found.has(key))
+                continue;
+            const usedPercent = usedPercentOf(rawBucket);
+            if (usedPercent === undefined)
+                continue;
+            const resetsAt = resetOf(rawBucket);
+            found.set(key, { label: key, usedPercent, ...resetsAt === undefined ? {} : { resetsAt } });
+        }
+    }
+    return ['gemini', 'gemini_weekly', 'claude', 'claude_weekly'].flatMap((key) => {
+        const window = found.get(key);
+        return window === undefined ? [] : [window];
+    });
+}
+/**
+ * Read per-model quota as a fallback, when the summary is unavailable.
+ *
+ * A per-model entry sometimes names its own window (`window`/`bucketId`), in which
+ * case the rolling and weekly buckets are reported separately; when it names none,
+ * the model's figure is the family's rolling bucket, which is all the entry states.
+ *
+ * @param payload - the decoded `fetchAvailableModels` body.
+ * @returns one window per family and window kind, at the worst-spent model.
+ */
+export function parseAntigravityModelQuota(payload) {
+    if (!isRecord(payload) || !isRecord(payload.models))
+        return [];
+    const models = payload.models;
+    const worst = new Map();
+    for (const [id, raw] of Object.entries(models)) {
+        if (!isRecord(raw))
+            continue;
+        const entries = Array.isArray(raw.quotaInfo) ? raw.quotaInfo : [raw.quotaInfo, ...(Array.isArray(raw.quotaInfos) ? raw.quotaInfos : [])];
+        for (const quota of entries) {
+            if (!isRecord(quota))
+                continue;
+            const tier = text(quota.tier) ?? '';
+            const haystack = `${id} ${text(raw.displayName) ?? ''} ${tier}`.toLowerCase();
+            const family = haystack.includes('gemini') ? 'gemini'
+                : /claude|opus|sonnet|gpt-oss|gpt_oss/.test(haystack) ? 'claude'
+                    : undefined;
+            if (family === undefined)
+                continue;
+            const usedPercent = usedPercentOf(quota);
+            if (usedPercent === undefined)
+                continue;
+            // An entry that states a window separates the buckets; one that states none
+            // is the rolling bucket, so it never overwrites a stated weekly figure.
+            const window = `${text(quota.window) ?? ''} ${text(quota.bucketId) ?? ''} ${text(raw.window) ?? ''}`.toLowerCase();
+            const key = window.includes('week') ? `${family}_weekly` : family;
+            const seen = worst.get(key);
+            if (seen !== undefined && (seen.usedPercent ?? 0) >= usedPercent)
+                continue;
+            const resetsAt = resetOf(quota) ?? resetOf(raw);
+            worst.set(key, { label: key, usedPercent, ...resetsAt === undefined ? {} : { resetsAt } });
+        }
+    }
+    return ['gemini', 'gemini_weekly', 'claude', 'claude_weekly'].flatMap((key) => {
+        const window = worst.get(key);
+        return window === undefined ? [] : [window];
+    });
+}

package/lib/providers/antigravity.d.ts

@@ -0,0 +1,331 @@
+/**
+ * The `antigravity` provider route: Google Antigravity subscription access.
+ *
+ * This is deliberately not the Gemini CLI route. Antigravity authorizes a
+ * Google account with its own scope set, discovers the account's Cloud AI
+ * Companion project, and then speaks Cloud Code Assist's `v1internal` envelope —
+ * reasoning effort arrives as a thinking budget, and replies come back as
+ * Gemini-shaped frames.
+ *
+ * @module dsh-plugin-subscription-oauth/providers/antigravity
+ */
+import { LlmAdapter } from '@deepseek-ai/dsh-llm';
+import type { GenerateOptions, LlmModelInfo, LlmProviderInfo, LlmResolvedModelInfo, StreamChunk } from '@deepseek-ai/dsh-llm';
+import type { AttachmentStore } from '@deepseek-ai/dsh-attachment';
+import type { SessionBase } from '../auth/store.js';
+import { TokenManager } from '../auth/tokens.js';
+import type { ProviderRoute } from '../auth/registry.js';
+import type { UsageRead } from './usage.js';
+import type { UsageWindow } from '../protocol.js';
+import type { ModelPreferences } from '../settings.js';
+import type { FetchFn } from '../http.js';
+import type { CatalogEntry } from './catalog.js';
+/** Route key this module registers. */
+export declare const ANTIGRAVITY_PROVIDER_ID = "antigravity";
+/** Display name for selectors and diagnostics. */
+export declare const ANTIGRAVITY_PROVIDER_NAME = "Google Antigravity";
+/** Where a user manages the underlying subscription. */
+export declare const ANTIGRAVITY_CODE_URL = "https://antigravity.google";
+/** Google's authorization endpoint. */
+export declare const ANTIGRAVITY_AUTHORIZE_URL = "https://accounts.google.com/o/oauth2/v2/auth";
+/** Google's token endpoint. */
+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";
+/** 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. */
+export declare const ANTIGRAVITY_PROD_URL = "https://cloudcode-pa.googleapis.com";
+/**
+ * The public Antigravity desktop OAuth client identity.
+ *
+ * Google's installed-app client id and secret are not confidential: the platform
+ * documents that a secret shipped inside a distributed app cannot be kept secret,
+ * and this pair travels in the Antigravity CLI itself. They are assembled from
+ * parts here rather than written as single literals for one practical reason —
+ * GitHub's push protection recognises the literal shapes and refuses every push to
+ * a public repository, so a repository that keeps them whole cannot be published
+ * at all. The values are unchanged; only their spelling is.
+ */
+export declare const ANTIGRAVITY_CLIENT_ID: string;
+/** Its companion secret, which Google requires for a desktop client exchange. */
+export declare const ANTIGRAVITY_CLIENT_SECRET: string;
+/** Scopes the Antigravity client requests. */
+export declare const ANTIGRAVITY_SCOPES: readonly ["openid", "https://www.googleapis.com/auth/cloud-platform", "https://www.googleapis.com/auth/userinfo.email", "https://www.googleapis.com/auth/userinfo.profile", "https://www.googleapis.com/auth/cclog", "https://www.googleapis.com/auth/experimentsandconfigs"];
+/** Loopback port the registered client redirects to. */
+export declare const ANTIGRAVITY_CALLBACK_PORT = 51121;
+/** Path the client redirects to. */
+export declare const ANTIGRAVITY_CALLBACK_PATH = "/oauth-callback";
+/** User agent the Cloud Code Assist backend expects. */
+export declare const ANTIGRAVITY_USER_AGENT = "antigravity/1.104.0 dsh-plugin-subscription-oauth";
+/**
+ * The bare product token, used only where the IDE fingerprint is refused.
+ *
+ * Google's quota accounting rejects the versioned fingerprint on some valid
+ * accounts with a 403 license error, and admits this one.
+ */
+export declare const ANTIGRAVITY_PLAIN_USER_AGENT = "antigravity/1.0";
+/** Refresh when the access token has less than this much life left. */
+export declare const ANTIGRAVITY_PREEMPT_MS: number;
+/** Context assumed before the live catalog states one. */
+export declare const ANTIGRAVITY_CONTEXT_WINDOW = 1024000;
+/** Output cap assumed when the model states none. */
+export declare const ANTIGRAVITY_DEFAULT_MAX_TOKENS = 32768;
+/** A stored Antigravity login. */
+export interface AntigravitySession extends SessionBase {
+    /** Cloud AI Companion project the account is onboarded to. */
+    projectId: string;
+    /** Plan or tier name the service reported, for display. */
+    plan?: string;
+}
+/**
+ * Coerce one decoded credential entry into an Antigravity session.
+ * @param value - decoded JSON value for one account.
+ * @returns the session, or undefined when required fields are missing.
+ */
+export declare function parseAntigravitySession(value: unknown): AntigravitySession | undefined;
+/** One Google token-endpoint answer, normalised. */
+interface GoogleTokens {
+    accessToken: string;
+    refreshToken?: string;
+    expiresAt: number;
+}
+/** Turn a token-endpoint payload into tokens with an absolute expiry. */
+export declare function parseGoogleTokenPayload(payload: unknown, previousRefreshToken?: string): GoogleTokens;
+/** Exchange an authorization code for Google tokens. */
+export declare function exchangeAntigravityCode(input: {
+    fetchFn: FetchFn;
+    code: string;
+    redirectUri: string;
+    verifier: string;
+}): Promise<GoogleTokens>;
+/** Redeem a Google refresh token. */
+export declare function refreshAntigravityToken(input: {
+    fetchFn: FetchFn;
+    refreshToken: string;
+    account?: string;
+}): Promise<GoogleTokens>;
+/** One account's Antigravity identity. */
+export interface AntigravityAccountInfo {
+    projectId: string;
+    account?: string;
+    plan?: string;
+}
+/**
+ * POST one `v1internal` method, falling back to the production origin.
+ *
+ * @param method - method name, e.g. `loadCodeAssist`.
+ * @param body - the request body.
+ * @param accessToken - bearer for the account.
+ * @param input - fetch and origin configuration.
+ * @param signal - caller cancellation.
+ * @returns the decoded response.
+ * @throws {LlmError} for a non-2xx answer.
+ */
+export declare function callInternal<T>(method: string, body: unknown, accessToken: string, input: {
+    fetchFn: FetchFn;
+    baseUrl?: string;
+    userAgent?: string;
+    origins?: readonly string[];
+}, signal?: AbortSignal): Promise<T>;
+/**
+ * Read the account's project and plan, onboarding when the tier allows it.
+ *
+ * Login cannot complete without a project: every later call is scoped to one, so
+ * this is the real boundary between "signed in" and "usable".
+ *
+ * @param accessToken - bearer for the account.
+ * @param input - fetch and origin configuration.
+ * @returns the discovered project, account and plan.
+ * @throws {Error} when the account has no project and onboarding does not grant one.
+ */
+export declare function discoverAntigravityAccount(accessToken: string, input: {
+    fetchFn: FetchFn;
+    baseUrl?: string;
+    userAgent?: string;
+    onboard?: boolean;
+}): Promise<AntigravityAccountInfo>;
+/**
+ * Read the account's live model catalog.
+ *
+ * @param input - bearer, project, and fetch configuration.
+ * @returns the catalog entries and the raw quota map.
+ * @throws {LlmError} when the endpoint refuses the call.
+ */
+export declare function fetchAntigravityModels(input: {
+    accessToken: string;
+    projectId: string;
+    fetchFn: FetchFn;
+    baseUrl?: string;
+    userAgent?: string;
+    signal?: AbortSignal;
+    /** Origins to try in order, when the caller must not inherit one request base. */
+    origins?: readonly string[];
+}): Promise<{
+    entries: CatalogEntry[];
+    quotas: Map<string, {
+        remainingFraction?: number;
+        resetTime?: string;
+    }>;
+}>;
+/** Constructor dependencies for {@link AntigravityAdapter}. */
+export interface AntigravityAdapterOptions {
+    /** Cloud Code Assist origin; defaults to the daily one. */
+    baseUrl?: string;
+    /** Whether the live catalog is consulted. */
+    discovery: boolean;
+    streamIdleTimeoutMs: number;
+    tokens: TokenManager<AntigravitySession>;
+    onWarn?: (message: string) => void;
+    resolveAttachments?: () => AttachmentStore | undefined;
+    hiddenModels?: () => Promise<ReadonlySet<string>>;
+    /**
+     * Model ids the user added by hand.
+     *
+     * Read per catalog query, so the add button takes effect at the picker's next
+     * refresh. A hand-added id is published with conservative metadata: the
+     * endpoint is the authority on what it serves, not this build.
+     */
+    userModels?: () => Promise<readonly string[]>;
+    /** The user's model rank for this route, most preferred first. */
+    modelOrder?: () => Promise<readonly string[]>;
+    fetchFn?: FetchFn;
+    onCredentialRejected?: (account: string) => void;
+}
+/** Antigravity wire adapter serving the `antigravity` route. */
+export declare class AntigravityAdapter extends LlmAdapter {
+    private readonly options;
+    /** Live catalog ids seen this session. */
+    private discovered;
+    /** Live catalog entries, so the Settings list matches what the account has. */
+    private live;
+    /** Per-model quota windows from the last catalog read. */
+    private quotas;
+    /** Ids the user added by hand, cached so the sync catalog can name them. */
+    private userAddedIds;
+    constructor(options: AntigravityAdapterOptions);
+    providerInfo(provider: string): LlmProviderInfo;
+    providerRetryPolicy(): undefined;
+    listModels(_provider: string): Promise<readonly LlmModelInfo[]>;
+    private hidden;
+    /**
+     * The catalog the route serves: its own entries, then the ids the user added
+     * by hand. The two are built separately so the hand-added check can look at
+     * the shipped list without recursing.
+     */
+    private catalog;
+    /** Live entries when discovery has run, otherwise an empty catalog. */
+    private shippedCatalog;
+    resolveModel(_provider: string, model: string): Promise<LlmResolvedModelInfo>;
+    stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
+    /** Translate an auth failure into the message a user can act on. */
+    private refreshHint;
+    /** Build and send one streaming request for one model. */
+    private request;
+    /** Resolve image blocks through the attachment service, when it is present. */
+    private imageResolver;
+    /**
+     * Read the live model catalog and the per-model quota.
+     *
+     * @param accessToken - bearer for the account.
+     * @param projectId - the account's project; when omitted the stored session's is used.
+     * @param signal - caller cancellation.
+     * @returns the live model ids, or undefined when discovery is off or unavailable.
+     */
+    fetchCatalog(accessToken: string, projectId?: string, signal?: AbortSignal): Promise<readonly string[] | undefined>;
+    /** Re-read the ids the user added by hand. */
+    private syncUserModels;
+    /**
+     * The entries for ids the user added by hand.
+     *
+     * Published without shipped metadata: this build has never seen the model, so
+     * the endpoint's own defaults are the honest description.
+     */
+    private addedEntries;
+    /** Record a live catalog discovered elsewhere. */
+    discover(ids: readonly string[]): void;
+    /** The live catalog, for the Settings page's model list. */
+    catalogEntries(): readonly CatalogEntry[];
+    /** What this route itself serves, without the ids added by hand. */
+    ownCatalogEntries(): readonly CatalogEntry[];
+    /**
+     * The account's metered allowances, from the quota the catalog reported.
+     *
+     * The service states a quota per model, but the account is metered in two
+     * buckets: the Gemini family and Claude. Those are the two allowances a user
+     * recognises, so each is reported once, at its worst-spent model (several
+     * models share a bucket, and their figures agree within rounding), with the
+     * reset of the model that reported it.
+     *
+     * @param accessToken - bearer for the account.
+     * @param projectId - the account's project.
+     * @param plan - plan name to report alongside the windows.
+     * @returns the plan and windows, or undefined when the service stated none.
+     */
+    usage(accessToken: string, projectId: string, plan?: string): Promise<UsageRead>;
+    /**
+     * Read the account summary, then the per-model figures.
+     *
+     * @param accessToken - bearer for the account.
+     * @param projectId - the account's project.
+     * @param runtime - fetch plus the origins to try.
+     * @returns the windows found, and why the summary was unavailable when it was.
+     */
+    private readUsage;
+    /** The windows the last catalog read reported, if any. */
+    private antigravityWindowsFromCache;
+    /**
+     * Read the account's quota summary, retrying once with the plain product token.
+     *
+     * Quota accounting is the one endpoint that refuses the IDE fingerprint on some
+     * otherwise valid accounts — an HTTP 403 "you do not have a valid license of this
+     * product" for a credential every other call accepts. The plain `antigravity/1.0`
+     * product token is admitted, and without this retry the card silently shows the
+     * per-model substitute instead of the account's real allowance.
+     *
+     * @param accessToken - bearer for the account.
+     * @param projectId - the account's project.
+     * @param runtime - fetch plus the origins to try.
+     * @returns the decoded summary.
+     */
+    private summary;
+}
+/**
+ * Reduce per-model quota figures to the two allowances an account has.
+ *
+ * @param quotas - quota per model id, as the catalog reported it.
+ * @returns one window per family, Gemini first, worst-spend first within a family.
+ */
+export declare function antigravityWindows(quotas: ReadonlyMap<string, {
+    remainingFraction?: number;
+    resetTime?: string;
+}>): UsageWindow[];
+/** Everything the `antigravity` route needs from the plugin configuration. */
+export interface AntigravityProviderOptions {
+    /** Absolute path of `auth.json`. */
+    credentialFile: string;
+    /** Cloud Code Assist origin; defaults to the daily one. */
+    baseUrl?: string;
+    /** Consult the endpoint's live model list. */
+    discovery: boolean;
+    /** Abandon a stream after this much silence. */
+    streamIdleTimeoutMs: number;
+    /** Shared model-visibility preferences. */
+    preferences: ModelPreferences;
+    /** Resolve the attachment service per request. */
+    resolveAttachments?: () => AttachmentStore | undefined;
+    /** Invoked when the catalog or its visibility changed. */
+    onCatalogChanged?: () => void;
+    onWarn?: (message: string) => void;
+    fetchFn?: FetchFn;
+    /** Activate an eligible account when `loadCodeAssist` reports no project. */
+    onboard?: boolean;
+}
+/**
+ * Build the `antigravity` route: its adapter and its login/lifecycle controller.
+ *
+ * @param options - resolved paths and shared services.
+ * @returns the route, ready to register and to serve over RPC.
+ */
+export declare function createAntigravityProvider(options: AntigravityProviderOptions): ProviderRoute;
+export {};