dsh-plugin-subscriptions 0.4.2 → 0.5.1

package/lib/providers/catalog-store.js

@@ -74,6 +74,21 @@ function sanitizeModel(value) {
     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;
+    const copilotWire = raw.copilotWire;
+    if (copilotWire !== undefined && copilotWire !== 'chat-completions' && copilotWire !== 'responses') {
+        return undefined;
+    }
+    const copilotResponses = raw.copilotResponses;
+    if (copilotResponses !== undefined && typeof copilotResponses !== 'boolean')
+        return undefined;
+    const inputModalities = raw.inputModalities;
+    if (inputModalities !== undefined
+        && (!Array.isArray(inputModalities) || inputModalities.length === 0
+            || inputModalities.some(modality => modality !== 'text' && modality !== 'image')))
+        return undefined;
     return {
         id: raw.id,
         name: raw.name,
@@ -82,6 +97,10 @@ function sanitizeModel(value) {
         ...raw.priority === undefined ? {} : { priority: raw.priority },
         ...reasoning === undefined ? {} : { reasoning },
         ...thinkingType === undefined ? {} : { thinkingType: thinkingType },
+        ...fastTier === undefined ? {} : { fastTier },
+        ...copilotWire === undefined ? {} : { copilotWire: copilotWire },
+        ...copilotResponses === undefined ? {} : { copilotResponses },
+        ...inputModalities === undefined ? {} : { inputModalities: [...inputModalities] },
     };
 }
 /**

package/lib/providers/claude.d.ts

@@ -8,14 +8,17 @@ import type { GenerateOptions, LlmModelInfo, LlmProviderInfo, LlmResolvedModelIn
 import type { FlowSpec } from '../auth/oauth-flow.js';
 import type { ClaudeSession } from '../auth/store.js';
 import type { AttachmentStore } from '@deepseek-ai/dsh-attachment';
+import type { TranslatableMessage } from '../translate/resolved.js';
 import { TokenManager } 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.com/cai/oauth/authorize";
+export declare const CLAUDE_AUTHORIZE_URL = "https://claude.ai/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";
+export declare const CLAUDE_SCOPE = "org:create_api_key user:profile user:inference user:sessions:claude_code user:mcp_servers user:file_upload";
+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;
 /**
@@ -79,6 +82,22 @@ export interface ClaudeAdapterOptions {
     /** Durable catalog store seeding capability metadata across restarts. */
     catalogStore?: CatalogPersistence;
 }
+/**
+ * Assemble the Anthropic request body.
+ *
+ * Extracted from the adapter so the wire shape — cache breakpoints above all —
+ * is testable without a network round trip. The message array is marked before
+ * it is placed so the breakpoints land on the blocks the body ships: one on the
+ * last `system` block (covering `tools` + `system`, which render ahead of it)
+ * and up to three across the history, Anthropic's four-slot maximum.
+ * @param options - the generate request.
+ * @param messages - conversation messages with images already resolved.
+ * @param maxTokens - the resolved output cap.
+ * @param thinking - the thinking parameter, when the model takes one.
+ * @param effort - the reasoning effort, when the model advertises efforts.
+ * @returns the JSON body to POST.
+ */
+export declare function claudeRequestBody(options: GenerateOptions, messages: readonly TranslatableMessage[], maxTokens: number, thinking?: Record<string, unknown>, effort?: string): Record<string, unknown>;
 /** Claude wire adapter: one instance serves the `claude` provider route. */
 export declare class ClaudeAdapter extends LlmAdapter {
     private readonly options;

package/lib/providers/claude.js

@@ -6,16 +6,16 @@
 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, ModelCatalogCache, oauthEndpointError, OAuthEndpointError, TokenManager, } from './common.js';
+import { markMessageCache, streamAnthropic, toAnthropicMessages, toAnthropicSystem, toAnthropicTools, } from '../translate/anthropic.js';
+import { httpLlmError, idleWatchdog, mapFetchFailure, ModelCatalogCache, discoverOrRetryAuth, isMissingOrInvalidCredential, oauthEndpointError, OAuthEndpointError, TokenManager, } from './common.js';
 export const CLAUDE_CLIENT_ID = '9d1c250a-e61b-44d9-88ed-5944d1962f5e';
