dsh-subscriptions 0.2.0 → 0.2.3

package/lib/provider-settings.d.ts

@@ -1,4 +1,5 @@
 import { type ProviderId } from './auth/store.js';
+import type { PromptCacheTtl } from './translate/anthropic.js';
 export declare const PROVIDER_TOOLS: {
     readonly codex: readonly ["image_generate", "web_search"];
     readonly claude: readonly [];
@@ -7,6 +8,7 @@ export declare const PROVIDER_TOOLS: {
     readonly antigravity: readonly [];
 };
 export type SubscriptionTool = 'image_generate' | 'video_generate' | 'x_search' | 'web_search';
+export type SubagentSpeedTier = 'standard' | 'fast';
 export interface AccountPreferences {
     alias?: string;
     /** Absent means included. */
@@ -21,7 +23,14 @@ export interface ProviderPreferences {
     /** Absent follows discovery; an explicit selection hides newly discovered models. */
     visibleModels?: string[];
     contextWindows?: Record<string, number>;
+    /** Codex only: per-model defaults for subagents, independent of main-session speed. */
+    subagentSpeeds?: Record<string, SubagentSpeedTier>;
     tools?: Partial<Record<SubscriptionTool, boolean>>;
+    /**
+     * Claude only: overrides the `claudePromptCacheTtl` plugin config for this
+     * route. Absent follows the configured TTL.
+     */
+    promptCacheTtl?: PromptCacheTtl;
 }
 export declare function validatePreferences(provider: ProviderId, input: unknown): ProviderPreferences;
 /** Durable user preferences, independent of expiring discovery caches. */
@@ -34,6 +43,14 @@ export declare class ProviderSettingsStore {
     visible(provider: ProviderId, model: string): boolean;
     /** The user's local context-window override for one model; absent follows the provider. */
     contextWindow(model: string, provider?: ProviderId): number | undefined;
+    /** Read on every request so saved changes apply to the next subagent request. */
+    subagentSpeed(model: string): SubagentSpeedTier;
+    /**
+     * The Claude route's prompt-cache TTL override, read live so a saved change
+     * takes effect from the next request without a restart. Absent means follow
+     * the `claudePromptCacheTtl` config.
+     */
+    promptCacheTtl(): PromptCacheTtl | 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

@@ -16,11 +16,16 @@ export function validatePreferences(provider, input) {
     const raw = input;
     const result = {};
     if (raw.accounts !== undefined) {
-        if (!raw.accounts || typeof raw.accounts !== 'object' || Array.isArray(raw.accounts))
+        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))
+            if (!key.trim() ||
+                !value ||
+                typeof value !== 'object' ||
+                Array.isArray(value))
                 throw new Error('invalid account preferences');
             const account = value;
             const parsed = {};
@@ -37,7 +42,8 @@ export function validatePreferences(provider, input) {
                 }
             }
             if (account.poolModels !== undefined) {
-                if (!Array.isArray(account.poolModels) || account.poolModels.some(id => typeof id !== 'string' || !id.trim()))
+                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)];
             }
