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

package/lib/providers/account-preferences.d.ts

@@ -0,0 +1,46 @@
+import { LlmAdapter } from '@deepseek-ai/dsh-llm';
+import type { GenerateOptions, LlmModelInfo, LlmProviderInfo, LlmResolvedModelInfo, PreparedAdapterCall, StreamChunk } from '@deepseek-ai/dsh-llm';
+import type { ProviderId } from '../auth/store.js';
+import type { ProviderSettingsStore, AccountPreferences } from '../provider-settings.js';
+import type { AccountAwareAdapter } from './accounts.js';
+import type { PoolAdapter } from './pool.js';
+/** Reserved namespace, recognized even when malformed or no longer enabled. */
+export declare const ACCOUNT_MODEL_PREFIX = "~account:";
+export declare function accountModelId(account: string, model: string): string;
+export declare function parseAccountModelId(id: string): {
+    account: string;
+    model: string;
+} | undefined;
+export declare function accountAllowsPool(preferences: AccountPreferences | undefined, model: string): boolean;
+interface Options {
+    provider: ProviderId;
+    adapter: AccountAwareAdapter;
+    settings: ProviderSettingsStore;
+    accounts: () => Promise<readonly {
+        key: string;
+        label: string;
+    }[]>;
+    pool: () => PoolAdapter | undefined;
+    /** Per-account discovery bound (defaults to {@link DISCOVERY_TIMEOUT_MS}; tests shorten it). */
+    discoveryTimeoutMs?: number;
+}
+/** Keeps the registered route separate from raw adapters and pool member seams. */
+export declare class AccountPreferencesAdapter extends LlmAdapter {
+    private readonly options;
+    constructor(options: Options);
+    providerInfo(provider: string): LlmProviderInfo;
+    providerRetryPolicy(provider: string): import("@deepseek-ai/dsh-llm").ResolvedRetryPolicy | undefined;
+    private preference;
+    private models;
+    private requireAccount;
+    private fallback;
+    /** Pool-only facade: explicit families/tiers must obey the same policy as auto pools. */
+    poolMember(): AccountAwareAdapter;
+    listModels(provider: string): Promise<readonly LlmModelInfo[]>;
+    resolveModel(provider: string, id: string, signal?: AbortSignal): Promise<LlmResolvedModelInfo>;
+    prepareCall(provider: string, id: string, signal?: AbortSignal): Promise<PreparedAdapterCall>;
+    /** Presentation only: routing still uses the original model id. */
+    private present;
+    stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
+}
+export {};

package/lib/providers/account-preferences.js

