@bitkyc08/opencodex 2.52.0-preview.20260911 → 2.52.0-preview.20260912

package/src/oauth/pool-kernel.ts

@@ -0,0 +1,321 @@
+import type { OcxAccountPoolRotationStrategy } from "../types";
+import type { GenerationContext } from "../lib/state-store-sweeper";
+
+export const POOL_KEY_CODEX = "codex";
+export const POOL_KEY_ANTHROPIC = "anthropic";
+
+/**
+ * Pool key for a generic OAuth provider. Namespaced so a provider can never collide
+ * with the two dedicated kinds, and so `reconcilePoolRotationState` can recognise
+ * the entry as sweepable rather than skipping it as unknown.
+ */
+export function genericPoolKey(providerName: string): string {
+  return `generic:${providerName}`;
+}
+
+interface SelectionState {
+  activeKey?: string;
+  successes: number;
+  currentWeights: Map<string, number>;
+}
+
+const selectionState = new Map<string, SelectionState>();
+let lastReconciledGeneration = 0;
+
+const DEFAULT_STICKY_LIMIT = 1;
+const MIN_STICKY_LIMIT = 1;
+const MAX_STICKY_LIMIT = 100;
+const DEFAULT_STRATEGY: OcxAccountPoolRotationStrategy = "quota";
+const VALID_STRATEGIES = new Set<OcxAccountPoolRotationStrategy>(["quota", "round-robin", "fill-first"]);
+
+/** Selection order for an account with no stored preference: one flat tier. */
+export const DEFAULT_ACCOUNT_PRIORITY = 0;
+export const MIN_ACCOUNT_PRIORITY = -100;
+export const MAX_ACCOUNT_PRIORITY = 100;
+
+/** Strict parse for management APIs — returns null instead of defaulting. */
+export function parseAccountPoolStrategy(raw: unknown): OcxAccountPoolRotationStrategy | null {
+  if (typeof raw === "string" && VALID_STRATEGIES.has(raw as OcxAccountPoolRotationStrategy)) {
+    return raw as OcxAccountPoolRotationStrategy;
+  }
+  return null;
+}
+
+/** Strict parse for management APIs — returns null instead of defaulting. */
+export function parseAccountPoolStickyLimit(raw: unknown): number | null {
+  if (typeof raw === "number" && Number.isInteger(raw) && raw >= MIN_STICKY_LIMIT && raw <= MAX_STICKY_LIMIT) {
+    return raw;
+  }
+  return null;
+}
+
+export function normalizeAccountPoolStrategy(raw: unknown): OcxAccountPoolRotationStrategy {
+  return parseAccountPoolStrategy(raw) ?? DEFAULT_STRATEGY;
+}
+
+export function normalizeAccountPoolStickyLimit(raw: unknown): number {
+  return parseAccountPoolStickyLimit(raw) ?? DEFAULT_STICKY_LIMIT;
+}
+
+/** Strict parse for management APIs — returns null instead of defaulting. */
+export function parseAccountPriority(raw: unknown): number | null {
+  if (
+    typeof raw === "number"
+    && Number.isInteger(raw)
+    && raw >= MIN_ACCOUNT_PRIORITY
+    && raw <= MAX_ACCOUNT_PRIORITY
+  ) {
+    return raw;
+  }
+  return null;
+}
+
+export function normalizeAccountPriority(raw: unknown): number {
+  return parseAccountPriority(raw) ?? DEFAULT_ACCOUNT_PRIORITY;
+}
+
+/**
+ * Narrow an already-eligible account list to the highest selection-order tier that
+ * still has usable quota. Priority is an *ordering* boundary layered on top of
+ * eligibility: it never admits an account the caller already filtered out, and it
+ * never keeps the pool on a tier whose every member is drained.
+ *
+ * Contract (each clause is load-bearing for "no behavior change when unconfigured"):
+ * - one distinct priority across `ids` (the unconfigured case) returns `ids` unchanged,
+ *   so today's pick sequence is preserved byte for byte;
+ * - input order is preserved inside the returned tier, which keeps the `__main__`
+ *   head-of-list bias and the first-index tie-break used by SWRR/lowest-usage;
+ * - every tier drained returns `ids` unchanged, reproducing today's
+ *   stay-put-until-429 behavior rather than inventing a pick;
+ * - a `pinnedId` that is present *and* has headroom lowers the ceiling to its own
+ *   tier, which is what makes a manual "use this now" survive round-robin and
+ *   fill-first without any mutable selection state. A drained or absent pin is
+ *   ignored, so the pin expires on its own once the account crosses the threshold.
+ */
+export function selectPriorityTier(
+  ids: readonly string[],
+  priorityOf: (id: string) => number,
+  hasHeadroom: (id: string) => boolean,
+  pinnedId?: string,
+): readonly string[] {
+  // Readonly out as well as in: the no-change cases return the caller's own array, so a
+  // mutating caller would corrupt its input in exactly the cases that must not change.
+  const list = ids;
+  if (list.length <= 1) return list;
+
+  const priorities = list.map(priorityOf);
+  const firstPriority = priorities[0]!;
+  if (priorities.every(priority => priority === firstPriority)) return list;
+
+  let ceiling = Number.POSITIVE_INFINITY;
+  if (pinnedId !== undefined) {
+    const pinnedIndex = list.indexOf(pinnedId);
+    if (pinnedIndex >= 0 && hasHeadroom(pinnedId)) ceiling = priorities[pinnedIndex]!;
+  }
+
+  const tiers = [...new Set(priorities)].sort((a, b) => b - a);
+  for (const tier of tiers) {
+    if (tier > ceiling) continue;
+    const members = list.filter((_, index) => priorities[index] === tier);
+    if (members.some(hasHeadroom)) return members;
+  }
+  return list;
+}
+
+function getOrCreateState(poolKey: string): SelectionState {
+  let state = selectionState.get(poolKey);
+  if (!state) {
+    state = { successes: 0, currentWeights: new Map() };
+    selectionState.set(poolKey, state);
+  }
+  return state;
+}
+
+function cloneSelectionState(state: SelectionState): SelectionState {
+  return {
+    activeKey: state.activeKey,
+    successes: state.successes,
+    currentWeights: new Map(state.currentWeights),
+  };
+}
+
+function smoothWeightedIndex(ids: readonly string[], state: SelectionState): number {
+  let best = -1;
+  let bestScore = Number.NEGATIVE_INFINITY;
+  let total = 0;
+  const weight = 1;
+  for (let i = 0; i < ids.length; i++) {
+    const id = ids[i]!;
+    const score = (state.currentWeights.get(id) ?? 0) + weight;
+    state.currentWeights.set(id, score);
+    total += weight;
+    if (score > bestScore) {
+      best = i;
+      bestScore = score;
+    }
+  }
+  if (best >= 0) {
+    const key = ids[best]!;
+    state.currentWeights.set(key, (state.currentWeights.get(key) ?? 0) - total);
+  }
+  return best;
+}
+
+/**
+ * Shared pick core. Mutates `state` the same way live resolve does; callers pass
+ * either the live map entry or a scratch/clone for dry-run peek.
+ */
+function pickRoundRobinFromState(
+  eligibleIds: readonly string[],
+  stickyLimit: number,
+  state: SelectionState,
+  commitSticky: boolean,
+): string | null {
+  if (eligibleIds.length === 0) return null;
+
+  const limit = normalizeAccountPoolStickyLimit(stickyLimit);
+
+  if (state.activeKey && eligibleIds.includes(state.activeKey)) {
+    return state.activeKey;
+  }
+
+  if (state.activeKey) {
+    delete state.activeKey;
+    state.successes = 0;
+  }
+
+  const index = smoothWeightedIndex(eligibleIds, state);
+  if (index < 0) return null;
+
+  const picked = eligibleIds[index]!;
+  if (commitSticky && limit > 1) {
+    state.activeKey = picked;
+    state.successes = 0;
+  }
+  return picked;
+}
+
+export function pickRoundRobinAccount(
+  poolKey: string,
+  eligibleIds: readonly string[],
+  stickyLimit: number,
+): string | null {
+  return pickRoundRobinFromState(eligibleIds, stickyLimit, getOrCreateState(poolKey), true);
+}
+
+/**
+ * Dry-run of {@link pickRoundRobinAccount}: returns the same account resolve would
+ * pick without advancing ring weights, activeKey, or successes.
+ */
+export function peekRoundRobinAccount(
+  poolKey: string,
+  eligibleIds: readonly string[],
+  stickyLimit: number,
+): string | null {
+  const live = selectionState.get(poolKey);
+  const scratch = live
+    ? cloneSelectionState(live)
+    : { successes: 0, currentWeights: new Map<string, number>() };
+  return pickRoundRobinFromState(eligibleIds, stickyLimit, scratch, false);
+}
+
+export function notePoolRotationSuccess(
+  poolKey: string,
+  accountId: string,
+  stickyLimit: number,
+): void {
+  const limit = normalizeAccountPoolStickyLimit(stickyLimit);
+  const state = selectionState.get(poolKey);
+  if (!state) return;
+  if (state.activeKey !== accountId) {
+    state.activeKey = accountId;
+    state.successes = 0;
+  }
+  state.successes += 1;
+  if (state.successes >= limit) {
+    delete state.activeKey;
+    state.successes = 0;
+  }
+}
+
+export function notePoolRotationFailure(poolKey: string, accountId: string): void {
+  const state = selectionState.get(poolKey);
+  if (state?.activeKey === accountId) {
+    delete state.activeKey;
+    state.successes = 0;
+  }
+}
+
+/**
+ * Force the next sticky/RR pick onto `accountId` (manual dashboard selection).
+ * Clears sticky success counters and ring weights so the seeded account is held
+ * for the next new-session pick before ordinary rotation resumes.
+ */
+export function seedPoolRotationAccount(poolKey: string, accountId: string): void {
+  const state = getOrCreateState(poolKey);
+  state.activeKey = accountId;
+  state.successes = 0;
+  state.currentWeights.clear();
+}
+
+export function clearPoolRotationState(poolKey?: string): void {
+  if (poolKey === undefined) {
+    selectionState.clear();
+    return;
+  }
+  selectionState.delete(poolKey);
+}
+
+export function reconcilePoolRotationState(context: GenerationContext): number {
+  if (context.generation <= lastReconciledGeneration) return 0;
+  const anthropicIds = new Set<string>();
+  // Live account ids per generic OAuth provider, built from the same
+  // `provider\0id` roster the Anthropic pass already walks. Without this the
+  // `generic:*` entries fall through as unknown and are never swept, so a removed
+  // account would keep its rotation weight forever.
+  const genericIds = new Map<string, Set<string>>();
+  for (const key of context.oauthAccountKeys) {
+    const separator = key.indexOf("\0");
+    if (separator <= 0) continue;
+    const provider = key.slice(0, separator);
+    const accountId = key.slice(separator + 1);
+    if (provider === "anthropic") {
+      anthropicIds.add(accountId);
+      continue;
+    }
+    let bucket = genericIds.get(provider);
+    if (!bucket) {
+      bucket = new Set<string>();
+      genericIds.set(provider, bucket);
+    }
+    bucket.add(accountId);
+  }
+  let removed = 0;
+  for (const [poolKey, state] of selectionState) {
+    const valid = poolKey === POOL_KEY_ANTHROPIC
+      ? anthropicIds
+      : poolKey === POOL_KEY_CODEX || poolKey.startsWith(`${POOL_KEY_CODEX}:`)
+        ? context.codexAccountIds
+        : poolKey.startsWith("generic:")
+          ? genericIds.get(poolKey.slice("generic:".length)) ?? new Set<string>()
+          : null;
+    if (!valid) continue;
+    if (valid.size === 0) {
+      selectionState.delete(poolKey);
+      removed += 1;
+      continue;
+    }
+    if (state.activeKey && !valid.has(state.activeKey)) {
+      delete state.activeKey;
+      state.successes = 0;
+      removed += 1;
+    }
+    for (const accountId of state.currentWeights.keys()) {
+      if (valid.has(accountId)) continue;
+      state.currentWeights.delete(accountId);
+      removed += 1;
+    }
+  }
+  lastReconciledGeneration = context.generation;
+  return removed;
+}

