mixdog 1.0.8 → 1.0.10

package/src/runtime/agent/orchestrator/providers/client-version-store.mjs

@@ -0,0 +1,50 @@
+// Last live client version each provider saw, kept on disk under one key per
+// client. A new or offline process starts from the newest version this machine
+// has observed instead of a floor that only moves with a release. Skipped
+// entirely when MIXDOG_DISABLE_LIVE_CLI_VERSIONS=1.
+
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { updateJsonAtomicSync } from '../../../shared/atomic-file.mjs';
+import { resolvePluginData } from '../../../shared/plugin-paths.mjs';
+
+const LAST_KNOWN_FILE_NAME = 'client-versions.json';
+const LAST_KNOWN_SCHEMA_VERSION = 1;
+const LAST_KNOWN_VALUE = /^[\w.+-]{1,64}$/;
+
+const liveLookupDisabled = () => process.env.MIXDOG_DISABLE_LIVE_CLI_VERSIONS === '1';
+const lastKnownPath = () => join(resolvePluginData(), LAST_KNOWN_FILE_NAME);
+
+/** The last live version remembered under `key`, or null. */
+export function readLastKnownVersion(key) {
+  if (!key || liveLookupDisabled()) return null;
+  try {
+    const raw = JSON.parse(readFileSync(lastKnownPath(), 'utf-8'));
+    if (raw?.version !== LAST_KNOWN_SCHEMA_VERSION) return null;
+    const value = raw.entries?.[key]?.value;
+    return typeof value === 'string' && LAST_KNOWN_VALUE.test(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Remember a live version; `null` forgets it. Best-effort: never throws. */
+export function rememberLastKnownVersion(key, value) {
+  if (!key || liveLookupDisabled()) return;
+  if (value != null && !LAST_KNOWN_VALUE.test(String(value))) return;
+  try {
+    updateJsonAtomicSync(
+      lastKnownPath(),
+      (current) => {
+        const entries = current?.version === LAST_KNOWN_SCHEMA_VERSION ? { ...current.entries } : {};
+        if ((entries[key]?.value ?? null) === value) return undefined;
+        if (value == null) delete entries[key];
+        else entries[key] = { value, fetchedAt: Date.now() };
+        return { version: LAST_KNOWN_SCHEMA_VERSION, entries };
+      },
+      { lock: true }
+    );
+  } catch {
+    /* a read-only data directory must not break the lookup */
+  }
+}

package/src/runtime/agent/orchestrator/providers/codex-client-meta.mjs

@@ -12,13 +12,16 @@
  * cache-node routing, so mixdog mirrors both.
  */
 import os from 'node:os';
+import { readLastKnownVersion, rememberLastKnownVersion } from './client-version-store.mjs';
 
-// Offline fallback only; live value refreshes from npm (24h TTL, in-process).
+// Offline fallback only; live value refreshes from npm (24h TTL) and the last
+// live answer is kept on disk, so the floor is only a first-run default.
 // The backend gates model exposure AND per-request model access on the client
 // version (gpt-6-sol/luna require >= 0.155.0 per the published model catalog,
 // verified 2026-09-22), so keep this at the current release when bumping.
 const CODEX_CLIENT_VERSION_FLOOR = '0.155.1';
 const VERSION_TTL_MS = 24 * 60 * 60_000;
+const LAST_KNOWN_KEY = 'codex-cli';
 let _cache = { value: null, fetchedAt: 0 };
 let _refreshInFlight = null;
 
@@ -32,14 +35,16 @@ async function _refresh() {
       const v = String(j?.version || '').trim();
       if (/^\d+\.\d+\.\d+/.test(v)) {
         _cache = { value: v, fetchedAt: Date.now() };
+        rememberLastKnownVersion(LAST_KNOWN_KEY, v);
         return v;
       }
     }
   } catch {
     /* offline — keep floor */
   }
-  _cache = { value: CODEX_CLIENT_VERSION_FLOOR, fetchedAt: Date.now() };
-  return CODEX_CLIENT_VERSION_FLOOR;
+  const fallback = _offlineVersion();
+  _cache = { value: fallback, fetchedAt: Date.now() };
+  return fallback;
 }
 
 /**
@@ -50,7 +55,25 @@ async function _refresh() {
 function codexClientVersionSync() {
   if (_cacheFresh()) return _cache.value;
   _ensureRefresh();
-  return _cache.value || CODEX_CLIENT_VERSION_FLOOR;
+  return _cache.value || _offlineVersion();
+}
+
+// The newest version this machine has seen, never below the shipped floor.
+function _offlineVersion() {
+  const lastKnown = readLastKnownVersion(LAST_KNOWN_KEY);
+  const newer = lastKnown && _compareVersion(lastKnown, CODEX_CLIENT_VERSION_FLOOR) > 0;
+  return newer ? lastKnown : CODEX_CLIENT_VERSION_FLOOR;
+}
+
+// Numeric x.y.z order; a pre-release suffix on the patch part is ignored.
+function _compareVersion(a, b) {
+  const parts = (version) => String(version).split('.').map((part) => Number.parseInt(part, 10) || 0);
+  const [pa, pb] = [parts(a), parts(b)];
+  for (let i = 0; i < 3; i += 1) {
+    const delta = (pa[i] || 0) - (pb[i] || 0);
+    if (delta) return delta;
+  }
+  return 0;
 }
 
 function _cacheFresh() {

package/src/runtime/agent/orchestrator/providers/cursor-client-version.mjs

@@ -4,13 +4,17 @@ import { createRemoteVersionSource } from './npm-cli-version.mjs';
 // documented version endpoint; the official installer script embeds the
 // current build (…/lab/<build>/…), parsed best-effort. Any format change or
 // failure falls back to the floor.
-export const CURSOR_CLIENT_VERSION_FLOOR = 'cli-2026.08.11-e8db854';
+export const CURSOR_CLIENT_VERSION_FLOOR = 'cli-2026.10.01-e373342';
 const BUILD_PATTERN = /downloads\.cursor\.com\/lab\/(\d{4}\.\d{2}\.\d{2}-[0-9a-f]{6,40})\//;
 
-const live = createRemoteVersionSource('https://cursor.com/install', async (res) => {
-  const match = (await res.text()).match(BUILD_PATTERN);
-  return match ? `cli-${match[1]}` : null;
-});
+const live = createRemoteVersionSource(
+  'https://cursor.com/install',
+  async (res) => {
+    const match = (await res.text()).match(BUILD_PATTERN);
+    return match ? `cli-${match[1]}` : null;
+  },
+  { persistKey: 'cursor-cli' }
+);
 let envVersion;
 
 function envOverride() {

package/src/runtime/agent/orchestrator/providers/custom-provider.mjs

@@ -0,0 +1,163 @@
+// User-defined ("custom") providers. A custom provider is stored as a
+// secret-free config entry keyed by a generated `custom-<uuid>` id; the API key
+// lives in the keychain under that same id and is injected at load time. The
+// runtime reuses the existing OpenAI-compat / Anthropic engines, constructed
+// under the custom id so model routes and provider identity stay `custom-…`.
+
+import { ANTHROPIC_VERSION } from './lib/anthropic-models.mjs';
+import { assertSafeBaseURL } from './provider-base-url.mjs';
+import { listCompatModels } from './openai-compat-models.mjs';
+
+export const CUSTOM_PROVIDER_PROTOCOLS = Object.freeze(['openai-chat', 'openai-responses', 'anthropic']);
+
+function fail(message) {
+  throw new Error(`[custom-provider] ${message}`);
+}
+
+function text(value) {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+function positiveInt(value, label) {
+  if (value === undefined || value === null || value === '') return undefined;
+  const n = Number(value);
+  if (!Number.isInteger(n) || n <= 0) fail(`${label} must be a positive integer`);
+  return n;
+}
+
+function normalizeBaseURL(raw) {
+  const value = text(raw);
+  if (!value) fail('baseURL is required');
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    fail(`invalid baseURL: ${value}`);
+  }
+  if (url.protocol !== 'https:' && url.protocol !== 'http:') fail('baseURL must use http or https');
+  if (url.username || url.password) fail('baseURL must not embed credentials');
+  if (url.search || url.hash || /[?#]/.test(value)) fail('baseURL must not contain a query or hash');
+  return assertSafeBaseURL(value.replace(/\/+$/, ''), 'custom');
+}
+
+function normalizeModels(raw, requireModels) {
+  if (raw === undefined || raw === null) raw = [];
+  if (!Array.isArray(raw)) fail('models must be an array');
+  const seen = new Set();
+  const models = raw.map((entry) => {
+    const id = text(entry?.id);
+    if (!id) fail('every model needs an id');
+    if (seen.has(id)) fail(`duplicate model id: ${id}`);
+    seen.add(id);
+    const name = text(entry.name);
+    const contextWindow = positiveInt(entry.contextWindow, `model ${id} contextWindow`);
+    const maxOutputTokens = positiveInt(entry.maxOutputTokens, `model ${id} maxOutputTokens`);
+    return {
+      id,
+      ...(name ? { name } : {}),
+      ...(contextWindow ? { contextWindow } : {}),
+      ...(maxOutputTokens ? { maxOutputTokens } : {}),
+    };
+  });
+  if (requireModels && models.length === 0) fail('at least one model is required');
+  return models;
+}
+
+export function normalizeCustomProviderConfig(input, { requireModels = true } = {}) {
+  if (!input || typeof input !== 'object') fail('config must be an object');
+  const name = text(input.name);
+  if (!name) fail('name is required');
+  const protocol = text(input.protocol);
+  if (!protocol) fail('protocol is required');
+  if (!CUSTOM_PROVIDER_PROTOCOLS.includes(protocol)) fail(`unsupported protocol: ${protocol}`);
+  return {
+    type: 'custom',
+    name,
+    protocol,
+    baseURL: normalizeBaseURL(input.baseURL),
+    models: normalizeModels(input.models, requireModels),
+    enabled: true,
+  };
+}
+
+function modelRow(id, m) {
+  return {
+    id: m.id,
+    name: m.name || m.id,
+    provider: id,
+    contextWindow: m.contextWindow || 0,
+    outputTokens: m.maxOutputTokens || null,
+  };
+}
+
+// Configured models win; an empty list falls back to protocol discovery.
+function withConfiguredModels(Base, discover) {
+  return class extends Base {
+    _customModels = [];
+    async listModels() {
+      if (!this._customModels.length) return discover(this);
+      if ('_enrichedModels' in this) this._enrichedModels = this._customModels;
+      return this._customModels.map((m) => ({ ...m }));
+    }
+    async isAvailable() {
+      return this._customModels.length ? true : super.isAvailable();
+    }
+    getCachedModelInfo(model) {
+      return this._customModels.find((m) => m.id === model) || super.getCachedModelInfo?.(model) || null;
+    }
+  };
+}
+
+async function discoverAnthropicModels(provider) {
+  const res = await fetch(`${provider.config.baseURL}/v1/models`, {
+    method: 'GET',
+    signal: AbortSignal.timeout(10_000),
+    headers: { 'x-api-key': provider.apiKey || '', 'anthropic-version': ANTHROPIC_VERSION },
+  });
+  if (!res.ok) throw new Error(`${provider.name} models ${res.status}`);
+  const data = await res.json();
+  const items = Array.isArray(data?.data) ? data.data : [];
+  return items
+    .filter((m) => m?.id)
+    .map((m) => ({
+      id: m.id,
+      name: m.display_name || m.id,
+      provider: provider.name,
+      contextWindow: Number(m.max_input_tokens) > 0 ? Number(m.max_input_tokens) : 0,
+      outputTokens: Number(m.max_tokens) > 0 ? Number(m.max_tokens) : null,
+    }));
+}
+
+export async function createCustomProvider(id, config) {
+  const providerId = text(id);
+  if (!/^custom-.+/.test(providerId)) fail(`invalid custom provider id: ${id}`);
+  const cfg = normalizeCustomProviderConfig(config, { requireModels: false });
+  const engine = {
+    baseURL: cfg.baseURL,
+    apiKey: config.apiKey || undefined,
+    ...(config.preconnect === false ? { preconnect: false } : {}),
+  };
+  let provider;
+  if (cfg.protocol === 'anthropic') {
+    const { AnthropicProvider } = await import('./anthropic.mjs');
+    const Custom = withConfiguredModels(AnthropicProvider, discoverAnthropicModels);
+    // The Anthropic SDK appends /v1/messages itself; accept a /v1 base URL.
+    provider = new Custom({ ...engine, name: providerId, baseURL: cfg.baseURL.replace(/\/v1$/i, '') });
+  } else {
+    const { OpenAICompatProvider } = await import('./openai-compat.mjs');
+    const Base =
+      cfg.protocol === 'openai-responses'
+        ? class extends OpenAICompatProvider {
+            _doSend(messages, model, tools, sendOpts) {
+              return super._doSend(messages, model, tools, { ...(sendOpts || {}), compatWireApi: 'responses' });
+            }
+          }
+        : OpenAICompatProvider;
+    const Custom = withConfiguredModels(Base, (self) => listCompatModels(self, { throwOnError: true }));
+    provider = new Custom(providerId, engine);
+    if (cfg.models.length) provider.defaultModel = cfg.models[0].id;
+  }
+  provider._customModels = cfg.models.map((m) => modelRow(providerId, m));
+  provider.customConfig = cfg;
+  return provider;
+}

package/src/runtime/agent/orchestrator/providers/effort-configuration.mjs

@@ -1,10 +1,19 @@
 import { normalizeAnthropicEffortInput } from './anthropic-effort.mjs';
+import { codexModelSupportsEffortUpdates } from './openai-oauth-catalog.mjs';
 
 export const EFFORT_CONFIGURATION_BETA = 'mid-conversation-output-config-2026-07-01';
-const ANTHROPIC_MODELS = new Set(['claude-fable-5-1', 'claude-mythos-5-1', 'claude-opus-5', 'claude-opus-5-5']);
+const ANTHROPIC_MODELS = new Set([
+  'claude-fable-5-1',
+  'claude-mythos-5-1',
+  'claude-opus-5',
+  'claude-opus-5-5',
+  'claude-sonnet-5-5',
+]);
 // https://developers.openai.com/api/docs/guides/reasoning#change-reasoning-mid-conversation
-// — the GPT-6 model family, standard single-agent mode.
-const OPENAI_MODELS = new Set(['gpt-6-astra', 'gpt-6-sol', 'gpt-6-luna']);
+// — the GPT-6 model family, standard single-agent mode. The public API
+// publishes no per-model flag, so this list is its whole answer; the OAuth
+// backend's catalog carries one and only falls back here without it.
+const OPENAI_MODELS = new Set(['gpt-6-astra', 'gpt-6-sol', 'gpt-6-luna', 'gpt-6-1-sol']);
 const OPENAI_PROVIDERS = new Set(['openai', 'openai-oauth']);
 const ANTHROPIC_PROVIDERS = new Set(['anthropic', 'anthropic-oauth']);
 const EFFORTS = new Set(['minimal', 'low', 'medium', 'high', 'xhigh', 'max']);
@@ -35,11 +44,16 @@ function modelKey(model) {
     .replace(/\./g, '-');
 }
 
+function openAiSupportsEffortUpdates(provider, model, id) {
+  const declared = provider === 'openai-oauth' ? codexModelSupportsEffortUpdates(String(model || '').trim()) : null;
+  return declared ?? OPENAI_MODELS.has(id);
+}
+
 // Explicit protocol capabilities, not a prediction about future model families.
 export function effortConfigurationMode(provider, model, opts = {}) {
   const id = modelKey(model);
   if (opts.effortConfigurationEnabled === false || Number(opts.thinkingBudgetTokens) > 0) return null;
-  if (OPENAI_PROVIDERS.has(provider) && OPENAI_MODELS.has(id)) {
+  if (OPENAI_PROVIDERS.has(provider) && openAiSupportsEffortUpdates(provider, model, id)) {
     const parameters = opts.modelParameters || {};
     const mode = opts.reasoning?.mode ?? parameters.reasoning_mode ?? parameters.mode ?? 'standard';
     if (mode !== 'standard' || opts.multiAgent === true || parameters.multi_agent === true) return null;

package/src/runtime/agent/orchestrator/providers/grok-client-version.mjs

@@ -3,9 +3,9 @@ import { createNpmVersionSource, maxSemver } from './npm-cli-version.mjs';
 // Grok CLI client version for the cli-chat-proxy version gate (HTTP 426).
 // Effective = env override, else max(floor, learned-from-426, live npm latest
 // of the official @xai-official/grok CLI).
-export const GROK_CLI_VERSION_FLOOR = '0.2.87';
+export const GROK_CLI_VERSION_FLOOR = '1.0.46';
 
-const live = createNpmVersionSource('@xai-official/grok');
+const live = createNpmVersionSource('@xai-official/grok', { persistKey: 'grok-cli' });
 let envVersion;
 let learned = null;
 

package/src/runtime/agent/orchestrator/providers/lib/anthropic-models.mjs

@@ -3,6 +3,12 @@
 export const MODELS = [
   { id: 'claude-opus-5-5', name: 'Claude Opus 5.5', provider: 'anthropic', family: 'opus', contextWindow: 1000000 },
   { id: 'claude-fable-5-1', name: 'Claude Fable 5.1', provider: 'anthropic', family: 'fable', contextWindow: 1000000 },
-  { id: 'claude-sonnet-5', name: 'Claude Sonnet 5', provider: 'anthropic', family: 'sonnet', contextWindow: 1000000 },
+  {
+    id: 'claude-sonnet-5-5',
+    name: 'Claude Sonnet 5.5',
+    provider: 'anthropic',
+    family: 'sonnet',
+    contextWindow: 1000000,
+  },
 ];
 export const ANTHROPIC_VERSION = '2023-06-01';

package/src/runtime/agent/orchestrator/providers/model-list-sanitize.mjs

@@ -11,6 +11,7 @@
 // a filtered + deduped subset of the SAME row objects (never mutated).
 
 import { getModelsDevProviderModelsSync, getModelsDevRowSync } from './model-catalog.mjs';
+import { isRollingModelAlias } from '../../../shared/model-alias.mjs';
 
 // Id-level fallback for coding-unfit SKUs when the catalog row is missing.
 // search-preview (grounded-search) and audio/realtime preview SKUs are
@@ -213,6 +214,14 @@ function _stalenessFamily(row, id) {
   return family || null;
 }
 
+// Explicit preview/experimental markers in the id. A stable
+// model is not superseded by these; the catalog carries no structured status.
+const PREVIEW_VARIANT_RE = /(^|[-_.:/\s])(preview|exp|experimental)([-_.:/\s]|$)/i;
+
+function _isPreviewVariant(id) {
+  return PREVIEW_VARIANT_RE.test(String(id || ''));
+}
+
 function _staleMonths() {
   const raw = process.env.MIXDOG_MODEL_STALE_MONTHS;
   if (raw == null || raw === '') return 9;
@@ -246,19 +255,28 @@ function _applyAutoStaleness(kept, provider, testCatalog) {
   // ANY model (kept or not) in the same family with a strictly newer date.
   // Compute the newest release_date per family from the FULL catalog so a
   // superseding model that isn't in this list still counts.
+  // Rolling aliases never count. Preview/experimental entries count only
+  // against other preview/experimental rows, never against a stable one.
   const familyNewest = new Map();
+  const familyNewestStable = new Map();
+  const bump = (map, fam, ep) => {
+    const prev = map.get(fam);
+    if (prev == null || ep > prev) map.set(fam, ep);
+  };
   for (const [id, cr] of Object.entries(catModels)) {
     const fam = _stalenessFamily(cr, id);
     const ep = _releaseEpoch(cr);
-    if (!fam || ep == null) continue;
-    const prev = familyNewest.get(fam);
-    if (prev == null || ep > prev) familyNewest.set(fam, ep);
+    if (!fam || ep == null || isRollingModelAlias(id)) continue;
+    bump(familyNewest, fam, ep);
+    if (!_isPreviewVariant(id)) bump(familyNewestStable, fam, ep);
   }
 
   const dropped = new Set();
   for (const m of meta) {
     if (!m.cat || m.family == null || m.epoch == null) continue; // fallback: keep
-    const newest = familyNewest.get(m.family);
+    if (isRollingModelAlias(m.row.id)) continue;
+    const newestByFamily = _isPreviewVariant(m.row.id) ? familyNewest : familyNewestStable;
+    const newest = newestByFamily.get(m.family);
     if (newest != null && newest > m.epoch) dropped.add(m.row);
   }
   // Never empty a family the user relies on: if supersession removed every
@@ -286,6 +304,7 @@ function _applyAutoStaleness(kept, provider, testCatalog) {
     for (const m of meta) {
       if (dropped.has(m.row)) continue;
       if (!m.cat || m.epoch == null) continue; // fallback: keep
+      if (isRollingModelAlias(m.row.id)) continue;
       if (m.epoch < cutoff) cutDropped.add(m.row);
     }
     // If applying the absolute cut would empty the entire provider list, skip

package/src/runtime/agent/orchestrator/providers/npm-cli-version.mjs

@@ -3,6 +3,12 @@
 // Sync accessor never blocks (kicks a background refresh); warm() is the
 // awaitable cold-start path. Failures resolve to null so callers fall back to
 // their floor. MIXDOG_DISABLE_LIVE_CLI_VERSIONS=1 turns the lookup off.
+//
+// A source given a `persistKey` also remembers its last live answer on disk,
+// so a new process (or an offline one) starts from the newest version this
+// machine has seen rather than from a floor that only moves with a release.
+
+import { readLastKnownVersion, rememberLastKnownVersion } from './client-version-store.mjs';
 
 const SEMVER = /^\d+\.\d+\.\d+$/;
 const DEFAULT_TTL_MS = 24 * 60 * 60_000;
@@ -43,10 +49,22 @@ export function createNpmVersionSource(pkg, options) {
  * Generic source: GET `url`, `parse(res)` returns the version string or null
  * (unrecognised format). Same TTL/in-flight/timeout/disable rules as npm.
  */
-export function createRemoteVersionSource(url, parse, { ttlMs = DEFAULT_TTL_MS, timeoutMs = TIMEOUT_MS } = {}) {
+export function createRemoteVersionSource(
+  url,
+  parse,
+  { ttlMs = DEFAULT_TTL_MS, timeoutMs = TIMEOUT_MS, persistKey = null } = {}
+) {
   let value = null;
   let expiresAt = 0;
   let inFlight = null;
+  let lastKnownLoaded = false;
+
+  // Stale on purpose: it answers until the refresh lands, never instead of it.
+  function loadLastKnown() {
+    if (lastKnownLoaded) return;
+    lastKnownLoaded = true;
+    if (!value) value = readLastKnownVersion(persistKey);
+  }
 
   async function refresh() {
     let next = null;
@@ -56,7 +74,10 @@ export function createRemoteVersionSource(url, parse, { ttlMs = DEFAULT_TTL_MS,
     } catch {
       /* offline or slow — keep previous/floor */
     }
-    if (next) value = next;
+    if (next) {
+      value = next;
+      rememberLastKnownVersion(persistKey, next);
+    }
     expiresAt = Date.now() + (next ? ttlMs : FAILURE_TTL_MS);
     return value;
   }
@@ -76,11 +97,13 @@ export function createRemoteVersionSource(url, parse, { ttlMs = DEFAULT_TTL_MS,
   return {
     /** Cached live version or null; refreshes in the background when stale. */
     sync() {
+      loadLastKnown();
       if (!fresh()) ensureRefresh();
       return value;
     },
     /** Awaitable, never rejects; bounded by the fetch timeout. */
     warm() {
+      loadLastKnown();
       return fresh() ? Promise.resolve(value) : ensureRefresh();
     },
   };

package/src/runtime/agent/orchestrator/providers/oauth-credential-probes.mjs

@@ -154,7 +154,13 @@ function openAIOAuthState() {
 }
 
 function grokOAuthState() {
-  const paths = [process.env.GROK_OAUTH_CREDENTIALS_PATH, join(resolvePluginData(), 'grok-oauth.json')];
+  // Same account/path precedence as the token store (getOwnTokenPath): a login
+  // lands in the selected account's pool file, never the legacy root file.
+  const paths = [
+    boundProviderAuthPath('grok-oauth') ||
+      process.env.GROK_OAUTH_CREDENTIALS_PATH ||
+      join(resolvePluginData(), 'grok-oauth.json'),
+  ];
   return memoProbe('grok-oauth', paths, () =>
     resolveProbeState(paths, (docs) => docs.some((own) => !!(own?.access_token && own?.refresh_token)))
   );

package/src/runtime/agent/orchestrator/providers/openai-codex-model.mjs

@@ -86,6 +86,10 @@ export function _normalizeCodexModel(m) {
     supportVerbosity: m?.support_verbosity === true,
     defaultVerbosity: m?.default_verbosity || null,
     supportsReasoningSummaries: m?.supports_reasoning_summaries === true,
+    // Absent on an older catalog: the caller then falls back to its own list.
+    ...(typeof m?.supports_reasoning_effort_updates === 'boolean'
+      ? { supportsReasoningEffortUpdates: m.supports_reasoning_effort_updates }
+      : {}),
     ...(typeof m?.supports_image_generation === 'boolean'
       ? { supportsImageGeneration: m.supports_image_generation }
       : {}),

package/src/runtime/agent/orchestrator/providers/openai-compat-models.mjs

@@ -28,7 +28,7 @@ export async function fetchCompatModelItems(provider) {
   }
 }
 
-export async function listCompatModels(provider) {
+export async function listCompatModels(provider, { throwOnError = false } = {}) {
   try {
     const list = await provider._fetchModelItems();
     const models = [];
@@ -56,7 +56,8 @@ export async function listCompatModels(provider) {
     const enriched = sanitizeModelList(await enrichModels(filtered), { provider: provider.name });
     provider._enrichedModels = enriched;
     return enriched;
-  } catch {
+  } catch (error) {
+    if (throwOnError) throw error;
     return [];
   }
 }

package/src/runtime/agent/orchestrator/providers/openai-compat-xai.mjs

@@ -14,6 +14,7 @@ import { appendAgentTrace } from '../agent-trace.mjs';
 import { resolveProviderCacheKey, resolveProviderPromptCacheLane } from '../agent-runtime/cache-strategy.mjs';
 import { shouldFallbackTransport } from './retry-classifier.mjs';
 import { envFlag as _envFlag } from '../../../shared/env.mjs';
+import { getModelsDevRowSync } from '../../../shared/llm/model-catalog.mjs';
 import {
   traceHash,
   stableTraceStringify,
@@ -161,6 +162,13 @@ export function xaiModelSupportsReasoningEffort(model) {
     .toLowerCase();
   if (!id) return true;
   if (!id.startsWith('grok')) return true;
+  // The catalog answers first: a listed model takes the parameter exactly
+  // when it publishes effort values (grok-4.3 does, grok-4.20-*-reasoning
+  // does not), so a new release needs no edit here.
+  const listed = getModelsDevRowSync(id, 'xai');
+  if (listed) {
+    return (listed.reasoning_options || []).some((option) => option?.type === 'effort' && option.values?.length > 0);
+  }
   // grok-4.5 / grok-4.6 and anything newer in that line.
   return /grok[-_]?4\.(?:[5-9]|\d{2,})/.test(id);
 }

package/src/runtime/agent/orchestrator/providers/openai-compat.mjs

@@ -4,6 +4,7 @@ import { getLlmDispatcher, preconnect } from '../../../shared/llm/http-agent.mjs
 import { _combineUsageWithWarmup } from './openai-ws-events.mjs';
 import { appendAgentTrace } from '../agent-trace.mjs';
 import { OPENAI_COMPAT_PRESETS } from './openai-compat-presets.mjs';
+import { assertSafeBaseURL } from './provider-base-url.mjs';
 import { resolveResponsesTransportPolicy, RESPONSES_TRANSPORT_CAPABILITIES } from './openai-transport-policy.mjs';
 import { toResponsesTools, toXaiResponsesInput } from './openai-compat-wire.mjs';
 import {
@@ -74,34 +75,6 @@ export { compatReportedCostUsd } from './openai-compat-response-normalization.mj
 
 const PRESETS = OPENAI_COMPAT_PRESETS;
 
-// SSRF guard for provider baseURL. config.baseURL comes from user JSON;
-// reject non-http(s) schemes (file:/data:/ftp:/etc.) and require https for
-// any non-localhost host. The managed Local Provider and other loopback hosts
-// may use http. Throws a clear config error — no silent
-// fallback — so misconfig surfaces immediately instead of leaking apiKey.
-function assertSafeBaseURL(rawURL, providerName) {
-  let parsed;
-  try {
-    parsed = new URL(String(rawURL));
-  } catch {
-    throw new Error(`[provider:${providerName}] invalid baseURL: ${rawURL}`);
-  }
-  const scheme = parsed.protocol.toLowerCase();
-  if (scheme !== 'https:' && scheme !== 'http:') {
-    throw new Error(`[provider:${providerName}] baseURL scheme not allowed: ${parsed.protocol} (only http/https)`);
-  }
-  if (scheme === 'http:') {
-    const host = parsed.hostname.toLowerCase();
-    const isLocal = host === 'localhost' || host === '127.0.0.1' || host === '::1';
-    if (!isLocal) {
-      throw new Error(
-        `[provider:${providerName}] baseURL must use https for non-localhost host (got ${parsed.protocol}//${parsed.hostname})`
-      );
-    }
-  }
-  return rawURL;
-}
-
 export class OpenAICompatProvider {
   // Chat Completions prompt_tokens is already the total (includes cached).
   // Covers grok-oauth and all OPENAI_COMPAT_PRESETS. See registry.mjs.

package/src/runtime/agent/orchestrator/providers/openai-direct-request.mjs

@@ -1,13 +1,27 @@
+import { getModelMetadataSync } from '../../../shared/llm/model-catalog.mjs';
+
 // Public Responses contracts are independent of the OAuth backend.
 // Match documented model IDs and dated snapshots, not unknown future families.
 // GPT-5.6 and later: prompt_cache_options caching and Fast mode.
-const GPT_56_PLUS_MODELS = /^(?:gpt-6-(?:astra|sol|luna)|gpt-5\.6-(?:sol|terra|luna))(?:-\d{4}-\d{2}-\d{2})?$/;
+const GPT_56_PLUS_MODELS =
+  /^(?:gpt-6-(?:astra|sol|luna)|gpt-6\.1-sol|gpt-5\.6-(?:sol|terra|luna))(?:-\d{4}-\d{2}-\d{2})?$/;
+
+// OpenAI bills prompt-cache writes from GPT-5.6 on, and exactly those models
+// take prompt_cache_options and Fast mode. The id pattern is the offline
+// floor; a published cache-write price admits a later model without an edit
+// here, and a family no catalog lists yet stays out.
+// https://developers.openai.com/api/docs/guides/prompt-caching
+function isGpt56PlusModel(model) {
+  const id = String(model || '').trim();
+  if (!id) return false;
+  return GPT_56_PLUS_MODELS.test(id) || getModelMetadataSync(id, 'openai')?.cacheWriteCostPerM > 0;
+}
 // Earlier models documented for Priority processing (now Fast mode).
 const EARLIER_FAST_MODELS = /^gpt-5\.(?:5|4|4-mini)(?:-\d{4}|$)/;
 
 export function openAiDirectSupportsFast(model) {
   const id = String(model?.id || model || '').trim();
-  return GPT_56_PLUS_MODELS.test(id) || EARLIER_FAST_MODELS.test(id);
+  return isGpt56PlusModel(id) || EARLIER_FAST_MODELS.test(id);
 }
 
 export function applyOpenAIDirectCachePolicy(body, model, storeResponses) {
@@ -17,7 +31,7 @@ export function applyOpenAIDirectCachePolicy(body, model, storeResponses) {
   // Preserve the existing opt-out: no explicit cache-retention hint when
   // response storage is disabled. The provider's default cache still applies.
   if (!storeResponses) return body;
-  if (GPT_56_PLUS_MODELS.test(String(model || '').trim())) {
+  if (isGpt56PlusModel(model)) {
     body.prompt_cache_options = { ttl: '30m' };
   } else {
     body.prompt_cache_retention = '24h';