dsh-plugin-subscriptions 0.5.2 → 0.6.0

package/lib/model-defaults.d.ts

@@ -0,0 +1,23 @@
+import { type ProviderId } from './auth/store.js';
+/** One model id → its configured default reasoning effort id. */
+export type ModelDefaultMap = Readonly<Record<string, string>>;
+/** Provider route → model defaults. */
+export type ModelDefaults = Readonly<Partial<Record<ProviderId, ModelDefaultMap>>>;
+/** Absolute path of the defaults file. */
+export declare function modelDefaultsFilePath(): string;
+/**
+ * The last load failure, or a warning about entries that were skipped while
+ * loading; consumers only use it for diagnostics.
+ */
+export declare function modelDefaultsLoadError(): unknown;
+/** A detached snapshot for the RPC surface (render + diffing). */
+export declare function modelDefaultsSnapshot(): ModelDefaults;
+/**
+ * Set or clear one model's configured default effort, then persist. The
+ * memory snapshot updates only after the atomic write succeeds, so a failed
+ * write never leaves the live state ahead of the file.
+ * @param provider - the subscription provider route.
+ * @param model - the wire model id.
+ * @param effort - the effort id, or undefined to clear the override.
+ */
+export declare function setDefaultEffort(provider: ProviderId, model: string, effort: string | undefined): Promise<void>;

package/lib/model-defaults.js