@@ -0,0 +1,188 @@
+import { LlmAdapter, LlmError } from '@deepseek-ai/dsh-llm';
+import { DISCOVERY_TIMEOUT_MS, withAbortSignal, withTimeout } from './common.js';
+import { streamAccountWithReplay } from './replay.js';
+/** Reserved namespace, recognized even when malformed or no longer enabled. */
+export const ACCOUNT_MODEL_PREFIX = '~account:';
+export function accountModelId(account, model) {
+    return `${ACCOUNT_MODEL_PREFIX}${encodeURIComponent(account)}:${encodeURIComponent(model)}`;
+}
+export function parseAccountModelId(id) {
+    if (!id.startsWith(ACCOUNT_MODEL_PREFIX))
+        return undefined;
+    const parts = id.slice(ACCOUNT_MODEL_PREFIX.length).split(':');
+    try {
+        if (parts.length !== 2)
+            throw new Error();
+        const account = decodeURIComponent(parts[0]);
+        const model = decodeURIComponent(parts[1]);
+        if (!account || !model || accountModelId(account, model) !== id)
+            throw new Error();
+        return { account, model };
+    }
+    catch {
+        throw new LlmError('Invalid independent account model id', 'NO_ADAPTER');
+    }
+}
+export function accountAllowsPool(preferences, model) {
+    return preferences?.poolEnabled !== false && (preferences?.poolModels?.includes(model) ?? true);
+}
+/** Keeps the registered route separate from raw adapters and pool member seams. */
+export class AccountPreferencesAdapter extends LlmAdapter {
+    options;
+    constructor(options) {
+        super();
+        this.options = options;
+    }
+    providerInfo(provider) {
+        const info = this.options.adapter.providerInfo(provider);
+        // Native model groups read provider metadata, separately from model names.
+        return { ...info, name: this.options.settings.get(this.options.provider).displayName ?? info.name };
+    }
+    providerRetryPolicy(provider) { return this.options.adapter.providerRetryPolicy(provider); }
+    preference(account) {
+        const accounts = this.options.settings.get(this.options.provider).accounts;
+        return accounts && Object.hasOwn(accounts, account) ? accounts[account] : undefined;
+    }
+    async models(account, signal) {
+        const models = await withAbortSignal(() => withTimeout(signal => this.options.adapter.listOwnModels(this.options.provider, account, signal, true), this.options.discoveryTimeoutMs ?? DISCOVERY_TIMEOUT_MS), signal);
+        if (models !== undefined)
+            return models;
+        // Discovery timed out: the catalog this account listed last time beats
+        // "no models", which would fail the turn with "No eligible account".
+        return await withAbortSignal(async () => this.options.adapter.lastKnownOwnModels?.(this.options.provider, account), signal) ?? [];
+    }
+    async requireAccount(account, model, independent, signal) {
+        if (!(await withAbortSignal(this.options.accounts, signal)).some(entry => entry.key === account)
+            || (independent ? this.preference(account)?.independentEntry !== true : !accountAllowsPool(this.preference(account), model))
+            || !(await this.models(account, signal)).some(entry => entry.id === model)) {
+            throw new LlmError(`Account route unavailable: ${this.options.provider}/${account}/${model}`, 'NO_ADAPTER');
+        }
+    }
+    async fallback(model, signal) {
+        for (const { key } of await withAbortSignal(this.options.accounts, signal)) {
+            if (!accountAllowsPool(this.preference(key), model))
+                continue;
+            try {
+                await this.requireAccount(key, model, false, signal);
+                return key;
+            }
+            catch {
+                signal?.throwIfAborted();
+            }
+        }
+        throw new LlmError(`No eligible account for ${this.options.provider}/${model}`, 'NO_ADAPTER');
+    }
+    /** Pool-only facade: explicit families/tiers must obey the same policy as auto pools. */
+    poolMember() {
+        const raw = this.options.adapter;
+        const keyFor = async (account, model, signal) => {
+            if (model.startsWith(ACCOUNT_MODEL_PREFIX))
+                throw new LlmError('Independent entries cannot be pool members', 'NO_ADAPTER');
+            const key = account ?? (await withAbortSignal(this.options.accounts, signal))[0]?.key;
+            if (!key)
+                throw new LlmError('No account available', 'NO_ADAPTER');
+            await this.requireAccount(key, model, false, signal);
+            return key;
+        };
+        return new Proxy(raw, { get: (target, property) => {
+                if (property === 'streamAccount')
+                    return async function* (options, account) {
+                        let key;
+                        try {
+                            key = await keyFor(account, options.model, options.signal);
+                        }
+                        catch (cause) {
+                            options.signal?.throwIfAborted();
+                            // Skip policy-excluded members without poisoning account health. The
+                            // pool treats TRANSPORT as switch-without-cooldown; raw is never called.
+                            throw new LlmError('Pool member unavailable under account preferences', 'TRANSPORT', { cause });
+                        }
+                        yield* raw.streamAccount(options, key);
+                    };
+                if (property === 'resolveOwnModel')
+                    return async (provider, model, account) => raw.resolveOwnModel(provider, model, await keyFor(account, model));
+                const value = Reflect.get(target, property);
+                return typeof value === 'function' ? value.bind(target) : value;
+            } });
+    }
+    async listModels(provider) {
+        const result = new Map();
+        const catalogs = await Promise.all((await this.options.accounts()).map(async (account) => ({ ...account, models: await this.models(account.key).catch(() => []) })));
+        for (const { key, label, models } of catalogs) {
+            const preferences = this.preference(key);
+            for (const model of models) {
+                if (model.id.startsWith(ACCOUNT_MODEL_PREFIX))
+                    continue;
+                if (accountAllowsPool(preferences, model.id) && this.options.settings.visible(this.options.provider, model.id) && !result.has(model.id))
+                    result.set(model.id, model);
+                if (preferences?.independentEntry === true && this.options.settings.visible(this.options.provider, model.id)) {
+                    const id = accountModelId(key, model.id);
+                    result.set(id, { ...model, id, name: `${preferences.alias || label} · ${this.options.settings.modelName(this.options.provider, model.id, model.name)}` });
+                }
+            }
+        }
+        for (const model of await this.options.pool()?.modelsForProvider(this.options.provider) ?? []) {
+            if (model.id.startsWith(ACCOUNT_MODEL_PREFIX) || !this.options.settings.visible(this.options.provider, model.id))
+                continue;
+            try {
+                await this.options.pool().resolveModel(provider, model.id);
+                result.set(model.id, model);
+            }
+            catch { /* excluded tier */ }
+        }
+        const priority = (model) => model.priority ?? Number.MAX_SAFE_INTEGER;
+        return [...result.values()].map(model => ({ ...model,
+            name: this.options.settings.modelName(this.options.provider, model.id, model.name),
+        })).sort((left, right) => priority(left) - priority(right));
+    }
+    async resolveModel(provider, id, signal) {
+        return (await this.prepareCall(provider, id, signal)).model;
+    }
+    async prepareCall(provider, id, signal) {
+        signal?.throwIfAborted();
+        const independent = parseAccountModelId(id);
+        const pool = this.options.pool();
+        if (!independent && pool && await withAbortSignal(() => pool.owns(this.options.provider, id), signal)) {
+            const prepared = await pool.prepareCall(provider, id, signal);
+            return { ...prepared, model: this.present(id, prepared.model) };
+        }
+        const account = independent?.account ?? await this.fallback(id, signal);
+        const model = independent?.model ?? id;
+        if (independent)
+            await this.requireAccount(account, model, true, signal);
+        const info = await withAbortSignal(() => this.options.adapter.resolveOwnModel(provider, model, account), signal);
+        const label = independent ? (await withAbortSignal(this.options.accounts, signal)).find(entry => entry.key === account)?.label ?? account : undefined;
+        const owner = this;
+        const named = this.present(model, info);
+        return {
+            model: independent ? { ...named, id, name: `${this.preference(account)?.alias || label} · ${named.name}` } : named,
+            async *stream(options) {
+                // Keep the capability-bearing account; revoked permission must fail instead of rerouting.
+                await owner.requireAccount(account, model, independent !== undefined, options.signal);
+                options.signal?.throwIfAborted();
+                yield* streamAccountWithReplay(owner.options.adapter, options, account, model);
+            },
+        };
+    }
+    /** Presentation only: routing still uses the original model id. */
+    present(id, info) {
+        return { ...info, name: this.options.settings.modelName(this.options.provider, id, info.name) };
+    }
+    async *stream(options) {
+        const independent = parseAccountModelId(options.model);
+        if (independent) {
+            await this.requireAccount(independent.account, independent.model, true, options.signal);
+            options.signal?.throwIfAborted();
+            yield* streamAccountWithReplay(this.options.adapter, options, independent.account, independent.model);
+            return;
+        }
+        const pool = this.options.pool();
+        if (pool && await withAbortSignal(() => pool.owns(this.options.provider, options.model), options.signal)) {
+            yield* pool.stream(options);
+            return;
+        }
+        const account = await this.fallback(options.model, options.signal);
+        options.signal?.throwIfAborted();
+        yield* streamAccountWithReplay(this.options.adapter, options, account);
+    }
+}