package/src/oauth/pool-settings-capability.ts

@@ -1,5 +1,6 @@
 import { isGenericFailoverProvider } from "./generic-account-failover";
-import type { OcxProviderConfig } from "../types";
+import { parseAccountPoolStickyLimit, parseAccountPoolStrategy } from "./pool-kernel";
+import type { OcxConfig, OcxProviderConfig } from "../types";
 
 /**
  * Which pool-settings contract a provider speaks (#695, slice 1).
@@ -28,33 +29,85 @@ export function poolSettingsCapability(name: string, provider: OcxProviderConfig
 }
 
 export function parseGenericPoolStrategy(value: unknown): GenericPoolStrategy | null {
-  return typeof value === "string" && (GENERIC_POOL_STRATEGIES as readonly string[]).includes(value)
-    ? value as GenericPoolStrategy
-    : null;
+  // Delegated, not re-implemented. Three pools accepting the same three names from three
+  // private copies of the same check is how they drift apart: the Codex and Anthropic kinds
+  // already shared this parser while the generic kind carried its own. The names and the
+  // 1..100 bound live in pool-kernel.ts, once.
+  return parseAccountPoolStrategy(value) as GenericPoolStrategy | null;
 }
 
 export function parseGenericAutoSwitchThreshold(value: unknown): number | null {
   return typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= 100 ? value : null;
 }
 
+export function parseGenericStickyLimit(value: unknown): number | null {
+  return parseAccountPoolStickyLimit(value);
+}
+
+/** Fields the unified pool-settings contract can carry, per kind. */
+export const POOL_SETTINGS_FIELDS = [
+  "enabled", "strategy", "stickyLimit", "autoSwitchThreshold", "quotaWindow",
+] as const;
+export type PoolSettingsField = typeof POOL_SETTINGS_FIELDS[number];
+
+/**
+ * One shape for all three pool kinds.
+ *
+ * `supported` is the reason this is a consolidation rather than a fourth contract: a field a
+ * kind does not honour is DECLARED unsupported instead of being omitted, so a dashboard can
+ * tell "this pool has no quotaWindow" from "this response forgot to send one". Every kind
+ * answers with the same keys.
+ */
+export interface PoolSettingsDto {
+  provider: string;
+  kind: PoolSettingsKind;
+  supported: PoolSettingsField[];
+  /** The STORED override. null means nothing is stored here, not "off". */
+  enabled: boolean | null;
+  /**
+   * What the runtime actually resolves for `enabled`, after the global default.
+   *
+   * The generic kind inherits `config.oauthAccountFailover.enabled` when it stores no override
+   * of its own, so `enabled: null` alone cannot distinguish a disabled pool from an inherited
+   * one. This resolves exactly that config question and nothing else -- deliberately NOT the
+   * roster quorum the dispatch predicate also applies, because a settings field that folded in
+   * "how many accounts are logged in" would be answering a different question than it asks.
+   */
+  enabledEffective: boolean;
+  strategy: string | null;
+  stickyLimit: number | null;
+  autoSwitchThreshold: number | null;
+  quotaWindow: string | null;
+}
+
+
 export interface GenericPoolSettingsDto {
   provider: string;
   kind: "generic";
   enabled: boolean | null;
   strategy: GenericPoolStrategy | null;
   autoSwitchThreshold: number | null;
+  stickyLimit: number | null;
   /**
-   * Slice-1 marker for `strategy` and `autoSwitchThreshold` only: persisted, not yet consumed
-   * by the selector.
+   * Marker for `strategy`, `autoSwitchThreshold` and `stickyLimit` only: true while they are
+   * persisted but not consumed by the selector, false once `pool.kernel` is on and they
+   * actually choose an account.
    *
    * It deliberately does NOT describe `enabled`, which governs the pre-dispatch preference.
    * Widening it to the whole DTO would tell a dashboard that `enabled` changes nothing, which
    * has been false since reactive and proactive activation were split.
+   *
+   * Computed, never a literal: the flag is reversible, so a DTO that hard-codes either answer
+   * would be lying in one of the two states.
    */
-  inert: true;
+  inert: boolean;
 }
 