@@ -0,0 +1,237 @@
+/**
+ * Per-model default reasoning effort overrides — the durable half of the
+ * Settings page's per-model "default effort" pickers.
+ *
+ * The file lives at `~/.dsh/plugins/subscriptions/model-defaults.json`
+ * (mode 0600, atomic replace). Shape: `{ "<provider>": { "<model id>": "<effort>" } }`.
+ * An absent entry means "follow the provider's own default": the `Default`
+ * chip the model picker shows when the discovered catalog advertises no
+ * default at all.
+ *
+ * Writes are single-process and atomic, but *not* as serialised as the rest
+ * of the page: the Settings page disables only the row being saved, so two
+ * rows saved back to back can overlap. The write chain below serialises them,
+ * so no update is lost to a read-modify-write race. Every read comes from the
+ * in-memory snapshot, so the on-disk file only needs to survive a restart: a
+ * malformed file reads as empty and is rewritten on the next save, never
+ * taking the plugin down with it.
+ */
+import { chmod, mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { dshHomePath } from '@deepseek-ai/dsh-home-paths';
+import { PROVIDER_IDS } from './auth/store.js';
+/** Absolute path of the defaults file. */
+export function modelDefaultsFilePath() {
+    return dshHomePath('plugins', 'subscriptions', 'model-defaults.json');
+}
+const EMPTY = Object.freeze({});
+/** In-memory snapshot read by every consumer (adapters, RPC). */
+let current = EMPTY;
+/** One lazy load of the on-disk file (read once per process). */
+let ready;
+/** Last load failure, surfaced to callers that care; defaults stay empty. */
+let loadError;
+/**
+ * Serialises every write: the read-modify-write sequence must not interleave,
+ * or a fast second save would compute its snapshot from the stale `current`
+ * and silently drop the first update (the UI disables only the row being
+ * saved, so overlaps are reachable).
+ */
+let writeChain = Promise.resolve();
+/**
+ * Validate one persisted provider section: a string→string map, or undefined.
+ * Malformed *entries* are skipped, not the whole section: one bad value (a
+ * hand edit losing its quotes) must not silently un-configure every model in
+ * that provider. What was dropped is reported so the caller can surface it
+ * instead of the loss disappearing.
+ */
+function sanitizeProvider(value, dropped) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return undefined;
+    const entries = {};
+    for (const [model, effort] of Object.entries(value)) {
+        if (typeof effort !== 'string' || effort.length === 0) {
+            dropped.push(model);
+            continue;
+        }
+        entries[model] = effort;
+    }
+    if (Object.keys(entries).length === 0)
+        return undefined;
+    return Object.freeze(entries);
+}
+/** Validate the raw document: only known providers, malformed sections dropped. */
+function sanitizeDefaults(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return { defaults: EMPTY, dropped: [] };
+    const record = value;
+    const result = {};
+    const dropped = [];
+    for (const provider of PROVIDER_IDS) {
+        const section = sanitizeProvider(record[provider], dropped);
+        if (section !== undefined)
+            result[provider] = section;
+    }
+    return { defaults: Object.freeze(result), dropped };
+}
+/** Read and validate the on-disk file; a missing file reads as empty. */
+async function loadFile(path) {
+    let text;
+    try {
+        text = await readFile(path, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return EMPTY;
+        throw error;
+    }
+    try {
+        const { defaults, dropped } = sanitizeDefaults(JSON.parse(text));
+        if (dropped.length > 0)
+            loadError = new Error(`subscriptions model defaults: ${dropped.length} malformed entr${dropped.length === 1 ? 'y' : 'ies'} skipped (${dropped.join(', ')}); fix or delete the file`);
+        return defaults;
+    }
+    catch {
+        throw new Error(`subscriptions model defaults at ${path} are not valid JSON; fix or delete the file`);
+    }
+}
+/** Resolve the module state once from disk; failures leave the defaults empty. */
+async function ensureReady() {
+    ready ??= loadFile(modelDefaultsFilePath()).then((loaded) => {
+        current = loaded;
+        // loadFile itself sets loadError for skipped entries; do not clobber it.
+    }, (error) => {
+        loadError = error;
+        current = EMPTY;
+    });
+    return ready;
+}
+/** Persist a snapshot atomically with owner-only permissions. */
+async function atomicPersist(defaults, path) {
+    await mkdir(dirname(path), { recursive: true });
+    const tmp = `${path}.tmp-${process.pid}-${Math.random().toString(36).slice(2)}`;
+    try {
+        await writeFile(tmp, JSON.stringify(defaults, null, 2), { mode: 0o600 });
+        await chmod(tmp, 0o600);
+        await rename(tmp, path);
+    }
+    catch (error) {
+        await rm(tmp, { force: true });
+        throw error;
+    }
+}
+let persistDefaults = atomicPersist;
+/**
+ * Clone one provider section, or undefined when nothing is configured for it.
+ * The clone is prototype-less: model ids are provider-supplied catalog data
+ * used as object keys, and consumers index the section directly (the RPC
+ * catalog in index.ts does), so an id like `toString` would otherwise yield an
+ * inherited *function* where a string is declared.
+ */
+function sectionOf(defaults, provider) {
+    const section = defaults[provider];
+    if (section === undefined)
+        return undefined;
+    return Object.assign(Object.create(null), section);
+}
+/**
+ * Ready the defaults store.
+ * @internal Exported for tests; index.ts calls it at apply time so every
+ * later synchronous read sees the persisted state.
+ */
+export async function loadModelDefaults() {
+    await ensureReady();
+}
+/**
+ * The last load failure, or a warning about entries that were skipped while
+ * loading; consumers only use it for diagnostics.
+ */
+export function modelDefaultsLoadError() {
+    return loadError;
+}
+/**
+ * The configured default effort for one model, or undefined when none (the
+ * picker then follows the provider's own default).
+ * @internal Exported for the adapters' `defaultEffortOf` options.
+ */
+export function defaultEffortOf(provider, model) {
+    const section = current[provider];
+    if (section === undefined)
+        return undefined;
+    // Own-property lookup: a model id is provider-supplied catalog data, and a
+    // plain index would inherit from Object.prototype for names like
+    // `toString`, handing a *function* to mergeReasoning (which then throws and
+    // breaks that model's resolution).
+    return Object.prototype.hasOwnProperty.call(section, model) ? section[model] : undefined;
+}
+/** A detached snapshot for the RPC surface (render + diffing). */
+export function modelDefaultsSnapshot() {
+    const result = {};
+    for (const provider of PROVIDER_IDS) {
+        const section = sectionOf(current, provider);
+        if (section !== undefined)
+            result[provider] = section;
+    }
+    return Object.freeze(result);
+}
+/**
+ * Set or clear one model's configured default effort, then persist. The
+ * memory snapshot updates only after the atomic write succeeds, so a failed
+ * write never leaves the live state ahead of the file.
+ * @param provider - the subscription provider route.
+ * @param model - the wire model id.
+ * @param effort - the effort id, or undefined to clear the override.
+ */
+export function setDefaultEffort(provider, model, effort) {
+    // Chained behind every earlier write: the snapshot `current` is read inside
+    // the chain, so two overlapping saves cannot lose either update. The caller
+    // receives the promise of its own write (a rejection propagates), not the
+    // shared chain.
+    const run = writeChain.then(async () => {
+        await ensureReady();
+        const section = { ...sectionOf(current, provider) ?? {} };
+        if (effort === undefined) {
+            delete section[model];
+        }
+        else {
+            section[model] = effort;
+        }
+        const next = { ...current };
+        if (Object.keys(section).length === 0) {
+            delete next[provider];
+        }
+        else {
+            next[provider] = Object.freeze(section);
+        }
+        const frozen = Object.freeze(next);
+        await persistDefaults(frozen, modelDefaultsFilePath());
+        current = frozen;
+    });
+    // Keep the chain alive even when one write fails, or every later save would
+    // be stuck behind the rejected promise. The caller has already received the
+    // rejection through `run`.
+    writeChain = run.catch(() => undefined);
+    return run;
+}
+/**
+ * Drop the in-memory state and the cached load. Test-only: lets a suite
+ * unwind the lazy singleton before the next `loadModelDefaults`.
+ * @internal Exported for tests only; not part of the plugin's public surface.
+ */
+export async function resetModelDefaultsForTests() {
+    current = EMPTY;
+    ready = undefined;
+    loadError = undefined;
+    writeChain = Promise.resolve();
+    persistDefaults = atomicPersist;
+}
+/**
+ * Test-only seam: replace the atomic persistence so a failure happens on the
+ * real write path. Proves a failed write propagates to the caller and does
+ * not wedge the write chain (resetModelDefaultsForTests restores the real
+ * implementation).
+ * @internal Exported for tests only.
+ */
+export function overridePersistForTests(persist) {
+    persistDefaults = persist;
+}

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/claude.d.ts

@@ -7,10 +7,12 @@ import { LlmAdapter } from '@deepseek-ai/dsh-llm';
 import type { GenerateOptions, LlmModelInfo, LlmProviderInfo, LlmResolvedModelInfo, StreamChunk } from '@deepseek-ai/dsh-llm';
 import type { FlowSpec } from '../auth/oauth-flow.js';
 import type { ClaudeSession } from '../auth/store.js';
+import type { PoolAdapter } from './pool.js';
 import type { AttachmentStore } from '@deepseek-ai/dsh-attachment';
 import type { TranslatableMessage } from '../translate/resolved.js';
-import { TokenManager } from './common.js';
+import { AccountTokenManager } from './accounts.js';
 import type { CatalogPersistence, DiscoveredModel, FetchFn, ModelEntry, ProviderUsage } from './common.js';
+import type { RateLimitResetReader, RateLimitWait } from './rate-limit.js';
 export declare const CLAUDE_CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
 export declare const CLAUDE_AUTHORIZE_URL = "https://claude.ai/oauth/authorize";
 export declare const CLAUDE_TOKEN_URL = "https://claude.ai/v1/oauth/token";
@@ -21,6 +23,20 @@ export declare const CLAUDE_SCOPE = "org:create_api_key user:profile user:infere
 export declare const CLAUDE_CALLBACK_PATH = "/callback";
 /** Refresh when the access token has less than this much life left. */
 export declare const CLAUDE_PREEMPT_MS: number;
+/**
+ * Reads the reset instant of the Anthropic window that rejected a request.
+ *
+ * `anthropic-ratelimit-unified-*` is the subscription-plan family — the one
+ * Claude Code renders as "resets 3pm" — and is the only header that names the
+ * window which actually rejected this request. The per-bucket
+ * `anthropic-ratelimit-{requests,tokens,input-tokens,output-tokens}-reset`
+ * headers are deliberately not read: they are rollover snapshots attached to
+ * every response, so on a 429 they cannot say which bucket refused, and the
+ * earliest of them is typically the bucket that still had room — a wait that
+ * lands straight back in the closed window. They reach the operator through
+ * `rateLimitDiagnostics` instead.
+ */
+export declare const claudeRateLimitReset: RateLimitResetReader;
 /**
  * The subscription endpoint only serves requests presenting as Claude Code,
  * so these headers impersonate the CLI; the harness attribution user-agent
@@ -64,23 +80,31 @@ export declare const CLAUDE_USAGE_URL = "https://api.anthropic.com/api/oauth/usa
  * @returns the mapped usage snapshot.
  */
 export declare function fetchClaudeUsage(session: ClaudeSession, fetchFn?: FetchFn, signal?: AbortSignal): Promise<ProviderUsage>;
-/** Fetch the live model catalog from the subscription endpoint. */
-export declare function fetchClaudeModels(session: ClaudeSession, fetchFn?: FetchFn): Promise<DiscoveredModel[]>;
+/** Fetch the live model catalog from the subscription endpoint. `signal` cancels the request. */
+export declare function fetchClaudeModels(session: ClaudeSession, fetchFn?: FetchFn, signal?: AbortSignal): Promise<DiscoveredModel[]>;
 /** Constructor dependencies for {@link ClaudeAdapter}. */
 export interface ClaudeAdapterOptions {
     models: readonly ModelEntry[];
     streamIdleTimeoutMs: number;
-    tokens: TokenManager<ClaudeSession>;
+    tokens: AccountTokenManager<ClaudeSession>;
+    /** Late-bound pool facade (wired after adapter construction); pools list under their first member's provider. */
+    pool?: () => PoolAdapter | undefined;
     /** Whether to fetch the live catalog when logged in (false when config `models` overrides). */
     discovery: boolean;
     fetchFn?: FetchFn;
     onWarn?: (message: string) => void;
-    /** Max retries on a retryable failure before giving up; matches Claude Code's own client-side retry count. Defaults to the dsh-llm default (2) when unset. */
-    maxRetries?: number;
+    /** How long this route may hold a turn open waiting for a rate-limit window; defaults to waiting on, six-hour ceiling. */
+    rateLimit?: RateLimitWait;
     /** Resolve the attachment service per request; absent means image requests fail loudly. */
     resolveAttachments?: () => AttachmentStore | undefined;
     /** Durable catalog store seeding capability metadata across restarts. */
     catalogStore?: CatalogPersistence;
+    /**
+     * Per-model default reasoning effort override (the Settings page's picker).
+     * Returns the user-configured default for one model, or undefined to follow
+     * the provider's own default.
+     */
+    defaultEffortOf?: (model: string) => string | undefined;
 }
 /**
  * Assemble the Anthropic request body.
@@ -102,15 +126,30 @@ export declare function claudeRequestBody(options: GenerateOptions, messages: re
 export declare class ClaudeAdapter extends LlmAdapter {
     private readonly options;
     private readonly catalog;
+    /** In-memory catalogs for non-default accounts (the persisted cache is the default's). */
+    private readonly accountCatalogs;
+    /** Account whose snapshot currently lives in {@link catalog}; cleared on default change. */
+    private catalogOwner;
     constructor(options: ClaudeAdapterOptions);
     private fetchCatalog;
+    /** Drop cached catalogs after login/logout so the next list does not reuse a stale plan. */
+    clearAccountCatalog(account?: string): void;
+    /** Persisted cache for the default account; a throwaway cache for any other. */
+    private catalogFor;
     private discovered;
     private staticModels;
     providerInfo(provider: string): LlmProviderInfo;
-    providerRetryPolicy(provider: string): import("@deepseek-ai/dsh-llm").ResolvedRetryPolicy | undefined;
+    providerRetryPolicy(provider: string): import("@deepseek-ai/dsh-llm").ResolvedRetryPolicy;
     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): Promise<readonly LlmModelInfo[]>;
     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): 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;
     /**
      * `display: 'summarized'` is set explicitly on both shapes: `adaptive`-type
      * models default to `display: 'omitted'`, which returns thinking blocks with