@@ -45,7 +51,8 @@ export function validatePreferences(provider, input) {
         }
     }
     if (raw.visibleModels !== undefined) {
-        if (!Array.isArray(raw.visibleModels) || raw.visibleModels.some(id => typeof id !== 'string' || !id.trim())) {
+        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)];
@@ -54,23 +61,53 @@ export function validatePreferences(provider, input) {
         if (provider !== 'codex' && provider !== 'claude') {
             throw new Error('context window overrides are supported only for Codex and Claude');
         }
-        if (!raw.contextWindows || typeof raw.contextWindows !== 'object' || Array.isArray(raw.contextWindows)) {
+        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) {
+            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.promptCacheTtl !== undefined) {
+        if (provider !== 'claude')
+            throw new Error('the prompt-cache TTL override is supported only for Claude');
+        if (raw.promptCacheTtl !== '5m' && raw.promptCacheTtl !== '1h') {
+            throw new Error('promptCacheTtl must be "5m" or "1h"');
+        }
+        result.promptCacheTtl = raw.promptCacheTtl;
+    }
+    if (raw.subagentSpeeds !== undefined) {
+        if (provider !== 'codex')
+            throw new Error('subagent speeds are currently supported only for Codex');
+        if (!raw.subagentSpeeds ||
+            typeof raw.subagentSpeeds !== 'object' ||
+            Array.isArray(raw.subagentSpeeds)) {
+            throw new Error('subagent speeds must be a model-to-speed map');
+        }
+        result.subagentSpeeds = Object.create(null);
+        for (const [model, tier] of Object.entries(raw.subagentSpeeds)) {
+            if (!model.trim() || (tier !== 'standard' && tier !== 'fast')) {
+                throw new Error('subagent speeds require a model id and either "standard" or "fast"');
+            }
+            result.subagentSpeeds[model] = tier;
+        }
+    }
     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') {
+            if (!PROVIDER_TOOLS[provider].includes(tool) ||
+                typeof enabled !== 'boolean') {
                 throw new Error(`unsupported tool setting: ${provider}/${tool}`);
             }
             result.tools[tool] = enabled;
@@ -93,29 +130,49 @@ export class ProviderSettingsStore {
                 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)
+            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 ?? {};
+                const tools = validatePreferences(revision.provider, { tools: revision.tools })
+                    .tools ?? {};
                 return { at: revision.at, provider: revision.provider, tools };
-            }).sort((a, b) => a.at - b.at);
+            })
+                .sort((a, b) => a.at - b.at);
         }
         catch (error) {
             if (error.code !== 'ENOENT')
-                throw new Error(`Cannot read provider settings at ${path}`, { cause: error });
+                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;
+        return (this.current.providers[provider]?.visibleModels?.includes(model) ?? true);
     }
     /** The user's local context-window override for one model; absent follows the provider. */
     contextWindow(model, provider = 'codex') {
         const windows = this.current.providers[provider]?.contextWindows;
         return windows && Object.hasOwn(windows, model) ? windows[model] : undefined;
     }
+    /** Read on every request so saved changes apply to the next subagent request. */
+    subagentSpeed(model) {
+        const speeds = this.current.providers.codex?.subagentSpeeds;
+        return speeds && Object.hasOwn(speeds, model) ? speeds[model] : 'standard';
+    }
+    /**
+     * The Claude route's prompt-cache TTL override, read live so a saved change
+     * takes effect from the next request without a restart. Absent means follow
+     * the `claudePromptCacheTtl` config.
+     */
+    promptCacheTtl() {
+        return this.current.providers.claude?.promptCacheTtl;
+    }
     /** Creation-time policy survives restarts and never changes an existing session. */
     toolEnabled(provider, tool, createdAt = Date.now()) {
         let enabled = true;
@@ -133,13 +190,19 @@ export class ProviderSettingsStore {
             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 ?? {} });
+            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 writeFile(temporary, JSON.stringify(next, null, 2), {
+                    mode: 0o600,
+                });
                 await rename(temporary, this.path);
             }
             finally {

package/lib/providers/account-preferences.js

@@ -24,7 +24,8 @@ export function parseAccountModelId(id) {
     }
 }
 export function accountAllowsPool(preferences, model) {
-    return preferences?.poolEnabled !== false && (preferences?.poolModels?.includes(model) ?? true);
+    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 {
@@ -35,20 +36,24 @@ export class AccountPreferencesAdapter extends LlmAdapter {
     }
     preference(account) {
         const accounts = this.options.settings.get(this.options.provider).accounts;
-        return accounts && Object.hasOwn(accounts, account) ? accounts[account] : undefined;
+        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);
+        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) ?? [];
+        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)) {
+        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');
         }
     }
@@ -60,7 +65,9 @@ export class AccountPreferencesAdapter extends LlmAdapter {
                 await this.requireAccount(key, model, false);
                 return key;
             }
-            catch { /* unavailable catalog */ }
+            catch {
+                /* unavailable catalog */
+            }
         }
         throw new LlmError(`No eligible account for ${this.options.provider}/${model}`, 'NO_ADAPTER');
     }
@@ -76,7 +83,8 @@ export class AccountPreferencesAdapter extends LlmAdapter {
             await this.requireAccount(key, model, false);
             return key;
         };