-export function genericPoolSettingsDto(name: string, provider: OcxProviderConfig): GenericPoolSettingsDto {
+export function genericPoolSettingsDto(
+  name: string,
+  provider: OcxProviderConfig,
+  kernelEnabled = false,
+): GenericPoolSettingsDto {
   const failover = provider.oauthAccountFailover ?? {};
   return {
     provider: name,
@@ -62,6 +115,71 @@ export function genericPoolSettingsDto(name: string, provider: OcxProviderConfig
     enabled: typeof failover.enabled === "boolean" ? failover.enabled : null,
     strategy: parseGenericPoolStrategy(failover.strategy),
     autoSwitchThreshold: parseGenericAutoSwitchThreshold(failover.autoSwitchThreshold),
-    inert: true,
+    stickyLimit: parseGenericStickyLimit(failover.stickyLimit),
+    inert: kernelEnabled !== true,
   };
 }
+
+/** Which fields each kind actually honours. Declared, never silently omitted. */
+const SUPPORTED_BY_KIND: Record<PoolSettingsKind, PoolSettingsField[]> = {
+  codex: ["strategy", "stickyLimit", "autoSwitchThreshold"],
+  anthropic: ["enabled", "strategy", "stickyLimit", "autoSwitchThreshold", "quotaWindow"],
+  generic: ["enabled", "strategy", "stickyLimit", "autoSwitchThreshold"],
+};
+
+/**
+ * The one projection behind `/api/pool/settings`.
+ *
+ * Reads each kind's own storage -- this consolidates the CONTRACT, not the persistence -- and
+ * answers with identical keys plus a `supported` list, so an unsupported field is a declared
+ * `null` rather than an absence a caller has to guess about.
+ */
+export function unifiedPoolSettingsDto(
+  config: OcxConfig,
+  provider: string,
+  kind: PoolSettingsKind,
+): PoolSettingsDto {
+  const base = { provider, kind, supported: SUPPORTED_BY_KIND[kind] };
+  if (kind === "codex") {
+    return {
+      ...base,
+      // The Codex pool has no enablement switch: it is on whenever accounts exist, so the
+      // honest answer is "not a field here" rather than a fabricated true.
+      enabled: null,
+      enabledEffective: true,
+      strategy: parseGenericPoolStrategy(config.accountPoolStrategy) ?? "quota",
+      stickyLimit: parseGenericStickyLimit(config.accountPoolStickyLimit) ?? 1,
+      autoSwitchThreshold: parseGenericAutoSwitchThreshold(config.autoSwitchThreshold) ?? 80,
+      quotaWindow: null,
+    };
+  }
+  if (kind === "anthropic") {
+    const pool = config.anthropicAccountPool ?? {};
+    const enabled = typeof pool.enabled === "boolean" ? pool.enabled : null;
+    return {
+      ...base,
+      enabled,
+      enabledEffective: enabled === true,
+      strategy: parseGenericPoolStrategy(pool.strategy) ?? "quota",
+      stickyLimit: parseGenericStickyLimit(pool.stickyLimit) ?? 1,
+      autoSwitchThreshold: parseGenericAutoSwitchThreshold(pool.autoSwitchThreshold) ?? 80,
+      quotaWindow: typeof pool.quotaWindow === "string" ? pool.quotaWindow : "five-hour",
+    };
+  }
+  const failover = config.providers?.[provider]?.oauthAccountFailover ?? {};
+  const stored = typeof failover.enabled === "boolean" ? failover.enabled : null;
+  return {
+    ...base,
+    enabled: stored,
+    // The defect this field exists to close: a generic provider with no stored override
+    // inherits the global, so `enabled: null` alone cannot tell a disabled pool from an
+    // inherited one. Config only -- the roster quorum the dispatch predicate also applies is a
+    // different question and stays out of a settings field.
+    enabledEffective: stored ?? (config.oauthAccountFailover?.enabled === true),
+    strategy: parseGenericPoolStrategy(failover.strategy),
+    stickyLimit: parseGenericStickyLimit(failover.stickyLimit),
+    autoSwitchThreshold: parseGenericAutoSwitchThreshold(failover.autoSwitchThreshold),
+    quotaWindow: null,
+  };
+}
+

package/src/oauth/store.ts

@@ -29,6 +29,7 @@ import {
   type GenerationContext,
 } from "../lib/state-store-sweeper";
 import { validateCopilotApiBaseUrl } from "./github-copilot";
+import { validateDevinApiBaseUrl } from "./devin/api-base";
 import type { OAuthAccountSelection, OAuthCredentialSource, OAuthCredentials, ProviderAccount, ProviderAccountSet } from "./types";
 
 export type AuthStore = Record<string, ProviderAccountSet>;
@@ -459,9 +460,12 @@ function normalizeCredential(cred: unknown): OAuthCredentials | null {
   if (isCredentialSource(candidate.source)) normalized.source = candidate.source;
   if (typeof candidate.projectId === "string" && candidate.projectId.length > 0) normalized.projectId = candidate.projectId;
   if (typeof candidate.apiBaseUrl === "string" && candidate.apiBaseUrl.length > 0) {
-    // Persist only allowlisted Copilot origins; drop anything else so auth.json cannot
-    // become an SSRF springboard across reloads.
-    const validated = validateCopilotApiBaseUrl(candidate.apiBaseUrl);
+    // Persist only allowlisted origins; drop anything else so auth.json cannot
+    // become an SSRF springboard across reloads. Copilot and Devin are the two
+    // providers whose host comes back from the network, and each owns its own
+    // allowlist.
+    const validated =
+      validateCopilotApiBaseUrl(candidate.apiBaseUrl) ?? validateDevinApiBaseUrl(candidate.apiBaseUrl);
     if (validated) normalized.apiBaseUrl = validated;
   }
   if (candidate.kiro && typeof candidate.kiro === "object") {

package/src/oauth/token-guardian.ts

@@ -52,7 +52,7 @@ const DEFAULTS = {
   failureBackoffBaseSeconds: 300,
   failureBackoffMaxSeconds: 3600,
   codexWarmupMaxAgeSeconds: 691_200, // 8d — matches Codex managed-auth last_refresh cadence.
-  codexWarmupModel: "gpt-5.4-mini",
+  codexWarmupModel: "gpt-5.6-luna",
 };
 
 interface BackoffEntry {

package/src/providers/codebuddy-models.ts

@@ -35,7 +35,6 @@ export const CODEBUDDY_GLOBAL_MODELS = [
 /** China (`internal`) session models from the official internal manifest (text/chat models only). */
 export const CODEBUDDY_CN_MODELS = [
   "default",
-  "deepseek-v4-pro",
   "deepseek-v4-flash",
   "minimax-m3",
   "minimax-m2.7",
@@ -121,7 +120,6 @@ export const CODEBUDDY_GLOBAL_MODEL_DEFAULT_REASONING_EFFORTS: Record<string, st
 
 export const CODEBUDDY_CN_MODEL_CONTEXT_WINDOWS: Record<string, number> = {
   "default": 200_000,
-  "deepseek-v4-pro": 1_000_000,
   "deepseek-v4-flash": 1_000_000,
   "minimax-m3": 512_000,
   "minimax-m2.7": 200_000,
@@ -142,7 +140,6 @@ export const CODEBUDDY_CN_MODEL_CONTEXT_WINDOWS: Record<string, number> = {
 
 export const CODEBUDDY_CN_MODEL_MAX_OUTPUT_TOKENS: Record<string, number> = {
   "default": 24_000,
-  "deepseek-v4-pro": 50_000,
   "deepseek-v4-flash": 50_000,
   "minimax-m3": 128_000,
   "minimax-m2.7": 48_000,

package/src/providers/command-code-efforts.ts

@@ -1,10 +1,6 @@
 import { readBoundedResponseBody } from "../lib/bounded-body";
 
 const COMMAND_CODE_MODEL_EFFORTS = {
-  "deepseek/deepseek-v4-pro": {
-    efforts: ["high", "max"],
-    profileUrl: "https://commandcode.ai/models/deepseek-v4-pro",
-  },
   "deepseek/deepseek-v4-flash": {
     efforts: ["high", "max"],
     profileUrl: "https://commandcode.ai/models/deepseek-v4-flash",
@@ -130,6 +126,29 @@ const COMMAND_CODE_MODEL_EFFORTS = {
     efforts: ["low", "medium", "high", "xhigh", "max"],
     profileUrl: "https://commandcode.ai/models/meta-muse-spark-1.1",
   },
+  /*
+   * Two live routes that never gained a row here, so the adapter dropped every
+   * requested effort (a client's `max` left the wire as no reasoning parameter
+   * at all) and the preset advertised no effort control for them.
+   *
+   * PROVENANCE, stated plainly: both ladders are inferred from the same-family
+   * rows above — deepseek v4: high..max; the Qwen 3.8 family: low..max — NOT
+   * read from the profile pages. commandcode.ai renders those client-side and
+   * ships an empty reasoning payload, so the self-refresh below is as dead for
+   * these rows as the #2647 block above already documents. Measured live
+   * 2026-09-11: /alpha/generate accepts `reasoning_effort: "max"` on both
+   * routes (HTTP 200). `ultra` is deliberately not offered: the adapter would
+   * strip it, and no profile evidence backs an ultra→max alias the way it does
+   * for v4-pro/v4-flash above.
+   */
+  "deepseek/deepseek-v4.1-flash": {
+    efforts: ["high", "max"],
+    profileUrl: "https://commandcode.ai/models/deepseek-v4-1-flash",
+  },
+  "Qwen/Qwen3.8-Flash": {
+    efforts: ["low", "medium", "high", "max"],
+    profileUrl: "https://commandcode.ai/models/qwen3-8-flash",
+  },
 } as const;
 
 /**

package/src/providers/default-aliases.ts

@@ -51,7 +51,11 @@ export const DEFAULT_MODEL_ALIASES: ReadonlyArray<{ match: RegExp; alias: string
   { match: /^claude-haiku/, alias: "haiku" },
   { match: /^gemini-3(?:\.\d+)?-pro/, alias: "g3p" },
   { match: /^gemini-3(?:\.\d+)?-flash/, alias: "g3f" },
+  // Ordered before the V4 rule on purpose: `builtinRule` takes the first match, and
+  // `/^deepseek-v4/` also matches `deepseek-v4.1-flash`.
+  { match: /^deepseek-v4\.1/, alias: "ds41" },
   { match: /^deepseek-v4/, alias: "ds4" },
+  { match: /^deepseek-flash/, alias: "dsf" },
   { match: /^grok-4/, alias: "grok" },
 ];
 

package/src/providers/derive.ts

@@ -16,6 +16,7 @@ export interface DerivedKeyLoginProvider {
   label: string;
   baseUrl: string;
   responsesPath?: string;
+  chatCompletionsPath?: string;
   adapter: string;
   apiKeyValidation?: "unknown";
   apiKeyTransport?: OcxProviderConfig["apiKeyTransport"];
@@ -71,6 +72,7 @@ export interface DerivedProviderPreset {
   adapter: string;
   baseUrl: string;
   responsesPath?: string;
+  chatCompletionsPath?: string;
   defaultModel?: string;
   auth: "oauth" | "forward" | "key" | "local";
   codexAccountMode?: CodexAccountMode;
@@ -222,6 +224,7 @@ export function providerConfigSeed(entry: ProviderRegistryEntry): OcxProviderCon
     baseUrl: entry.baseUrl,
     ...(entry.apiKeyTransport !== undefined ? { apiKeyTransport: entry.apiKeyTransport } : {}),
     ...(entry.responsesPath ? { responsesPath: entry.responsesPath } : {}),
+    ...(entry.chatCompletionsPath ? { chatCompletionsPath: entry.chatCompletionsPath } : {}),
     ...(entry.alias ? { alias: entry.alias } : {}),
     // Preserve the registry auth kind verbatim (including "local") so fail-closed gates that
     // distinguish local runtimes from API-key providers keep working after the seed round-trip.
@@ -257,6 +260,7 @@ export function providerConfigSeed(entry: ProviderRegistryEntry): OcxProviderCon
     ...(entry.chatServiceTier !== undefined ? { chatServiceTier: entry.chatServiceTier } : {}),
     ...(entry.openaiChatEofTolerance !== undefined ? { openaiChatEofTolerance: entry.openaiChatEofTolerance } : {}),
     ...(entry.responsesPath !== undefined ? { responsesPath: entry.responsesPath } : {}),
+    ...(entry.chatCompletionsPath !== undefined ? { chatCompletionsPath: entry.chatCompletionsPath } : {}),
     ...(entry.statelessResponses !== undefined ? { statelessResponses: entry.statelessResponses } : {}),
     ...(entry.requiresAdjacentResponsesToolResults !== undefined
       ? { requiresAdjacentResponsesToolResults: entry.requiresAdjacentResponsesToolResults }
@@ -288,6 +292,7 @@ export function deriveKeyLoginMap(): Record<string, DerivedKeyLoginProvider> {
       label: entry.label,
       baseUrl: entry.baseUrl,
       ...(entry.responsesPath ? { responsesPath: entry.responsesPath } : {}),
+      ...(entry.chatCompletionsPath ? { chatCompletionsPath: entry.chatCompletionsPath } : {}),
       adapter: entry.adapter,
       ...(entry.apiKeyValidation !== undefined ? { apiKeyValidation: entry.apiKeyValidation } : {}),
       ...(entry.apiKeyTransport !== undefined ? { apiKeyTransport: entry.apiKeyTransport } : {}),
@@ -478,6 +483,7 @@ export function enrichProviderFromRegistry(name: string, prov: OcxProviderConfig
   if (prov.apiKeyTransport === undefined && seed.apiKeyTransport !== undefined) prov.apiKeyTransport = seed.apiKeyTransport;
   if (!prov.defaultModel && seed.defaultModel) prov.defaultModel = seed.defaultModel;
   if (prov.responsesPath === undefined && seed.responsesPath !== undefined) prov.responsesPath = seed.responsesPath;
+  if (prov.chatCompletionsPath === undefined && seed.chatCompletionsPath !== undefined) prov.chatCompletionsPath = seed.chatCompletionsPath;
   // Fill mode only when absent: an explicit persisted `direct` must never be overwritten.
   if (prov.codexAccountMode === undefined && seed.codexAccountMode !== undefined) prov.codexAccountMode = seed.codexAccountMode;
   if (!prov.models && seed.models) prov.models = [...seed.models];
@@ -521,6 +527,7 @@ export function enrichProviderFromRegistry(name: string, prov: OcxProviderConfig
   // Fill-only: a hand-edited path must survive, and a config saved before the registry
   // learned this route still gets backfilled.
   if (prov.responsesPath === undefined && seed.responsesPath !== undefined) prov.responsesPath = seed.responsesPath;
+  if (prov.chatCompletionsPath === undefined && seed.chatCompletionsPath !== undefined) prov.chatCompletionsPath = seed.chatCompletionsPath;
   if (prov.statelessResponses === undefined && seed.statelessResponses !== undefined) prov.statelessResponses = seed.statelessResponses;
   if (prov.requiresAdjacentResponsesToolResults === undefined && seed.requiresAdjacentResponsesToolResults !== undefined) {
     prov.requiresAdjacentResponsesToolResults = seed.requiresAdjacentResponsesToolResults;
@@ -602,6 +609,7 @@ function entryToPreset(entry: ProviderRegistryEntry): DerivedProviderPreset {
     adapter: entry.adapter,
     baseUrl: entry.baseUrl,
     ...(entry.responsesPath ? { responsesPath: entry.responsesPath } : {}),
+    ...(entry.chatCompletionsPath ? { chatCompletionsPath: entry.chatCompletionsPath } : {}),
     auth: entry.authKind === "forward" ? "forward" : entry.authKind === "oauth" ? "oauth" : entry.authKind === "local" ? "local" : "key",
     ...(entry.codexAccountMode ? { codexAccountMode: entry.codexAccountMode } : {}),
     ...(entry.codexAccountMode ? { provider: providerConfigSeed(entry) } : {}),