dsh-plugin-subscriptions 0.5.1 → 0.5.3

package/lib/providers/accounts.d.ts

@@ -0,0 +1,102 @@
+/**
+ * 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.
+     */
+    listOwnModels(provider: string, account?: string, signal?: AbortSignal): Promise<readonly LlmModelInfo[]>;
+    /**
+     * 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.
+     */
+    resolveOwnModel(provider: string, model: 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>;
+}
+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>;
+    /** 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,123 @@
+/**
+ * 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, } 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),
+        };
+    }
+    /** 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 key = account ?? await this.defaultAccount();
+        if (key === undefined)
+            throw this.missingCredential();
+        return this.tokensFor(key).session(forceRefresh);
+    }
+    /** Read an account's stored session without any refresh side effect. */
+    peek(account) {
+        return this.io.get(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;
+            manager = new TokenManager({
+                displayName: this.options.displayName,
+                ...this.options.makeOptions(account),
+                load: () => io.get(account),
+                save: session => io.save(account, session),
+                remove: () => io.remove(account),
+                onRemoved: () => { this.options.onAccountRemoved?.(account); },
+            });
+            this.managers.set(account, manager);
+        }
+        return manager;
+    }
+    /** The logged-out error, mirroring TokenManager's own message. */
+    missingCredential() {
+        return new LlmError(`dsh-plugin-subscriptions: not logged in to ${this.options.displayName}; `
+            + 'log in via Settings → Subscriptions in the dsh web app', 'MISSING_CREDENTIAL');
+    }
+}

package/lib/providers/antigravity.d.ts

@@ -0,0 +1,90 @@
+/**
+ * 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 { TokenManager } from './common.js';
+import type { CatalogPersistence, DiscoveredModel, FetchFn, ModelEntry, ProviderUsage } from './common.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-subscriptions";
+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. Values must come from config/environment. */
+export interface AntigravityOAuthConfig {
+    clientId: string;
+    clientSecret?: string;
+}
+/** Runtime endpoint configuration. */
+export interface AntigravityRuntimeConfig {
+    baseURL?: string;
+    userAgent?: string;
+    /** Activate an eligible account when loadCodeAssist has no project yet. */
+    onboard?: boolean;
+}
+/** Resolve and validate a user-supplied OAuth config without embedded credentials. */
+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): 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 {
+    models: readonly ModelEntry[];
+    streamIdleTimeoutMs: number;
+    tokens: TokenManager<AntigravitySession>;
+    discovery: boolean;
+    runtime?: AntigravityRuntimeConfig;
+    onWarn?: (message: string) => void;
+    fetchFn?: FetchFn;
+    resolveAttachments?: () => AttachmentStore | undefined;
+    catalogStore?: CatalogPersistence;
+}
+/** DSH provider adapter for the `antigravity` route. */
+export declare class AntigravityAdapter extends LlmAdapter {
+    private readonly options;
+    private readonly catalog;
+    constructor(options: AntigravityAdapterOptions);
+    providerInfo(provider: string): LlmProviderInfo;
+    private staticModels;
+    private fetchCatalog;
+    listModels(provider: string): Promise<readonly LlmModelInfo[]>;
+    private discovered;
+    resolveModel(provider: string, model: string): Promise<LlmResolvedModelInfo>;
+    stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
+    /** Non-stream forwarding seam used by tests and future DSH complete calls. */
+    generate(options: GenerateOptions): Promise<StreamChunk[]>;
+}
+export {};