dsh-subscriptions 0.1.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/provider-settings.d.ts

@@ -0,0 +1,39 @@
+import { type ProviderId } from './auth/store.js';
+export declare const PROVIDER_TOOLS: {
+    readonly codex: readonly ["image_generate", "web_search"];
+    readonly claude: readonly [];
+    readonly grok: readonly ["image_generate", "video_generate", "x_search"];
+    readonly copilot: readonly [];
+    readonly antigravity: readonly [];
+};
+export type SubscriptionTool = 'image_generate' | 'video_generate' | 'x_search' | 'web_search';
+export interface AccountPreferences {
+    alias?: string;
+    /** Absent means included. */
+    poolEnabled?: boolean;
+    /** Absent means no separate picker entries. */
+    independentEntry?: boolean;
+    /** Absent allows every model; [] allows none. */
+    poolModels?: string[];
+}
+export interface ProviderPreferences {
+    accounts?: Record<string, AccountPreferences>;
+    /** Absent follows discovery; an explicit selection hides newly discovered models. */
+    visibleModels?: string[];
+    contextWindows?: Record<string, number>;
+    tools?: Partial<Record<SubscriptionTool, boolean>>;
+}
+export declare function validatePreferences(provider: ProviderId, input: unknown): ProviderPreferences;
+/** Durable user preferences, independent of expiring discovery caches. */
+export declare class ProviderSettingsStore {
+    private current;
+    private writes;
+    readonly path: string;
+    constructor(path?: string);
+    get(provider: ProviderId): ProviderPreferences;
+    visible(provider: ProviderId, model: string): boolean;
+    contextWindow(model: string): number | undefined;
+    /** Creation-time policy survives restarts and never changes an existing session. */
+    toolEnabled(provider: ProviderId, tool: SubscriptionTool, createdAt?: number): boolean;
+    set(provider: ProviderId, input: unknown): Promise<void>;
+}

package/lib/provider-settings.js