package/lib/providers/accounts.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Multi-account token plumbing: one {@link AccountTokenManager} per provider
+ * owns a lazily-built {@link TokenManager} per account, so refresh coalescing
+ * (`inflight`) and permanent-failure removal stay scoped to ONE account —
+ * a revoked account deletes itself without touching its siblings.
+ *
+ * {@link AccountAwareAdapter} is the internal interface the pool uses to
+ * stream through a specific account. A catalog model listed by several
+ * accounts failovers; one listed by a single account is pinned to it.
+ */
+import { LlmAdapter } from '@deepseek-ai/dsh-llm';
+import type { GenerateOptions, LlmModelInfo, LlmResolvedModelInfo, StreamChunk } from '@deepseek-ai/dsh-llm';
+import { TokenManager } from './common.js';
+import type { TokenManagerOptions } from './common.js';
+import type { AccountEntry, ProviderId } from '../auth/store.js';
+export { DISCOVERY_TIMEOUT_MS } from './common.js';
+/** Minimal session shape the token managers need (mirrors common.ts). */
+interface TimedSession {
+    accessToken: string;
+    refreshToken: string;
+    expiresAt: number;
+}
+/** An adapter that can stream through a named account (the pool's seam). */
+export interface AccountAwareAdapter extends LlmAdapter {
+    /** Stream using the given account's credentials instead of the default. */
+    streamAccount(options: GenerateOptions, account: string): AsyncIterable<StreamChunk>;
+    /**
+     * The provider's own catalog: one account when `account` is set, otherwise
+     * the union of every logged-in account (default first; later duplicates
+     * dropped). The picker uses the union; pool assembly lists each account.
+     * `preferCached` serves saved metadata without starting an interactive refresh.
+     */
+    listOwnModels(provider: string, account?: string, signal?: AbortSignal, preferCached?: boolean): Promise<readonly LlmModelInfo[]>;
+    /**
+     * The last catalog one account successfully listed, with no network.
+     * Routing falls back to it when a live `listOwnModels` times out.
+     */
+    lastKnownOwnModels?(provider: string, account: string): Promise<readonly LlmModelInfo[] | undefined>;
+    /**
+     * Capability resolution of the provider's OWN models, bypassing the pool
+     * delegation. The pool resolves its members through this — an account pool
+     * reuses the catalog wire id (e.g. `gpt-5.4`), so resolveModel would
+     * otherwise bounce straight back into the pool forever. The optional account
+     * lets adapters with account-specific limits resolve that member conservatively.
+     */
+    resolveOwnModel(provider: string, model: string, account?: string): Promise<LlmResolvedModelInfo>;
+    /** Drop cached catalogs: one account, or every account when omitted (login/logout). */
+    clearAccountCatalog(account?: string): void;
+}
+/** Options for {@link unionAccountCatalogs}. */
+export interface UnionAccountCatalogsOptions {
+    /** Per-account bound; a hang sits that account out instead of blocking the picker. */
+    timeoutMs?: number;
+    /** Caller cancellation; aborting drops the whole union. */
+    signal?: AbortSignal;
+}
+/**
+ * Merge per-account catalogs, keeping the first occurrence of each model id.
+ * Rows that carry a numeric `priority` (Codex discovery) are then ordered by
+ * it so a model only the second account lists — e.g. `gpt-5.6-sol` — still
+ * sits with its generation instead of being appended after the default
+ * account's older ids.
+ */
+export declare function unionAccountCatalogs(accounts: readonly string[], listOne: (account: string, signal?: AbortSignal) => Promise<readonly LlmModelInfo[]>, options?: UnionAccountCatalogsOptions): Promise<LlmModelInfo[]>;
+/** Store I/O behind {@link AccountTokenManager} (injectable for tests). */
+export interface AccountStoreIo<S> {
+    list(): Promise<AccountEntry<S>[]>;
+    get(account?: string): Promise<S | undefined>;
+    save(account: string, session: S): Promise<void>;
+    remove(account: string): Promise<void>;
+    /** Resolve a legacy alias to the canonical account key. */
+    resolve?(account: string): Promise<string>;
+}
+export interface AccountTokenManagerOptions<S extends TimedSession> {
+    provider: ProviderId;
+    /** Human-readable provider name for error messages. */
+    displayName: string;
+    /** Provider hooks shared by every account (load/save/remove are bound per account). */
+    makeOptions: (account: string) => Omit<TokenManagerOptions<S>, 'load' | 'save' | 'remove' | 'onRemoved' | 'displayName'>;
+    /** Called after a permanent refresh failure deleted one account's session. */
+    onAccountRemoved?: (account: string) => void;
+    /** Store backend; defaults to the durable auth store. */
+    io?: AccountStoreIo<S>;
+}
+export declare class AccountTokenManager<S extends TimedSession> {
+    private readonly options;
+    private readonly managers;
+    private readonly io;
+    constructor(options: AccountTokenManagerOptions<S>);
+    /** The provider's accounts, default first (straight from the store). */
+    list(): Promise<AccountEntry<S>[]>;
+    /** The default account's key, or undefined when logged out. */
+    defaultAccount(): Promise<string | undefined>;
+    /**
+     * Resolve a usable session for one account (default when omitted),
+     * refreshing proactively or on demand.
+     * @param account - the account key; the default account when undefined.
+     * @param forceRefresh - refresh regardless of expiry (used after a 401).
+     * @returns the persisted session to send.
+     * @throws LlmError MISSING_CREDENTIAL when the account is not logged in.
+     */
+    session(account?: string, forceRefresh?: boolean): Promise<S>;
+    /** Resolve a legacy alias before it reaches any per-account manager or cache. */
+    resolveAccount(account: string): Promise<string>;
+    /** Read an account's stored session without any refresh side effect. */
+    peek(account?: string): Promise<S | undefined>;
+    /** Whether a session is stored for the account (cheap; never refreshes). */
+    hasSession(account?: string): Promise<boolean>;
+    /** The TokenManager bound to one account (created lazily, then cached). */
+    tokensFor(account: string): TokenManager<S>;
+    /** The logged-out error, mirroring TokenManager's own message. */
+    private missingCredential;
+}

