dsh-plugin-subscriptions 0.4.1 → 0.5.0

package/lib/providers/catalog-store.js

@@ -71,6 +71,12 @@ function sanitizeModel(value) {
     const reasoning = raw.reasoning === undefined ? undefined : sanitizeReasoning(raw.reasoning);
     if (raw.reasoning !== undefined && reasoning === undefined)
         return undefined;
+    const thinkingType = raw.thinkingType;
+    if (thinkingType !== undefined && thinkingType !== 'enabled' && thinkingType !== 'adaptive')
+        return undefined;
+    const fastTier = raw.fastTier;
+    if (fastTier !== undefined && typeof fastTier !== 'boolean')
+        return undefined;
     return {
         id: raw.id,
         name: raw.name,
@@ -78,6 +84,8 @@ function sanitizeModel(value) {
         ...raw.contextWindow === undefined ? {} : { contextWindow: raw.contextWindow },
         ...raw.priority === undefined ? {} : { priority: raw.priority },
         ...reasoning === undefined ? {} : { reasoning },
+        ...thinkingType === undefined ? {} : { thinkingType: thinkingType },
+        ...fastTier === undefined ? {} : { fastTier },
     };
 }
 /**

package/lib/providers/claude.d.ts

@@ -9,14 +9,23 @@ import type { FlowSpec } from '../auth/oauth-flow.js';
 import type { ClaudeSession } from '../auth/store.js';
 import type { AttachmentStore } from '@deepseek-ai/dsh-attachment';
 import { TokenManager } from './common.js';
-import type { FetchFn, ModelEntry, ProviderUsage } from './common.js';
+import type { CatalogPersistence, DiscoveredModel, FetchFn, ModelEntry, ProviderUsage } from './common.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://platform.claude.com/v1/oauth/token";
+export declare const CLAUDE_AUTHORIZE_URL = "https://claude.com/cai/oauth/authorize";
+export declare const CLAUDE_TOKEN_URL = "https://claude.ai/v1/oauth/token";
 export declare const CLAUDE_API_URL = "https://api.anthropic.com/v1/messages?beta=true";
 export declare const CLAUDE_PROFILE_URL = "https://api.anthropic.com/api/oauth/profile";
+export declare const CLAUDE_MODELS_URL = "https://api.anthropic.com/v1/models?beta=true";
 /** Refresh when the access token has less than this much life left. */
 export declare const CLAUDE_PREEMPT_MS: number;
+/**
+ * The subscription endpoint only serves requests presenting as Claude Code,
+ * so these headers impersonate the CLI; the harness attribution user-agent
+ * cannot be sent here (one user-agent slot, and the CLI's wins).
+ */
+export declare const CLAUDE_CLI_FALLBACK_VERSION = "2.1.234";
+export declare function detectClaudeVersion(): string;
+export declare const CLAUDE_BETA_FALLBACK: string;
 /** Static claude flow facts for the OAuth flow engine. */
 export declare const claudeFlow: FlowSpec;
 /**
@@ -52,21 +61,44 @@ 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[]>;
 /** Constructor dependencies for {@link ClaudeAdapter}. */
 export interface ClaudeAdapterOptions {
     models: readonly ModelEntry[];
     streamIdleTimeoutMs: number;
     tokens: TokenManager<ClaudeSession>;
+    /** 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;
     /** 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;
 }
 /** Claude wire adapter: one instance serves the `claude` provider route. */
 export declare class ClaudeAdapter extends LlmAdapter {
     private readonly options;
+    private readonly catalog;
     constructor(options: ClaudeAdapterOptions);
+    private fetchCatalog;
+    private discovered;
+    private staticModels;
     providerInfo(provider: string): LlmProviderInfo;
+    providerRetryPolicy(provider: string): import("@deepseek-ai/dsh-llm").ResolvedRetryPolicy | undefined;
     listModels(provider: string): Promise<readonly LlmModelInfo[]>;
     resolveModel(provider: string, model: string): Promise<LlmResolvedModelInfo>;
     stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
+    /**
+     * `display: 'summarized'` is set explicitly on both shapes: `adaptive`-type
+     * models default to `display: 'omitted'`, which returns thinking blocks with
+     * an empty `thinking` field — without this override the "Think" panel would
+     * always render empty even though real reasoning (and billed thinking_tokens)
+     * ran.
+     */
+    private thinkingParam;
     private request;
 }

package/lib/providers/claude.js

@@ -3,15 +3,17 @@
  * platform.claude.com with the Claude Code client id, and streaming against
  * the Anthropic Messages API with the Claude Code identity headers.
  */
-import { EMPTY_RESPONSE_CODE, LlmAdapter, LlmError } from '@deepseek-ai/dsh-llm';
+import { execFileSync } from 'node:child_process';
+import { EMPTY_RESPONSE_CODE, errorChain, LlmAdapter, LlmError, ReasoningEffortId, resolveRetryPolicy } from '@deepseek-ai/dsh-llm';
 import { resolveImages } from '../translate/resolved.js';
 import { streamAnthropic, toAnthropicMessages, toAnthropicSystem, toAnthropicTools, } from '../translate/anthropic.js';
-import { httpLlmError, idleWatchdog, mapFetchFailure, oauthEndpointError, OAuthEndpointError, TokenManager, } from './common.js';
+import { httpLlmError, idleWatchdog, mapFetchFailure, ModelCatalogCache, oauthEndpointError, OAuthEndpointError, TokenManager, } from './common.js';
 export const CLAUDE_CLIENT_ID = '9d1c250a-e61b-44d9-88ed-5944d1962f5e';
-export const CLAUDE_AUTHORIZE_URL = 'https://claude.ai/oauth/authorize';
-export const CLAUDE_TOKEN_URL = 'https://platform.claude.com/v1/oauth/token';
+export const CLAUDE_AUTHORIZE_URL = 'https://claude.com/cai/oauth/authorize';
+export const CLAUDE_TOKEN_URL = 'https://claude.ai/v1/oauth/token';
 export const CLAUDE_API_URL = 'https://api.anthropic.com/v1/messages?beta=true';
 export const CLAUDE_PROFILE_URL = 'https://api.anthropic.com/api/oauth/profile';
+export const CLAUDE_MODELS_URL = 'https://api.anthropic.com/v1/models?beta=true';
 const CLAUDE_SCOPE = 'org:create_api_key user:profile user:inference user:sessions:claude_code user:mcp_servers user:file_upload';
 const CLAUDE_CALLBACK_PATH = '/callback';
 const CLAUDE_CONTEXT_WINDOW = 200_000;
@@ -23,19 +25,49 @@ export const CLAUDE_PREEMPT_MS = 5 * 60_000;
  * so these headers impersonate the CLI; the harness attribution user-agent
  * cannot be sent here (one user-agent slot, and the CLI's wins).
  */
-const CLAUDE_CLI_USER_AGENT = 'claude-cli/2.1.97 (external, cli)';
-const CLAUDE_BETA_FLAGS = 'claude-code-20250219,oauth-2025-04-20,interleaved-thinking-2025-05-14,context-management-2025-06-27';
+export const CLAUDE_CLI_FALLBACK_VERSION = '2.1.234';
+export function detectClaudeVersion() {
+    try {
+        const raw = execFileSync('claude', ['--version'], { timeout: 3000, encoding: 'utf8' });
+        const match = raw.match(/^(\d+\.\d+\.\d+)/);
+        if (match)
+            return match[1];
+    }
+    catch { }
+    return CLAUDE_CLI_FALLBACK_VERSION;
+}
+// Lazy + memoized: detectClaudeVersion() shells out to `claude --version`,
+// so this must not run at module-evaluation time (it would fire for every
+// consumer of this module regardless of whether Claude is a configured
+// provider). Computed on first use of getClaudeCliUserAgent() instead.
+let claudeCliUserAgent;
+function getClaudeCliUserAgent() {
+    if (claudeCliUserAgent === undefined) {
+        claudeCliUserAgent = `claude-cli/${detectClaudeVersion()} (external, cli)`;
+    }
+    return claudeCliUserAgent;
+}
+export const CLAUDE_BETA_FALLBACK = [
+    'claude-code-20250219',
+    'oauth-2025-04-20',
+    'interleaved-thinking-2025-05-14',
+    'context-management-2025-06-27',
+    'effort-2025-11-24',
+    'compact-2026-01-12',
+    'files-api-2025-04-14',
+].join(',');
+const CLAUDE_BETA_FLAGS = CLAUDE_BETA_FALLBACK;
 /** Static claude flow facts for the OAuth flow engine. */
 export const claudeFlow = {
     callbackPath: CLAUDE_CALLBACK_PATH,
     // The redirect URI embeds the port, so it must be an ephemeral one.
-    listen: { host: 'localhost', ports: [0] },
+    listen: { host: '127.0.0.1', ports: [0] },
     buildAuthorizeUrl({ redirectUri, state, pkce }) {
         const params = new URLSearchParams({
             code: 'true',
             client_id: CLAUDE_CLIENT_ID,
             response_type: 'code',
-            redirect_uri: redirectUri,
+            redirect_uri: 'https://platform.claude.com/oauth/code/callback',
             scope: CLAUDE_SCOPE,
             code_challenge: pkce.challenge,
             code_challenge_method: 'S256',
@@ -212,7 +244,7 @@ export async function fetchClaudeUsage(session, fetchFn = fetch, signal) {
             'anthropic-beta': 'oauth-2025-04-20',
             // Unrecognized clients are aggressively rate-limited on this endpoint,
             // so it presents as the CLI like every other subscription request.
-            'user-agent': CLAUDE_CLI_USER_AGENT,
+            'user-agent': getClaudeCliUserAgent(),
             'accept': 'application/json',
         },
         ...signal === undefined ? {} : { signal },
@@ -236,24 +268,88 @@ export async function fetchClaudeUsage(session, fetchFn = fetch, signal) {
     }
     return { supported: true, windows };
 }
+function claudeThinkingType(capabilities) {
+    const types = capabilities?.thinking?.types;
+    if (types?.enabled?.supported === true)
+        return 'enabled';
+    if (types?.adaptive?.supported === true)
+        return 'adaptive';
+    return undefined;
+}
+/** Effort levels in display order; a model exposes only the ones it advertises as supported. */
+const CLAUDE_EFFORT_LEVELS = ['low', 'medium', 'high', 'xhigh', 'max'];
+function claudeReasoning(capabilities) {
+    const effort = capabilities?.effort;
+    if (effort?.supported !== true)
+        return undefined;
+    const efforts = CLAUDE_EFFORT_LEVELS
+        .filter(level => effort[level]?.supported === true)
+        .map(level => ({ id: ReasoningEffortId(level), name: level[0].toUpperCase() + level.slice(1) }));
+    return efforts.length > 0 ? { efforts } : undefined;
+}
+/** Fetch the live model catalog from the subscription endpoint. */
+export async function fetchClaudeModels(session, fetchFn = fetch) {
+    const response = await fetchFn(CLAUDE_MODELS_URL, {
+        headers: {
+            'authorization': `Bearer ${session.accessToken}`,
+            'anthropic-version': '2023-06-01',
+            'user-agent': getClaudeCliUserAgent(),
+            'anthropic-dangerous-direct-browser-access': 'true',
+            'accept': 'application/json',
+        },
+    });
+    if (!response.ok)
+        throw await httpLlmError(response, 'claude models API');
+    const payload = await response.json();
+    if (!Array.isArray(payload.data)) {
+        throw new Error('claude models API returned an invalid catalog');
+    }
+    const models = payload.data
+        .filter((m) => typeof m.id === 'string')
+        .map((m) => {
+        const thinkingType = claudeThinkingType(m.capabilities);
+        const reasoning = claudeReasoning(m.capabilities);
+        return {
+            id: m.id,
+            name: m.display_name ?? m.id,
+            ...thinkingType === undefined ? {} : { thinkingType },
+            ...reasoning === undefined ? {} : { reasoning },
+        };
+    });
+    if (models.length === 0) {
+        throw new Error('claude models API returned an empty catalog');
+    }
+    return models;
+}
+/**
+ * Claude Code's own SDK retry shape: exponential backoff starting at 1s,
+ * doubling per attempt, capped at 60s, plus jitter. `maxRetries` is the
+ * count of retries after the first attempt (Claude Code defaults to 10).
+ */
+const CLAUDE_RETRY_INITIAL_DELAY_MS = 1_000;
+const CLAUDE_RETRY_MAX_DELAY_MS = 60_000;
+const CLAUDE_RETRY_JITTER_RATIO = 0.2;
 /** The Claude 4.5 family accepts image input. */
 const CLAUDE_MODALITIES = ['text', 'image'];
 /** Claude wire adapter: one instance serves the `claude` provider route. */
 export class ClaudeAdapter extends LlmAdapter {
     options;
+    catalog;
     constructor(options) {
         super();
         this.options = options;
+        this.catalog = new ModelCatalogCache(options.catalogStore);
     }
-    providerInfo(provider) {
-        return { id: provider, name: 'Claude (Subscription)' };
+    async fetchCatalog() {
+        return fetchClaudeModels(await this.options.tokens.session(), this.options.fetchFn);
     }
-    async listModels(provider) {
-        // Not logged in → empty catalog, so the web picker drops the provider.
-        // Claude has no subscription model-list endpoint, so the static catalog
-        // is the whole answer when logged in.
-        if (!await this.options.tokens.hasSession())
-            return [];
+    async discovered(model) {
+        if (!this.options.discovery)
+            return undefined;
+        const models = await this.catalog.resolve(() => this.fetchCatalog());
+        return models?.find(entry => entry.id === model);
+    }
+    staticModels(provider) {
         return this.options.models.map(model => ({
             provider,
             id: model.id,
@@ -261,18 +357,61 @@ export class ClaudeAdapter extends LlmAdapter {
             inputModalities: model.inputModalities ?? CLAUDE_MODALITIES,
         }));
     }
-    resolveModel(provider, model) {
+    providerInfo(provider) {
+        return { id: provider, name: 'Claude (Subscription)' };
+    }
+    providerRetryPolicy(provider) {
+        if (this.options.maxRetries === undefined)
+            return undefined;
+        return resolveRetryPolicy({
+            mode: 'normal',
+            maxRetries: this.options.maxRetries,
+            backoff: {
+                initialDelayMs: CLAUDE_RETRY_INITIAL_DELAY_MS,
+                maxDelayMs: CLAUDE_RETRY_MAX_DELAY_MS,
+                jitterRatio: CLAUDE_RETRY_JITTER_RATIO,
+            },
+        }, `claude: provider "${provider}" retryPolicy`);
+    }
+    async listModels(provider) {
+        if (await this.options.tokens.peek() === undefined)
+            return [];
+        if (!this.options.discovery)
+            return this.staticModels(provider);
+        try {
+            const models = await this.catalog.get(() => this.fetchCatalog());
+            return models.map(model => ({
+                provider,
+                id: model.id,
+                name: model.name,
+                inputModalities: CLAUDE_MODALITIES,
+            }));
+        }
+        catch (error) {
+            if (error instanceof LlmError
+                && (error.code === 'MISSING_CREDENTIAL' || error.code === 'INVALID_CREDENTIAL'))
+                return [];
+            if (error instanceof LlmError && error.code === 'AUTH')
+                this.catalog.invalidate();
+            this.options.onWarn?.(`claude model discovery failed; using the built-in catalog (${errorChain(error)})`);
+            return this.staticModels(provider);
+        }
+    }
+    async resolveModel(provider, model) {
+        const disc = await this.discovered(model);
         const configured = this.options.models.find(entry => entry.id === model);
-        return Promise.resolve({
+        const reasoning = disc?.reasoning;
+        return {
             provider,
             id: model,
-            name: configured?.name ?? model,
+            name: disc?.name ?? configured?.name ?? model,
             inputModalities: configured?.inputModalities ?? CLAUDE_MODALITIES,
-            context: { contextWindow: configured?.contextWindow ?? CLAUDE_CONTEXT_WINDOW },
+            context: {
+                contextWindow: disc?.contextWindow ?? configured?.contextWindow ?? CLAUDE_CONTEXT_WINDOW,
+            },
             defaultMaxTokens: configured?.maxTokens ?? CLAUDE_DEFAULT_MAX_TOKENS,
-            // No reasoning metadata: the subscription endpoint's thinking support is
-            // not exercised, so effort requests reject as unsupported.
-        });
+            ...(reasoning === undefined ? {} : { reasoning }),
+        };
     }
     async *stream(options) {
         const watchdog = idleWatchdog(options.signal, this.options.streamIdleTimeoutMs);
@@ -280,7 +419,6 @@ export class ClaudeAdapter extends LlmAdapter {
             let session = await this.options.tokens.session();
             let response = await this.request(options, session, watchdog.signal);
             if (response.status === 401) {
-                // One forced refresh + retry on an unexpired-but-rejected token.
                 session = await this.options.tokens.session(true);
                 response = await this.request(options, session, watchdog.signal);
             }
@@ -298,18 +436,44 @@ export class ClaudeAdapter extends LlmAdapter {
             watchdog.stop();
         }
     }
+    /**
+     * `display: 'summarized'` is set explicitly on both shapes: `adaptive`-type
+     * models default to `display: 'omitted'`, which returns thinking blocks with
+     * an empty `thinking` field — without this override the "Think" panel would
+     * always render empty even though real reasoning (and billed thinking_tokens)
+     * ran.
+     */
+    thinkingParam(thinkingType, maxTokens) {
+        if (thinkingType === 'adaptive')
+            return { type: 'adaptive', display: 'summarized' };
+        if (thinkingType === 'enabled') {
+            const budget = Math.min(Math.max(1_024, Math.floor(maxTokens * 0.5)), maxTokens - 100);
+            if (budget < 1_024)
+                return undefined;
+            return { type: 'enabled', budget_tokens: budget, display: 'summarized' };
+        }
+        return undefined;
+    }
     async request(options, session, signal) {
         const messages = await resolveImages(options.messages, this.options.resolveAttachments?.(), signal);
+        const maxTokens = options.maxTokens
+            ?? this.options.models.find(entry => entry.id === options.model)?.maxTokens
+            ?? CLAUDE_DEFAULT_MAX_TOKENS;
+        const disc = await this.discovered(options.model);
+        const thinking = this.thinkingParam(disc?.thinkingType, maxTokens);
+        const effort = options.reasoningEffort !== undefined && disc?.reasoning !== undefined
+            ? { output_config: { effort: String(options.reasoningEffort) } }
+            : {};
         const body = {
             model: options.model,
-            max_tokens: options.maxTokens
-                ?? this.options.models.find(entry => entry.id === options.model)?.maxTokens
-                ?? CLAUDE_DEFAULT_MAX_TOKENS,
+            max_tokens: maxTokens,
             system: toAnthropicSystem(options.system, messages),
             messages: toAnthropicMessages(messages),
             ...options.tools !== undefined && options.tools.length > 0
                 ? { tools: toAnthropicTools(options.tools) }
                 : {},
+            ...thinking === undefined ? {} : { thinking },
+            ...effort,
             stream: true,
             ...options.sessionId !== undefined ? { metadata: { user_id: String(options.sessionId) } } : {},
         };
@@ -319,7 +483,7 @@ export class ClaudeAdapter extends LlmAdapter {
                 'authorization': `Bearer ${session.accessToken}`,
                 'anthropic-version': '2023-06-01',
                 'anthropic-beta': CLAUDE_BETA_FLAGS,
-                'user-agent': CLAUDE_CLI_USER_AGENT,
+                'user-agent': getClaudeCliUserAgent(),
                 'x-app': 'cli',
                 'anthropic-dangerous-direct-browser-access': 'true',
                 'accept': 'text/event-stream',

package/lib/providers/codex.d.ts

@@ -8,6 +8,7 @@ import type { GenerateOptions, LlmModelInfo, LlmProviderInfo, LlmResolvedModelIn
 import type { FlowSpec } from '../auth/oauth-flow.js';
 import type { CodexSession } from '../auth/store.js';
 import type { AttachmentStore } from '@deepseek-ai/dsh-attachment';
+import type { ResponsesRequestInput } from '../translate/responses.js';
 import { TokenManager } from './common.js';
 import type { CatalogPersistence, DiscoveredModel, FetchFn, ModelEntry, ProviderUsage } from './common.js';
 export declare const CODEX_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
@@ -16,6 +17,15 @@ export declare const CODEX_TOKEN_URL = "https://auth.openai.com/oauth/token";
 export declare const CODEX_API_URL = "https://chatgpt.com/backend-api/codex/responses";
 /** Refresh when the access token has less than this much life left. */
 export declare const CODEX_PREEMPT_MS: number;
+/**
+ * Fast tier (the codex CLI's "fast mode"): the Responses `service_tier` wire
+ * value for priority processing, mirroring codex-rs
+ * `ServiceTier::Fast.request_value()`. The legacy catalog spelling is the
+ * `additional_speed_tiers` entry "fast".
+ */
+export declare const CODEX_FAST_SERVICE_TIER = "priority";
+/** One session's speed choice: standard routing or the fast (priority) tier. */
+export type CodexSpeedTier = 'standard' | 'fast';
 /** Static codex flow facts for the OAuth flow engine. */
 export declare const codexFlow: FlowSpec;
 /** User identity claims decoded from a codex id token. */
@@ -98,7 +108,20 @@ export interface CodexAdapterOptions {
     resolveAttachments?: () => AttachmentStore | undefined;
     /** Durable catalog store seeding capability metadata across restarts. */
     catalogStore?: CatalogPersistence;
+    /**
+     * Per-request speed lookup (the composer Speed toggle's host half). Returns
+     * whether this session's current choice sends the model on the fast tier;
+     * absent means every request stays on standard routing.
+     */
+    speedFor?: (sessionId: string | undefined, model: string) => Promise<boolean> | boolean;
 }
+/**
+ * The Responses request body for one generation. A fast-tier request (the
+ * composer Speed toggle, the codex CLI's fast mode) carries
+ * `service_tier: priority`; the tier field is omitted entirely otherwise,
+ * matching the CLI (it never sends an explicit standard tier).
+ */
+export declare function codexRequestBody(options: GenerateOptions, resolved: ResponsesRequestInput, fast: boolean): Record<string, unknown>;
 /** Codex wire adapter: one instance serves the `codex` provider route. */
 export declare class CodexAdapter extends LlmAdapter {
     private readonly options;
@@ -117,6 +140,10 @@ export declare class CodexAdapter extends LlmAdapter {
      * call — just because the TTL lapsed mid-turn.
      */
     private discovered;
+    /** Whether the discovered catalog advertises a fast tier for this model. */
+    supportsFastTier(model: string): Promise<boolean>;
+    /** Ids of every discovered model with a fast tier (the Speed toggle's visibility list). */
+    fastCapableModels(): Promise<string[]>;
     resolveModel(provider: string, model: string): Promise<LlmResolvedModelInfo>;
     stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
     private request;

package/lib/providers/codex.js

@@ -39,6 +39,14 @@ const CODEX_EFFORTS = [
 const CODEX_DEFAULT_EFFORT = ReasoningEffortId('high');
 /** Every gpt-5.x codex model accepts image input. */
 const CODEX_MODALITIES = ['text', 'image'];
+/**
+ * Fast tier (the codex CLI's "fast mode"): the Responses `service_tier` wire
+ * value for priority processing, mirroring codex-rs
+ * `ServiceTier::Fast.request_value()`. The legacy catalog spelling is the
+ * `additional_speed_tiers` entry "fast".
+ */
+export const CODEX_FAST_SERVICE_TIER = 'priority';
+const CODEX_FAST_SPEED_TIER = 'fast';
 /** Static codex flow facts for the OAuth flow engine. */
 export const codexFlow = {
     callbackPath: CODEX_CALLBACK_PATH,
@@ -286,6 +294,15 @@ export const CODEX_CLIENT_VERSION = '0.147.0';
 function effortName(effort) {
     return effort === 'xhigh' ? 'Extra High' : effort.charAt(0).toUpperCase() + effort.slice(1);
 }
+/**
+ * Whether a catalog entry advertises the fast tier. Mirrors codex-rs
+ * `ModelPreset::supports_fast_mode`: a `service_tiers` id matching the fast
+ * wire value, or the legacy `additional_speed_tiers` "fast" entry.
+ */
+function supportsFastTier(entry) {
+    return (entry.service_tiers ?? []).some(tier => tier.id === CODEX_FAST_SERVICE_TIER)
+        || (entry.additional_speed_tiers ?? []).includes(CODEX_FAST_SPEED_TIER);
+}
 /**
  * Fetch the live codex model catalog with the session's auth headers.
  * @param session - the stored session (used as-is; never refreshed here).
@@ -328,7 +345,7 @@ export async function fetchCodexModels(session, fetchFn = fetch) {
             && efforts.some(effort => effort.id === ReasoningEffortId(entry.default_reasoning_level))
             ? ReasoningEffortId(entry.default_reasoning_level)
             : undefined;
-        discovered.push({
+        const model = {
             id: entry.slug,
             name: typeof entry.display_name === 'string' && entry.display_name.length > 0
                 ? entry.display_name
@@ -343,7 +360,9 @@ export async function fetchCodexModels(session, fetchFn = fetch) {
             ...efforts.length > 0
                 ? { reasoning: { efforts, ...defaultEffort === undefined ? {} : { defaultEffort } } }
                 : {},
-        });
+            ...supportsFastTier(entry) ? { fastTier: true } : {},
+        };
+        discovered.push(model);
     }
     discovered.sort((a, b) => (a.priority ?? Number.MAX_SAFE_INTEGER) - (b.priority ?? Number.MAX_SAFE_INTEGER));
     // An empty catalog from a 200 response means the backend gated us out (e.g.
@@ -354,6 +373,32 @@ export async function fetchCodexModels(session, fetchFn = fetch) {
     }
     return discovered;
 }
+/**
+ * The Responses request body for one generation. A fast-tier request (the
+ * composer Speed toggle, the codex CLI's fast mode) carries
+ * `service_tier: priority`; the tier field is omitted entirely otherwise,
+ * matching the CLI (it never sends an explicit standard tier).
+ */
+export function codexRequestBody(options, resolved, fast) {
+    return {
+        model: options.model,
+        instructions: resolved.instructions ?? DEFAULT_CODEX_INSTRUCTIONS,
+        input: resolved.input,
+        ...options.tools !== undefined && options.tools.length > 0
+            ? { tools: toResponsesTools(options.tools) }
+            : {},
+        tool_choice: 'auto',
+        parallel_tool_calls: true,
+        ...options.reasoningEffort !== undefined
+            ? { reasoning: { effort: String(options.reasoningEffort), summary: 'auto' } }
+            : {},
+        store: false,
+        stream: true,
+        include: ['reasoning.encrypted_content'],
+        ...options.sessionId !== undefined ? { prompt_cache_key: String(options.sessionId) } : {},
+        ...fast ? { service_tier: CODEX_FAST_SERVICE_TIER } : {},
+    };
+}
 /** Codex wire adapter: one instance serves the `codex` provider route. */
 export class CodexAdapter extends LlmAdapter {
     options;
@@ -423,6 +468,22 @@ export class CodexAdapter extends LlmAdapter {
         const models = await this.catalog.resolve(() => this.fetchCatalog());
         return models?.find(entry => entry.id === model);
     }
+    /** Whether the discovered catalog advertises a fast tier for this model. */
+    async supportsFastTier(model) {
+        return (await this.discovered(model))?.fastTier === true;
+    }
+    /** Ids of every discovered model with a fast tier (the Speed toggle's visibility list). */
+    async fastCapableModels() {
+        if (!this.options.discovery)
+            return [];
+        // Not logged in → no fast models, so the Speed toggle hides after logout
+        // (mirrors the listModels guard above).
+        const session = await this.options.tokens.peek();
+        if (session === undefined)
+            return [];
+        const models = await this.catalog.resolve(() => this.fetchCatalog());
+        return (models ?? []).filter(model => model.fastTier === true).map(model => model.id);
+    }
     async resolveModel(provider, model) {
         // Discovered metadata (when discovery is on) wins over the static entry;
         // the static entry wins over the built-in defaults.
@@ -465,24 +526,9 @@ export class CodexAdapter extends LlmAdapter {
     }
     async request(options, session, signal) {
         const messages = await resolveImages(options.messages, this.options.resolveAttachments?.(), signal);
-        const { instructions, input } = toResponsesInput(messages, options.system);
-        const body = {
-            model: options.model,
-            instructions: instructions ?? DEFAULT_CODEX_INSTRUCTIONS,
-            input,
-            ...options.tools !== undefined && options.tools.length > 0
-                ? { tools: toResponsesTools(options.tools) }
-                : {},
-            tool_choice: 'auto',
-            parallel_tool_calls: true,
-            ...options.reasoningEffort !== undefined
-                ? { reasoning: { effort: String(options.reasoningEffort), summary: 'auto' } }
-                : {},
-            store: false,
-            stream: true,
-            include: ['reasoning.encrypted_content'],
-            ...options.sessionId !== undefined ? { prompt_cache_key: String(options.sessionId) } : {},
-        };
+        const fast = this.options.speedFor !== undefined
+            && await this.options.speedFor(options.sessionId, options.model);
+        const body = codexRequestBody(options, toResponsesInput(messages, options.system), fast);
         return fetch(CODEX_API_URL, {
             method: 'POST',
             headers: {

package/lib/providers/common.d.ts

@@ -175,6 +175,10 @@ export interface DiscoveredModel {
         }[];
         defaultEffort?: ReasoningEffortId;
     };
+    /** Claude-specific: which extended-thinking wire shape this model accepts. */
+    thinkingType?: 'enabled' | 'adaptive';
+    /** Codex-specific: the catalog advertises a fast (priority) service tier. */
+    fastTier?: boolean;
 }
 /** How long a discovered catalog is trusted before re-fetching. */
 export declare const DISCOVERY_TTL_MS: number;

package/lib/tools/image-generate.js

@@ -16,7 +16,6 @@ import { mkdir, writeFile } from 'node:fs/promises';
 import { basename, join } from 'node:path';
 import { dshHomePath } from '@deepseek-ai/dsh-home-paths';
 import { AttachmentId } from '@deepseek-ai/dsh-attachment';
-import { createUserMessage } from '@deepseek-ai/dsh-llm';
 import { defineTool } from '@deepseek-ai/dsh-tools';
 import { httpLlmError, TokenManager } from '../providers/common.js';
 /** Endpoint the codex generation request is posted to. */
@@ -334,15 +333,9 @@ export function createImageGenerateTool(options) {
                 ...refs.length > 0 ? { images: refs } : {},
                 ...revisedPrompt === undefined ? {} : { revisedPrompt },
             };
-            // Nested (Code Mode) dispatches have no card: defer the image content as
-            // a user message so the next model request still sees it (read_image's
-            // pattern).
-            if (exec.parent !== undefined && refs.length > 0) {
-                exec.deferContext(createUserMessage({
-                    content: imageGenerateContent(value),
-                    source: { kind: 'plugin', plugin: 'dsh-plugin-subscriptions' },
-                }));
-            }
+            // Nested (Code Mode) dispatches need no defer here: the harness's code
+            // mode already defers any image-bearing sub-result as a user message, so
+            // deferring again would inject the same attachment twice.
             return value;
         },
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-subscriptions",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "Use ChatGPT (Codex), Claude, and Grok (X Premium) subscriptions as DeepSeek Harness LLM providers, with OAuth login from the web Settings page",
   "license": "MIT",
   "repository": {
@@ -70,6 +70,8 @@
     "@deepseek-ai/dsh-client-locale": "link:/Users/v1ki/Documents/projs/source/deepseek-harness/packages/client/locale",
     "@deepseek-ai/dsh-client-runtime": "link:/Users/v1ki/Documents/projs/source/deepseek-harness/packages/client/runtime",
     "@deepseek-ai/dsh-client-ui-settings": "link:/Users/v1ki/Documents/projs/source/deepseek-harness/packages/client/ui-settings",
+    "@deepseek-ai/dsh-client-ui-conversation": "link:/Users/v1ki/Documents/projs/source/deepseek-harness/packages/client/ui-conversation",
+    "@deepseek-ai/dsh-client-ui-commands": "link:/Users/v1ki/Documents/projs/source/deepseek-harness/packages/client/ui-commands",
     "@deepseek-ai/dsh-client-ui-slots": "link:/Users/v1ki/Documents/projs/source/deepseek-harness/packages/client/ui-slots",
     "@deepseek-ai/dsh-home-paths": "link:/Users/v1ki/Documents/projs/source/deepseek-harness/packages/util/home-paths",
     "@deepseek-ai/dsh-host-apiproxy": "link:/Users/v1ki/Documents/projs/source/deepseek-harness/packages/host/apiproxy",