-export const CLAUDE_AUTHORIZE_URL = 'https://claude.com/cai/oauth/authorize';
+export const CLAUDE_AUTHORIZE_URL = 'https://claude.ai/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';
+export const CLAUDE_SCOPE = 'org:create_api_key user:profile user:inference user:sessions:claude_code user:mcp_servers user:file_upload';
+export const CLAUDE_CALLBACK_PATH = '/callback';
 const CLAUDE_CONTEXT_WINDOW = 200_000;
 const CLAUDE_DEFAULT_MAX_TOKENS = 32_000;
 /** Refresh when the access token has less than this much life left. */
@@ -36,7 +36,17 @@ export function detectClaudeVersion() {
     catch { }
     return CLAUDE_CLI_FALLBACK_VERSION;
 }
-const CLAUDE_CLI_USER_AGENT = `claude-cli/${detectClaudeVersion()} (external, cli)`;
+// 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',
@@ -51,13 +61,13 @@ const CLAUDE_BETA_FLAGS = CLAUDE_BETA_FALLBACK;
 export const claudeFlow = {
     callbackPath: CLAUDE_CALLBACK_PATH,
     // The redirect URI embeds the port, so it must be an ephemeral one.
-    listen: { host: '127.0.0.1', ports: [0] },
+    listen: { host: 'localhost', ports: [0] },
     buildAuthorizeUrl({ redirectUri, state, pkce }) {
         const params = new URLSearchParams({
             code: 'true',
             client_id: CLAUDE_CLIENT_ID,
             response_type: 'code',
-            redirect_uri: 'https://platform.claude.com/oauth/code/callback',
+            redirect_uri: redirectUri,
             scope: CLAUDE_SCOPE,
             code_challenge: pkce.challenge,
             code_challenge_method: 'S256',
@@ -234,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 },
@@ -283,7 +293,7 @@ export async function fetchClaudeModels(session, fetchFn = fetch) {
         headers: {
             'authorization': `Bearer ${session.accessToken}`,
             'anthropic-version': '2023-06-01',
-            'user-agent': CLAUDE_CLI_USER_AGENT,
+            'user-agent': getClaudeCliUserAgent(),
             'anthropic-dangerous-direct-browser-access': 'true',
             'accept': 'application/json',
         },
@@ -321,6 +331,38 @@ 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'];
+/**
+ * Assemble the Anthropic request body.
+ *
+ * Extracted from the adapter so the wire shape — cache breakpoints above all —
+ * is testable without a network round trip. The message array is marked before
+ * it is placed so the breakpoints land on the blocks the body ships: one on the
+ * last `system` block (covering `tools` + `system`, which render ahead of it)
+ * and up to three across the history, Anthropic's four-slot maximum.
+ * @param options - the generate request.
+ * @param messages - conversation messages with images already resolved.
+ * @param maxTokens - the resolved output cap.
+ * @param thinking - the thinking parameter, when the model takes one.
+ * @param effort - the reasoning effort, when the model advertises efforts.
+ * @returns the JSON body to POST.
+ */
+export function claudeRequestBody(options, messages, maxTokens, thinking, effort) {
+    const anthropicMessages = toAnthropicMessages(messages);
+    markMessageCache(anthropicMessages);
+    return {
+        model: options.model,
+        max_tokens: maxTokens,
+        system: toAnthropicSystem(options.system, messages),
+        messages: anthropicMessages,
+        ...options.tools !== undefined && options.tools.length > 0
+            ? { tools: toAnthropicTools(options.tools) }
+            : {},
+        ...thinking === undefined ? {} : { thinking },
+        ...effort === undefined ? {} : { output_config: { effort } },
+        stream: true,
+        ...options.sessionId !== undefined ? { metadata: { user_id: String(options.sessionId) } } : {},
+    };
+}
 /** Claude wire adapter: one instance serves the `claude` provider route. */
 export class ClaudeAdapter extends LlmAdapter {
     options;
@@ -369,7 +411,7 @@ export class ClaudeAdapter extends LlmAdapter {
         if (!this.options.discovery)
             return this.staticModels(provider);
         try {
-            const models = await this.catalog.get(() => this.fetchCatalog());
+            const models = await discoverOrRetryAuth(force => this.options.tokens.session(force), this.catalog, () => this.catalog.get(() => this.fetchCatalog()));
             return models.map(model => ({
                 provider,
                 id: model.id,
@@ -378,11 +420,8 @@ export class ClaudeAdapter extends LlmAdapter {
             }));
         }
         catch (error) {
-            if (error instanceof LlmError
-                && (error.code === 'MISSING_CREDENTIAL' || error.code === 'INVALID_CREDENTIAL'))
+            if (isMissingOrInvalidCredential(error))
                 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);
         }
@@ -452,28 +491,16 @@ export class ClaudeAdapter extends LlmAdapter {
         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: 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) } } : {},
-        };
+            ? String(options.reasoningEffort)
+            : undefined;
+        const body = claudeRequestBody(options, messages, maxTokens, thinking, effort);
         return fetch(CLAUDE_API_URL, {
             method: 'POST',
             headers: {
                 '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

@@ -3,12 +3,12 @@
  * Codex CLI client id, and streaming against the ChatGPT backend Responses
  * endpoint.
  */
-import { randomUUID } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
 import { attributionHeaders, EMPTY_RESPONSE_CODE, errorChain, LlmAdapter, LlmError, ReasoningEffortId } from '@deepseek-ai/dsh-llm';
 import { decodeJwtPayload } from '../auth/jwt.js';
 import { resolveImages } from '../translate/resolved.js';
 import { streamResponses, toResponsesInput, toResponsesTools } from '../translate/responses.js';
-import { httpLlmError, idleWatchdog, mapFetchFailure, ModelCatalogCache, oauthEndpointError, OAuthEndpointError, TokenManager, } from './common.js';
+import { httpLlmError, idleWatchdog, mapFetchFailure, ModelCatalogCache, discoverOrRetryAuth, isMissingOrInvalidCredential, oauthEndpointError, OAuthEndpointError, TokenManager, } from './common.js';
 export const CODEX_CLIENT_ID = 'app_EMoamEEZ73f0CkXaXp7hrann';
 export const CODEX_AUTHORIZE_URL = 'https://auth.openai.com/oauth/authorize';
 export const CODEX_TOKEN_URL = 'https://auth.openai.com/oauth/token';
@@ -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,79 @@ export async function fetchCodexModels(session, fetchFn = fetch) {
     }
     return discovered;
 }
+const CODEX_CALL_ID_MAX_LENGTH = 64;
+const CODEX_CALL_ID_PREFIX = 'call_';
+/**
+ * Bound tool-call ids at the Codex wire boundary without changing the shared
+ * Responses translation used by Grok. Short ids stay verbatim. Oversized ids
+ * become deterministic hashes, and every id already present in this request
+ * is reserved first so a generated id cannot collide with a legitimate short
+ * one (or another oversized id).
+ */
+function normalizeCodexCallIds(input) {
+    const mapping = new Map();
+    const used = new Set();
+    const callId = (item) => (item.type === 'function_call' || item.type === 'function_call_output') && typeof item.call_id === 'string'
+        ? item.call_id
+        : undefined;
+    for (const item of input) {
+        const id = callId(item);
+        if (id !== undefined && id.length <= CODEX_CALL_ID_MAX_LENGTH) {
+            mapping.set(id, id);
+            used.add(id);
+        }
+    }
+    for (const item of input) {
+        const id = callId(item);
+        if (id === undefined || mapping.has(id))
+            continue;
+        let attempt = 0;
+        let normalized;
+        do {
+            const hash = createHash('sha256');
+            if (attempt > 0)
+                hash.update(String(attempt)).update('\0');
+            const digest = hash.update(id).digest('hex');
+            normalized = `${CODEX_CALL_ID_PREFIX}${digest.slice(0, CODEX_CALL_ID_MAX_LENGTH - CODEX_CALL_ID_PREFIX.length)}`;
+            attempt += 1;
+        } while (used.has(normalized));
+        mapping.set(id, normalized);
+        used.add(normalized);
+    }
+    return input.map((item) => {
+        const id = callId(item);
+        if (id === undefined)
+            return item;
+        const normalized = mapping.get(id) ?? id;
+        return normalized === id ? item : { ...item, call_id: normalized };
+    });
+}
+/**
+ * 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: normalizeCodexCallIds(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;
@@ -389,7 +481,7 @@ export class CodexAdapter extends LlmAdapter {
             // The fetcher runs only on a cache miss, and resolves the session
             // through the refresh-aware path so an expired access token renews here
             // instead of failing discovery into the static fallback.
-            const discovered = await this.catalog.get(() => this.fetchCatalog());
+            const discovered = await discoverOrRetryAuth(force => this.options.tokens.session(force), this.catalog, () => this.catalog.get(() => this.fetchCatalog()));
             return discovered.map(model => ({
                 provider,
                 id: model.id,
@@ -401,11 +493,8 @@ export class CodexAdapter extends LlmAdapter {
         catch (error) {
             // A permanent refresh failure deletes the stored session: the provider
             // is logged out, so hide it instead of showing a stale static catalog.
-            if (error instanceof LlmError
-                && (error.code === 'MISSING_CREDENTIAL' || error.code === 'INVALID_CREDENTIAL'))
+            if (isMissingOrInvalidCredential(error))
                 return [];
-            if (error instanceof OAuthEndpointError && error.status === 401)
-                this.catalog.invalidate();
             this.options.onWarn?.(`codex model discovery failed; using the built-in catalog (${errorChain(error)})`);
             return this.staticModels(provider);
         }
@@ -423,6 +512,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 +570,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

@@ -19,6 +19,12 @@ export interface ModelEntry {
     maxTokens?: number;
     /** Accepted request modalities; when set, wins over the provider default. */
     inputModalities?: ('text' | 'image')[];
+    /**
+     * Force this model's upstream protocol. Only the copilot adapter consumes
+     * the semantics; the union is inlined here to avoid a circular import of
+     * the copilot module's `CopilotWire`.
+     */
+    wire?: 'chat-completions' | 'responses';
 }
 /**
  * Validate a configured model catalog (mirrors llm-deepseek's resolveModels).
@@ -175,8 +181,20 @@ export interface DiscoveredModel {
         }[];
         defaultEffort?: ReasoningEffortId;
     };
+    /** Accepted request modalities the endpoint advertised (e.g. Copilot's vision support flag). */
+    inputModalities?: ('text' | 'image')[];
     /** 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;
+    /** Copilot-specific: which upstream protocol the model's endpoints speak. */
+    copilotWire?: 'chat-completions' | 'responses';
+    /**
+     * Copilot-specific: the catalog also lists `/responses` for this model
+     * (dual-protocol entries, e.g. gpt-5.4), so a chat-wire request may reroute
+     * there when it combines function tools with a reasoning effort.
+     */
+    copilotResponses?: boolean;
 }
 /** How long a discovered catalog is trusted before re-fetching. */
 export declare const DISCOVERY_TTL_MS: number;
@@ -205,7 +223,7 @@ export interface CatalogPersistence {
  * while a stale entry refreshes in the background, and only awaits the fetch
  * when nothing is known yet. An optional {@link CatalogPersistence} seeds the
  * last-known state across restarts and receives every successful fetch. A 401
- * during a fetch must call {@link invalidate}.
+ * that still fails after a forced token refresh must call {@link invalidate}.
  */
 export declare class ModelCatalogCache {
     private readonly persistence?;
@@ -222,6 +240,12 @@ export declare class ModelCatalogCache {
      * @returns the cached models, or `undefined` when absent or stale.
      */
     cached(): readonly DiscoveredModel[] | undefined;
+    /**
+     * The last successfully fetched catalog, ignoring TTL. Used to carry
+     * capability metadata forward when a later fetch cannot re-enrich.
+     * @returns the last-known models, or `undefined` when nothing has been stored.
+     */
+    lastKnown(): readonly DiscoveredModel[] | undefined;
     /** Load the persisted snapshot once; a fetch or invalidate that landed first wins. */
     private ensureSeeded;
     /** Run (or join) the single in-flight fetch, updating memory and disk on success. */
@@ -246,4 +270,13 @@ export declare class ModelCatalogCache {
     /** Drop the cached catalog (e.g. after a 401 proved the credential changed). */
     invalidate(): void;
 }
+/** Whether discovery failed because the stored login is gone. */
+export declare function isMissingOrInvalidCredential(error: unknown): boolean;
+/**
+ * Run a catalog fetch, retrying once after a forced token refresh when the
+ * first attempt is a 401/AUTH. Only {@link ModelCatalogCache.invalidate}s
+ * when the retry is also an auth failure, so a refresh race cannot erase
+ * last-known capability metadata.
+ */
+export declare function discoverOrRetryAuth<T>(session: (forceRefresh?: boolean) => Promise<unknown>, catalog: ModelCatalogCache, run: () => Promise<T>): Promise<T>;
 export {};

package/lib/providers/common.js

@@ -32,6 +32,9 @@ export function validateModels(models, label) {
                 || model.inputModalities.some(modality => modality !== 'text' && modality !== 'image'))) {
             throw new Error(`${label}: catalog model "${model.id}" inputModalities must be a non-empty list of "text"/"image"`);
         }
+        if (model.wire !== undefined && model.wire !== 'chat-completions' && model.wire !== 'responses') {
+            throw new Error(`${label}: catalog model "${model.id}" wire must be "chat-completions" or "responses"`);
+        }
         if (seen.has(model.id))
             throw new Error(`${label}: duplicate catalog model "${model.id}"`);
         seen.add(model.id);
@@ -41,6 +44,7 @@ export function validateModels(models, label) {
             ...model.contextWindow === undefined ? {} : { contextWindow: model.contextWindow },
             ...model.maxTokens === undefined ? {} : { maxTokens: model.maxTokens },
             ...model.inputModalities === undefined ? {} : { inputModalities: [...model.inputModalities] },
+            ...model.wire === undefined ? {} : { wire: model.wire },
         };
     });
 }
@@ -271,7 +275,7 @@ export const DISCOVERY_TTL_MS = 5 * 60_000;
  * while a stale entry refreshes in the background, and only awaits the fetch
  * when nothing is known yet. An optional {@link CatalogPersistence} seeds the
  * last-known state across restarts and receives every successful fetch. A 401
- * during a fetch must call {@link invalidate}.
+ * that still fails after a forced token refresh must call {@link invalidate}.
  */
 export class ModelCatalogCache {
     persistence;
@@ -295,6 +299,14 @@ export class ModelCatalogCache {
             return undefined;
         return this.entry.models;
     }
+    /**
+     * The last successfully fetched catalog, ignoring TTL. Used to carry
+     * capability metadata forward when a later fetch cannot re-enrich.
+     * @returns the last-known models, or `undefined` when nothing has been stored.
+     */
+    lastKnown() {
+        return this.entry?.models;
+    }
     /** Load the persisted snapshot once; a fetch or invalidate that landed first wins. */
     ensureSeeded() {
         if (this.persistence === undefined)
@@ -363,3 +375,38 @@ export class ModelCatalogCache {
         void this.persistence?.clear().catch(() => undefined);
     }
 }
+/** Whether discovery failed because the stored login is gone. */
+export function isMissingOrInvalidCredential(error) {
+    return error instanceof LlmError
+        && (error.code === 'MISSING_CREDENTIAL' || error.code === 'INVALID_CREDENTIAL');
+}
+/** Whether discovery failed because the access token was rejected. */
+function isDiscoveryAuthFailure(error) {
+    return (error instanceof OAuthEndpointError && error.status === 401)
+        || (error instanceof LlmError && error.code === 'AUTH');
+}
+/**
+ * Run a catalog fetch, retrying once after a forced token refresh when the
+ * first attempt is a 401/AUTH. Only {@link ModelCatalogCache.invalidate}s
+ * when the retry is also an auth failure, so a refresh race cannot erase
+ * last-known capability metadata.
+ */
+export async function discoverOrRetryAuth(session, catalog, run) {
+    try {
+        return await run();
+    }
+    catch (error) {
+        if (isMissingOrInvalidCredential(error) || !isDiscoveryAuthFailure(error))
+            throw error;
+        try {
+            await session(true);
+            return await run();
+        }
+        catch (retryError) {
+            if (!isMissingOrInvalidCredential(retryError) && isDiscoveryAuthFailure(retryError)) {
+                catalog.invalidate();
+            }
+            throw retryError;
+        }
+    }
+}