package/lib/providers/accounts.js

@@ -0,0 +1,142 @@
+/**
+ * Multi-account token plumbing: one {@link AccountTokenManager} per provider
+ * owns a lazily-built {@link TokenManager} per account, so refresh coalescing
+ * (`inflight`) and permanent-failure removal stay scoped to ONE account —
+ * a revoked account deletes itself without touching its siblings.
+ *
+ * {@link AccountAwareAdapter} is the internal interface the pool uses to
+ * stream through a specific account. A catalog model listed by several
+ * accounts failovers; one listed by a single account is pinned to it.
+ */
+import { LlmAdapter, LlmError } from '@deepseek-ai/dsh-llm';
+import { TokenManager, withTimeout } from './common.js';
+import { deleteAccountSession, getAccountSession, listAccounts, saveAccountSession, resolveAccountKey, } from '../auth/store.js';
+export { DISCOVERY_TIMEOUT_MS } from './common.js';
+/** Catalog sort hint when the provider advertised one (Codex `priority`). */
+function catalogPriority(model) {
+    const ranked = model;
+    return typeof ranked.priority === 'number' ? ranked.priority : Number.MAX_SAFE_INTEGER;
+}
+/**
+ * Merge per-account catalogs, keeping the first occurrence of each model id.
+ * Rows that carry a numeric `priority` (Codex discovery) are then ordered by
+ * it so a model only the second account lists — e.g. `gpt-5.6-sol` — still
+ * sits with its generation instead of being appended after the default
+ * account's older ids.
+ */
+export async function unionAccountCatalogs(accounts, listOne, options) {
+    const timeoutMs = options?.timeoutMs;
+    const caller = options?.signal;
+    const catalogs = await Promise.all(accounts.map(async (account) => {
+        try {
+            if (timeoutMs === undefined)
+                return await listOne(account, caller);
+            const models = await withTimeout(timeoutSignal => listOne(account, caller === undefined ? timeoutSignal : AbortSignal.any([timeoutSignal, caller])), timeoutMs);
+            return models ?? [];
+        }
+        catch (error) {
+            // One expired or failing account must not hide models the others list.
+            if (caller?.aborted === true)
+                throw error;
+            return [];
+        }
+    }));
+    const seen = new Set();
+    const models = [];
+    for (const catalog of catalogs) {
+        for (const model of catalog) {
+            if (seen.has(model.id))
+                continue;
+            seen.add(model.id);
+            models.push(model);
+        }
+    }
+    models.sort((left, right) => catalogPriority(left) - catalogPriority(right));
+    return models;
+}
+export class AccountTokenManager {
+    options;
+    managers = new Map();
+    io;
+    constructor(options) {
+        this.options = options;
+        const provider = options.provider;
+        this.io = options.io ?? {
+            list: () => listAccounts(provider),
+            get: account => getAccountSession(provider, account),
+            save: (account, session) => saveAccountSession(provider, account, session),
+            remove: account => deleteAccountSession(provider, account),
+            resolve: account => resolveAccountKey(provider, account),
+        };
+    }
+    /** The provider's accounts, default first (straight from the store). */
+    list() {
+        return this.io.list();
+    }
+    /** The default account's key, or undefined when logged out. */
+    async defaultAccount() {
+        return (await this.list())[0]?.key;
+    }
+    /**
+     * Resolve a usable session for one account (default when omitted),
+     * refreshing proactively or on demand.
+     * @param account - the account key; the default account when undefined.
+     * @param forceRefresh - refresh regardless of expiry (used after a 401).
+     * @returns the persisted session to send.
+     * @throws LlmError MISSING_CREDENTIAL when the account is not logged in.
+     */
+    async session(account, forceRefresh = false) {
+        const requested = account ?? await this.defaultAccount();
+        if (requested === undefined)
+            throw this.missingCredential();
+        const key = await this.resolveAccount(requested);
+        return this.tokensFor(key).session(forceRefresh);
+    }
+    /** Resolve a legacy alias before it reaches any per-account manager or cache. */
+    resolveAccount(account) {
+        return this.io.resolve?.(account) ?? Promise.resolve(account);
+    }
+    /** Read an account's stored session without any refresh side effect. */
+    async peek(account) {
+        return this.io.get(account === undefined ? undefined : await this.resolveAccount(account));
+    }
+    /** Whether a session is stored for the account (cheap; never refreshes). */
+    async hasSession(account) {
+        return (await this.peek(account)) !== undefined;
+    }
+    /** The TokenManager bound to one account (created lazily, then cached). */
+    tokensFor(account) {
+        let manager = this.managers.get(account);
+        if (manager === undefined) {
+            const io = this.io;
+            let boundAccount = account;
+            manager = new TokenManager({
+                displayName: this.options.displayName,
+                ...this.options.makeOptions(account),
+                load: () => io.get(boundAccount),
+                save: async (session) => {
+                    await io.save(boundAccount, session);
+                    const canonical = await this.resolveAccount(boundAccount);
+                    if (canonical !== boundAccount) {
+                        // Move the binding as well as the cache entry: logout can delete
+                        // aliases, so callbacks must not keep relying on the old key.
+                        // Retain the manager itself to preserve its in-flight refresh.
+                        this.managers.set(canonical, manager);
+                        if (this.managers.get(boundAccount) === manager)
+                            this.managers.delete(boundAccount);
+                        boundAccount = canonical;
+                    }
+                },
+                remove: () => io.remove(boundAccount),
+                onRemoved: () => { this.options.onAccountRemoved?.(boundAccount); },
+            });
+            this.managers.set(account, manager);
+        }
+        return manager;
+    }
+    /** The logged-out error, mirroring TokenManager's own message. */
+    missingCredential() {
+        return new LlmError(`dsh-plugin-subscription-usage: not logged in to ${this.options.displayName}; `
+            + 'log in via Settings → Subscriptions in the dsh web app', 'MISSING_CREDENTIAL');
+    }
+}