-        return new Proxy(raw, { get: (target, property) => {
+        return new Proxy(raw, {
+            get: (target, property) => {
                 if (property === 'streamAccount')
                     return async function* (options, account) {
                         let key;
@@ -94,34 +102,51 @@ export class AccountPreferencesAdapter extends LlmAdapter {
                     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(() => []) })));
+        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))
+                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)) {
+                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}` });
+                    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))
+        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 */ }
+            catch {
+                /* excluded tier */
+            }
         }
-        const priority = (model) => model.priority ?? Number.MAX_SAFE_INTEGER;
+        const priority = (model) => model.priority ??
+            Number.MAX_SAFE_INTEGER;
         return [...result.values()].sort((left, right) => priority(left) - priority(right));
     }
     async resolveModel(provider, id) {
@@ -129,11 +154,15 @@ export class AccountPreferencesAdapter extends LlmAdapter {
         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 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))
+        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));
     }
@@ -145,7 +174,7 @@ export class AccountPreferencesAdapter extends LlmAdapter {
             return;
         }
         const pool = this.options.pool();
-        if (pool && await pool.owns(this.options.provider, options.model)) {
+        if (pool && (await pool.owns(this.options.provider, options.model))) {
             yield* pool.stream(options);
             return;
         }

package/lib/providers/accounts.js

@@ -15,7 +15,9 @@ 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;
+    return typeof ranked.priority === 'number'
+        ? ranked.priority
+        : Number.MAX_SAFE_INTEGER;
 }
 /**
  * Merge per-account catalogs, keeping the first occurrence of each model id.
@@ -31,7 +33,9 @@ export async function unionAccountCatalogs(accounts, listOne, options) {
         try {
             if (timeoutMs === undefined)
                 return await listOne(account, caller);
-            const models = await withTimeout(timeoutSignal => listOne(account, caller === undefined ? timeoutSignal : AbortSignal.any([timeoutSignal, caller])), timeoutMs);
+            const models = await withTimeout((timeoutSignal) => listOne(account, caller === undefined
+                ? timeoutSignal
+                : AbortSignal.any([timeoutSignal, caller])), timeoutMs);
             return models ?? [];
         }
         catch (error) {
@@ -63,10 +67,10 @@ export class AccountTokenManager {
         const provider = options.provider;
         this.io = options.io ?? {
             list: () => listAccounts(provider),
-            get: account => getAccountSession(provider, account),
+            get: (account) => getAccountSession(provider, account),
             save: (account, session) => saveAccountSession(provider, account, session),
-            remove: account => deleteAccountSession(provider, account),
-            resolve: account => resolveAccountKey(provider, account),
+            remove: (account) => deleteAccountSession(provider, account),
+            resolve: (account) => resolveAccountKey(provider, account),
         };
     }
     /** The provider's accounts, default first (straight from the store). */
@@ -86,7 +90,7 @@ export class AccountTokenManager {
      * @throws LlmError MISSING_CREDENTIAL when the account is not logged in.
      */
     async session(account, forceRefresh = false) {
-        const requested = account ?? await this.defaultAccount();
+        const requested = account ?? (await this.defaultAccount());
         if (requested === undefined)
             throw this.missingCredential();
         const key = await this.resolveAccount(requested);
@@ -128,7 +132,9 @@ export class AccountTokenManager {
                     }
                 },
                 remove: () => io.remove(boundAccount),
-                onRemoved: () => { this.options.onAccountRemoved?.(boundAccount); },
+                onRemoved: () => {
+                    this.options.onAccountRemoved?.(boundAccount);
+                },
             });
             this.managers.set(account, manager);
         }
@@ -136,7 +142,7 @@ export class AccountTokenManager {
     }
     /** The logged-out error, mirroring TokenManager's own message. */
     missingCredential() {
-        return new LlmError(`dsh-subscriptions: not logged in to ${this.options.displayName}; `
-            + 'log in via Settings → Subscriptions in the dsh web app', 'MISSING_CREDENTIAL');
+        return new LlmError(`dsh-subscriptions: 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.js

@@ -3,5 +3,5 @@
  * 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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";
+export const ANTIGRAVITY_DEFAULT_CLIENT_ID = '1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com';
+export const ANTIGRAVITY_DEFAULT_CLIENT_SECRET = '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';