@@ -0,0 +1,151 @@
+import { readFileSync } from 'node:fs';
+import { mkdir, 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';
+export const PROVIDER_TOOLS = {
+    codex: ['image_generate', 'web_search'],
+    claude: [],
+    grok: ['image_generate', 'video_generate', 'x_search'],
+    copilot: [],
+    antigravity: [],
+};
+export function validatePreferences(provider, input) {
+    if (!input || typeof input !== 'object' || Array.isArray(input))
+        throw new Error('settings must be an object');
+    const raw = input;
+    const result = {};
+    if (raw.accounts !== undefined) {
+        if (!raw.accounts || typeof raw.accounts !== 'object' || Array.isArray(raw.accounts))
+            throw new Error('accounts must be an account-to-preferences map');
+        result.accounts = Object.create(null);
+        for (const [key, value] of Object.entries(raw.accounts)) {
+            if (!key.trim() || !value || typeof value !== 'object' || Array.isArray(value))
+                throw new Error('invalid account preferences');
+            const account = value;
+            const parsed = {};
+            if (account.alias !== undefined) {
+                if (typeof account.alias !== 'string')
+                    throw new Error('account alias must be a string');
+                parsed.alias = account.alias.trim();
+            }
+            for (const field of ['poolEnabled', 'independentEntry']) {
+                if (account[field] !== undefined) {
+                    if (typeof account[field] !== 'boolean')
+                        throw new Error(`${field} must be a boolean`);
+                    parsed[field] = account[field];
+                }
+            }
+            if (account.poolModels !== undefined) {
+                if (!Array.isArray(account.poolModels) || account.poolModels.some(id => typeof id !== 'string' || !id.trim()))
+                    throw new Error('poolModels must be an array of model ids');
+                parsed.poolModels = [...new Set(account.poolModels)];
+            }
+            result.accounts[key] = parsed;
+        }
+    }
+    if (raw.visibleModels !== undefined) {
+        if (!Array.isArray(raw.visibleModels) || raw.visibleModels.some(id => typeof id !== 'string' || !id.trim())) {
+            throw new Error('visibleModels must be an array of model ids');
+        }
+        result.visibleModels = [...new Set(raw.visibleModels)];
+    }
+    if (raw.contextWindows !== undefined) {
+        if (provider !== 'codex')
+            throw new Error('context window overrides are currently supported only for Codex');
+        if (!raw.contextWindows || typeof raw.contextWindows !== 'object' || Array.isArray(raw.contextWindows)) {
+            throw new Error('contextWindows must be a model-to-token map');
+        }
+        result.contextWindows = Object.create(null);
+        for (const [model, value] of Object.entries(raw.contextWindows)) {
+            if (!model.trim() || typeof value !== 'number' || !Number.isSafeInteger(value) || value <= 0) {
+                throw new Error('context windows must be positive safe integers');
+            }
+            result.contextWindows[model] = value;
+        }
+    }
+    if (raw.tools !== undefined) {
+        if (!raw.tools || typeof raw.tools !== 'object' || Array.isArray(raw.tools))
+            throw new Error('tools must be an object');
+        result.tools = {};
+        for (const [tool, enabled] of Object.entries(raw.tools)) {
+            if (!PROVIDER_TOOLS[provider].includes(tool) || typeof enabled !== 'boolean') {
+                throw new Error(`unsupported tool setting: ${provider}/${tool}`);
+            }
+            result.tools[tool] = enabled;
+        }
+    }
+    return result;
+}
+/** Durable user preferences, independent of expiring discovery caches. */
+export class ProviderSettingsStore {
+    current = { providers: {}, toolHistory: [] };
+    writes = Promise.resolve();
+    path;
+    constructor(path = dshHomePath('plugins', 'subscriptions', 'provider-settings.json')) {
+        this.path = path;
+        try {
+            const raw = JSON.parse(readFileSync(path, 'utf8'));
+            if (!raw.providers || !Array.isArray(raw.toolHistory))
+                throw new Error('invalid settings document');
+            for (const provider of PROVIDER_IDS) {
+                if (Object.hasOwn(raw.providers, provider))
+                    this.current.providers[provider] = validatePreferences(provider, raw.providers[provider]);
+            }
+            this.current.toolHistory = raw.toolHistory.map(revision => {
+                if (!PROVIDER_IDS.includes(revision.provider) || !Number.isSafeInteger(revision.at) || revision.at < 0)
+                    throw new Error('invalid tool history');
+                const tools = validatePreferences(revision.provider, { tools: revision.tools }).tools ?? {};
+                return { at: revision.at, provider: revision.provider, tools };
+            }).sort((a, b) => a.at - b.at);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw new Error(`Cannot read provider settings at ${path}`, { cause: error });
+        }
+    }
+    get(provider) {
+        return structuredClone(this.current.providers[provider] ?? {});
+    }
+    visible(provider, model) {
+        return this.current.providers[provider]?.visibleModels?.includes(model) ?? true;
+    }
+    contextWindow(model) {
+        const windows = this.current.providers.codex?.contextWindows;
+        return windows && Object.hasOwn(windows, model) ? windows[model] : undefined;
+    }
+    /** Creation-time policy survives restarts and never changes an existing session. */
+    toolEnabled(provider, tool, createdAt = Date.now()) {
+        let enabled = true;
+        for (const revision of this.current.toolHistory) {
+            if (revision.at > createdAt)
+                break;
+            if (revision.provider === provider)
+                enabled = revision.tools[tool] !== false;
+        }
+        return enabled;
+    }
+    set(provider, input) {
+        const preferences = validatePreferences(provider, input);
+        const run = this.writes.then(async () => {
+            const next = structuredClone(this.current);
+            const before = next.providers[provider]?.tools ?? {};
+            next.providers[provider] = preferences;
+            if (PROVIDER_TOOLS[provider].some(tool => (before[tool] !== false) !== (preferences.tools?.[tool] !== false))) {
+                next.toolHistory.push({ at: Date.now(), provider, tools: preferences.tools ?? {} });
+            }
+            await mkdir(dirname(this.path), { recursive: true });
+            const temporary = `${this.path}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+            try {
+                await writeFile(temporary, JSON.stringify(next, null, 2), { mode: 0o600 });
+                await rename(temporary, this.path);
+            }
+            finally {
+                await rm(temporary, { force: true });
+            }
+            this.current = next;
+        });
+        this.writes = run.catch(() => undefined);
+        return run;
+    }
+}

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

@@ -0,0 +1,41 @@
+import { LlmAdapter } from '@deepseek-ai/dsh-llm';
+import type { GenerateOptions, LlmModelInfo, LlmResolvedModelInfo, 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);
+    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): Promise<LlmResolvedModelInfo>;
+    stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
+}
+export {};

package/lib/providers/account-preferences.js

@@ -0,0 +1,153 @@
+import { LlmAdapter, LlmError } from '@deepseek-ai/dsh-llm';
+import { DISCOVERY_TIMEOUT_MS, withTimeout } from './common.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;
+    }
+    preference(account) {
+        const accounts = this.options.settings.get(this.options.provider).accounts;
+        return accounts && Object.hasOwn(accounts, account) ? accounts[account] : undefined;
+    }
+    async models(account) {
+        const models = await withTimeout(signal => this.options.adapter.listOwnModels(this.options.provider, account, signal), this.options.discoveryTimeoutMs ?? DISCOVERY_TIMEOUT_MS);
+        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 this.options.adapter.lastKnownOwnModels?.(this.options.provider, account) ?? [];
+    }
+    async requireAccount(account, model, independent) {
+        if (!(await this.options.accounts()).some(entry => entry.key === account)
+            || (independent ? this.preference(account)?.independentEntry !== true : !accountAllowsPool(this.preference(account), model))
+            || !(await this.models(account)).some(entry => entry.id === model)) {
+            throw new LlmError(`Account route unavailable: ${this.options.provider}/${account}/${model}`, 'NO_ADAPTER');
+        }
+    }
+    async fallback(model) {
+        for (const { key } of await this.options.accounts()) {
+            if (!accountAllowsPool(this.preference(key), model))
+                continue;
+            try {
+                await this.requireAccount(key, model, false);
+                return key;
+            }
+            catch { /* unavailable catalog */ }
+        }
+        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) => {
+            if (model.startsWith(ACCOUNT_MODEL_PREFIX))
+                throw new LlmError('Independent entries cannot be pool members', 'NO_ADAPTER');
+            const key = account ?? (await this.options.accounts())[0]?.key;
+            if (!key)
+                throw new LlmError('No account available', 'NO_ADAPTER');
+            await this.requireAccount(key, model, false);
+            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);
+                        }
+                        catch (cause) {
+                            // 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} · ${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()].sort((left, right) => priority(left) - priority(right));
+    }
+    async resolveModel(provider, id) {
+        const independent = parseAccountModelId(id);
+        if (independent) {
+            await this.requireAccount(independent.account, independent.model, true);
+            const info = await this.options.adapter.resolveOwnModel(provider, independent.model, independent.account);
+            const label = (await this.options.accounts()).find(entry => entry.key === independent.account)?.label ?? independent.account;
+            return { ...info, id, name: `${this.preference(independent.account)?.alias || label} · ${info.name}` };
+        }
+        const pool = this.options.pool();
+        if (pool && await pool.owns(this.options.provider, id))
+            return pool.resolveModel(provider, id);
+        return this.options.adapter.resolveOwnModel(provider, id, await this.fallback(id));
+    }
+    async *stream(options) {
+        const independent = parseAccountModelId(options.model);
+        if (independent) {
+            await this.requireAccount(independent.account, independent.model, true);
+            yield* this.options.adapter.streamAccount({ ...options, model: independent.model }, independent.account);
+            return;
+        }
+        const pool = this.options.pool();
+        if (pool && await pool.owns(this.options.provider, options.model)) {
+            yield* pool.stream(options);
+            return;
+        }
+        yield* this.options.adapter.streamAccount(options, await this.fallback(options.model));
+    }
+}