package/lib/providers/antigravity-oauth-client.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Public Antigravity desktop OAuth client identity, also distributed by pi-antigravity.
+ * These application constants are distinct from user access/refresh tokens.
+ * Source: https://github.com/Rahularya01/pi-antigravity/blob/697858cafcf1faddf2ae898d2f053b2ff26c05e6/src/auth/oauth.ts
+ */
+export declare const ANTIGRAVITY_DEFAULT_CLIENT_ID = "1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com";
+export declare const ANTIGRAVITY_DEFAULT_CLIENT_SECRET = "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";

package/lib/providers/antigravity-oauth-client.js

@@ -0,0 +1,7 @@
+/**
+ * Public Antigravity desktop OAuth client identity, also distributed by pi-antigravity.
+ * These application constants are distinct from user access/refresh tokens.
+ * Source: https://github.com/Rahularya01/pi-antigravity/blob/697858cafcf1faddf2ae898d2f053b2ff26c05e6/src/auth/oauth.ts
+ */
+export const ANTIGRAVITY_DEFAULT_CLIENT_ID = "1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com";
+export const ANTIGRAVITY_DEFAULT_CLIENT_SECRET = "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";

package/lib/providers/antigravity.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Google Antigravity subscription provider. This is intentionally separate
+ * from Gemini CLI: it uses Antigravity OAuth scopes, project discovery, and
+ * the daily-cloudcode-pa v1internal request envelope.
+ */
+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 { FlowSpec } from '../auth/oauth-flow.js';
+import type { AntigravitySession } from '../auth/store.js';
+import type { AntigravityRequest } from '../translate/antigravity.js';
+import type { CatalogPersistence, DiscoveredModel, FetchFn, ModelEntry, ProviderUsage } from './common.js';
+import { AccountTokenManager } from './accounts.js';
+import type { PoolAdapter } from './pool.js';
+import type { RateLimitWait } from './rate-limit.js';
+export declare const ANTIGRAVITY_AUTHORIZE_URL = "https://accounts.google.com/o/oauth2/v2/auth";
+export declare const ANTIGRAVITY_TOKEN_URL = "https://oauth2.googleapis.com/token";
+export declare const ANTIGRAVITY_USERINFO_URL = "https://www.googleapis.com/oauth2/v2/userinfo";
+export declare const ANTIGRAVITY_DEFAULT_BASE_URL = "https://daily-cloudcode-pa.googleapis.com";
+export declare const ANTIGRAVITY_PROD_BASE_URL = "https://cloudcode-pa.googleapis.com";
+export declare const ANTIGRAVITY_DEFAULT_USER_AGENT = "antigravity/1.104.0 dsh-plugin-subscription-usage";
+export declare const ANTIGRAVITY_PREEMPT_MS: number;
+/** Antigravity, not Gemini CLI, OAuth scopes from the local reference clients. */
+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"];
+/** OAuth client configuration; explicit clients override the bundled desktop identity. */
+export interface AntigravityOAuthConfig {
+    clientId: string;
+    clientSecret?: string;
+}
+/** Runtime endpoint configuration. */
+export interface AntigravityRuntimeConfig {
+    /** Pin one origin; omitted uses daily with production fallback on endpoint failures. */
+    baseURL?: string;
+    userAgent?: string;
+    /** Activate an eligible account when loadCodeAssist has no project yet. */
+    onboard?: boolean;
+}
+/** Resolve a client pair: plugin config, environment, then the public desktop default. */
+export declare function resolveAntigravityOAuthConfig(config?: Partial<AntigravityOAuthConfig>): AntigravityOAuthConfig;
+/** Normalize the configured API origin and reject paths/credentials. */
+export declare function antigravityBaseURL(value?: string): string;
+/** Google authorization-code + PKCE flow for Antigravity. */
+export declare function antigravityFlow(oauth: AntigravityOAuthConfig): FlowSpec;
+interface AntigravityAccountInfo {
+    projectId: string;
+    account?: string;
+    plan?: string;
+}
+/** Shared Antigravity API headers. */
+export declare function antigravityHeaders(accessToken: string, userAgent?: string): Record<string, string>;
+/** Read (and, when enabled, initialize) the Antigravity project/account. */
+export declare function discoverAntigravityAccount(accessToken: string, runtime?: AntigravityRuntimeConfig, fetchFn?: FetchFn): Promise<AntigravityAccountInfo>;
+/** Exchange a Google OAuth authorization code and discover the Antigravity project. */
+export declare function exchangeAntigravityCode(code: string, verifier: string, redirectUri: string, oauth: AntigravityOAuthConfig, runtime?: AntigravityRuntimeConfig, fetchFn?: FetchFn): Promise<AntigravitySession>;
+/** Refresh a stored Antigravity Google token, preserving project/account metadata. */
+export declare function refreshAntigravity(session: AntigravitySession, oauth: AntigravityOAuthConfig, fetchFn?: FetchFn): Promise<AntigravitySession>;
+/** Refresh failures that require a fresh Google consent grant. */
+export declare function isAntigravityPermanentRefreshError(error: unknown): boolean;
+/** Fetch the authenticated account's live Antigravity model catalog. */
+export declare function fetchAntigravityModels(session: AntigravitySession, runtime?: AntigravityRuntimeConfig, fetchFn?: FetchFn, signal?: AbortSignal): Promise<DiscoveredModel[]>;
+/** Fetch plan and per-model quota windows when the upstream exposes them. */
+export declare function fetchAntigravityUsage(session: AntigravitySession, runtime?: AntigravityRuntimeConfig, fetchFn?: FetchFn, signal?: AbortSignal): Promise<ProviderUsage>;
+/** URL for either v1internal generation transport. */
+export declare function antigravityGenerateURL(baseURL: string | undefined, stream: boolean): string;
+/** Forward one already-built payload to generateContent or streamGenerateContent. */
+export declare function requestAntigravityContent(session: AntigravitySession, payload: AntigravityRequest, stream: boolean, runtime?: AntigravityRuntimeConfig, fetchFn?: FetchFn, signal?: AbortSignal): Promise<Response>;
+export interface AntigravityAdapterOptions {
+    /**
+     * Observes every upstream reply before its status is checked, with the
+     * resolved account key. Usage headers ride both 2xx and 429 replies.
+     */
+    onResponse?: (response: Response, account: string, sessionId: string | undefined) => void;
+    models: readonly ModelEntry[];
+    streamIdleTimeoutMs: number;
+    tokens: AccountTokenManager<AntigravitySession>;
+    pool?: () => PoolAdapter | undefined;
+    rateLimit?: RateLimitWait;
+    discovery: boolean;
+    runtime?: AntigravityRuntimeConfig;
+    onWarn?: (message: string) => void;
+    fetchFn?: FetchFn;
+    resolveAttachments?: () => AttachmentStore | undefined;
+    catalogStore?: CatalogPersistence;
+    onCatalogChanged?: () => void;
+    accountCatalogStore?: (account: string) => CatalogPersistence;
+    defaultEffortOf?: (model: string) => string | undefined;
+}
+/** DSH provider adapter for the `antigravity` route. */
+export declare class AntigravityAdapter extends LlmAdapter {
+    private readonly options;
+    private readonly catalog;
+    private readonly accountCatalogs;
+    private accountCatalogsInvalidated;
+    private readonly invalidatedAccounts;
+    private catalogOwner;
+    constructor(options: AntigravityAdapterOptions);
+    providerInfo(provider: string): LlmProviderInfo;
+    /** Drop cached catalogs after login/logout so the next list does not reuse a stale plan. */
+    clearAccountCatalog(account?: string): void;
+    /** Default and secondary accounts each seed their own persisted catalog. */
+    private catalogFor;
+    providerRetryPolicy(provider: string): import("@deepseek-ai/dsh-llm").ResolvedRetryPolicy;
+    private staticModels;
+    private fetchCatalog;
+    listModels(provider: string): Promise<readonly LlmModelInfo[]>;
+    /** The provider's own catalog: union of every account, or one account when named. */
+    listOwnModels(provider: string, account?: string, signal?: AbortSignal, preferCached?: boolean): Promise<readonly LlmModelInfo[]>;
+    private discovered;
+    resolveModel(provider: string, model: string): Promise<LlmResolvedModelInfo>;
+    /** Capability resolution of the provider's own models (the pool resolves members here). */
+    resolveOwnModel(provider: string, model: string, account?: string): Promise<LlmResolvedModelInfo>;
+    stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
+    /** Pool seam: stream through one specific account instead of the default. */
+    streamAccount(options: GenerateOptions, account: string): AsyncIterable<StreamChunk>;
+    private streamCore;
+    /** Non-stream forwarding seam used by tests and future DSH complete calls. */
+    generate(options: GenerateOptions): Promise<StreamChunk[]>;
+}
+export {};