mixdog 0.9.2 → 0.9.4

package/src/session-runtime/cwd-plugins.mjs

@@ -0,0 +1,226 @@
+// cwd-plugins.mjs — cwd resolution/apply + plugins-status + core-memory context,
+// extracted from mixdog-session-runtime.mjs. Dependency-injected factory that
+// closes over the facade's mutable cwd/config/session state via getter/setter
+// injection (getCurrentCwd/setCurrentCwd/getConfig/getSession/...) plus the MCP
+// glue + prewarm callbacks. The facade keeps ownership of the mutable locals;
+// this module owns the pure logic that was previously inline.
+
+export function createCwdPlugins({
+  // mutable-state injection
+  getCurrentCwd,
+  setCurrentCwd,
+  getConfig,
+  getSession,
+  getRoute,
+  getLastProjectMcpKey,
+  setLastProjectMcpKey,
+  isCodeGraphPrewarmLazy,
+  isCodeGraphFirstTurnPrewarmDone,
+  getCodeGraphPrewarmDelayMs,
+  setSessionNeedsCwdRefresh,
+  // callbacks / deps
+  connectConfiguredMcp,
+  invalidatePreSessionToolSurface,
+  scheduleCodeGraphPrewarm,
+  hooks,
+  hookCommonPayload,
+  bootProfile,
+  getMemoryModule,
+  // channel-admin / registry helpers
+  listRegisteredPlugins,
+  pluginAdminStatus,
+  pluginManifest,
+  pluginMcpServerName,
+  mcpScriptForPlugin,
+  countSkillFiles,
+  readProjectMcpServers,
+  writeLastSessionCwd,
+  // shared utils
+  clean,
+  resolve,
+  statSync,
+  existsSync,
+  cfgMod,
+  STANDALONE_DATA_DIR,
+}) {
+  function resolveCwdPath(value) {
+    const raw = clean(value);
+    if (!raw) throw new Error('cwd: path is required for action=set');
+    const next = resolve(getCurrentCwd() || process.cwd(), raw);
+    const stat = statSync(next);
+    if (!stat.isDirectory()) throw new Error(`cwd: not a directory: ${next}`);
+    return next;
+  }
+
+  function applyResolvedCwd(nextCwd, { markRefresh = true } = {}) {
+    const resolved = resolve(nextCwd);
+    const stat = statSync(resolved);
+    if (!stat.isDirectory()) throw new Error(`cwd: not a directory: ${resolved}`);
+    const changed = resolve(getCurrentCwd()) !== resolved;
+    setCurrentCwd(resolved);
+    const currentCwd = resolved;
+    process.env.MIXDOG_SESSION_CWD = currentCwd;
+    writeLastSessionCwd(currentCwd);
+    const session = getSession();
+    if (session) session.cwd = currentCwd;
+    // cwd changes NEVER recreate the session: a mid-conversation cwd switch must
+    // preserve the full message history (and the BP1–BP3 prompt cache). We only
+    // retarget the live session's cwd in place; tool execution already reads the
+    // current cwd per turn. `cwd` is intentionally absent from the prompt
+    // context (see composeSystemPrompt), so there is nothing prompt-side to
+    // refresh either. `markRefresh`/`changed` are kept only for signature
+    // compatibility with existing callers.
+    void markRefresh;
+    // Lazy mode: before the first turn (e.g. the initial project-selection
+    // cwd set), do NOT prewarm — that is exactly the post-first-frame freeze
+    // we are avoiding. Once a turn has run, an in-session cwd switch DOES
+    // prewarm the new dir, since a lookup there is now likely.
+    if (isCodeGraphPrewarmLazy() && !isCodeGraphFirstTurnPrewarmDone()) {
+      bootProfile('code-graph:prewarm-lazy', { reason: 'cwd-deferred-to-first-turn' });
+    } else {
+      const delay = getCodeGraphPrewarmDelayMs();
+      scheduleCodeGraphPrewarm(changed ? 0 : delay, changed ? 'cwd-change' : 'cwd');
+    }
+    // Project-local `.mcp.json` follows the cwd: when the effective project MCP
+    // set changes, reconnect in the background (never await — this stays sync,
+    // and the session is preserved). Guarded so a no-op cwd change does not
+    // churn connections.
+    if (changed) {
+      try {
+        const nextKey = resolved + '\u0000' + JSON.stringify(readProjectMcpServers(resolved));
+        if (nextKey !== getLastProjectMcpKey()) {
+          setLastProjectMcpKey(nextKey);
+          void connectConfiguredMcp({ reset: true })
+            .then(() => invalidatePreSessionToolSurface())
+            .catch(() => {});
+        }
+      } catch {}
+    }
+    // CwdChanged: bridge an effective cwd switch to the standard hook bus.
+    // No matcher event — payload is minimal { cwd }. Fire-and-forget.
+    if (changed) {
+      try { void hooks.dispatch('CwdChanged', hookCommonPayload({ cwd: currentCwd })); } catch {}
+    }
+    return currentCwd;
+  }
+
+  async function refreshSessionForCwdIfNeeded(reason = 'cwd-change') {
+    // No-op: cwd changes are applied in place by applyResolvedCwd and never
+    // tear down the session. Retained as a stable hook for ask()'s pre-turn
+    // call so the surrounding turn flow is unchanged.
+    void reason;
+    setSessionNeedsCwdRefresh(false);
+    return getSession();
+  }
+
+  function pluginsStatus() {
+    const config = getConfig();
+    const dataDir = cfgMod.getPluginData?.();
+    const configuredMcp = config?.mcpServers && typeof config.mcpServers === 'object'
+      ? config.mcpServers
+      : {};
+    const plugins = [];
+    const addRegisteredPlugin = (entry) => {
+      const root = clean(entry.root);
+      if (!root || !existsSync(root)) return;
+      const manifest = pluginManifest(root);
+      const name = clean(manifest.name) || clean(manifest.id) || clean(entry.name) || root.split(/[\\/]/).pop() || root;
+      const plugin = {
+        id: clean(entry.id) || name,
+        name,
+        title: clean(manifest.title) || clean(manifest.displayName) || clean(entry.title) || name,
+        version: clean(manifest.version) || clean(entry.version) || null,
+        description: clean(manifest.description) || clean(entry.description),
+        marketplace: null,
+        source: clean(entry.sourceType) === 'local' ? 'local' : 'registry',
+        sourceUrl: clean(entry.source),
+        sourceType: clean(entry.sourceType) || 'git',
+        managed: entry.managed !== false,
+        root,
+        installedAt: entry.installedAt || null,
+        updatedAt: entry.updatedAt || null,
+        skillCount: countSkillFiles(root),
+        mcpScript: mcpScriptForPlugin(root),
+      };
+      plugin.mcpServerName = pluginMcpServerName(plugin);
+      plugin.mcpEnabled = Object.prototype.hasOwnProperty.call(configuredMcp, plugin.mcpServerName)
+        || Object.keys(configuredMcp).some((k) => k.startsWith(`${plugin.mcpServerName}--`));
+      plugins.push(plugin);
+    };
+
+    for (const entry of listRegisteredPlugins({ dataDir })) addRegisteredPlugin(entry);
+
+    plugins.sort((a, b) => {
+      if (a.source !== b.source) return a.source.localeCompare(b.source);
+      return a.name.localeCompare(b.name);
+    });
+    const admin = pluginAdminStatus({ dataDir });
+    return {
+      count: plugins.length,
+      plugins,
+      roots: {
+        registry: admin.registryPath,
+        installed: admin.installRoot,
+      },
+    };
+  }
+
+  function formatCoreMemoryLines(payload = {}) {
+    const seen = new Set();
+    const lines = [];
+    for (const value of [
+      ...(Array.isArray(payload.userLines) ? payload.userLines : []),
+      ...(Array.isArray(payload.dbLines) ? payload.dbLines : []),
+    ]) {
+      const text = clean(value).replace(/\s+/g, ' ');
+      if (!text) continue;
+      const key = text.toLowerCase();
+      if (seen.has(key)) continue;
+      seen.add(key);
+      lines.push(`- ${text}`);
+      if (lines.length >= 40) break;
+    }
+    const out = lines.join('\n');
+    const maxChars = 6000;
+    return out.length > maxChars ? `${out.slice(0, maxChars).replace(/\s+\S*$/, '')}\n- ...` : out;
+  }
+
+  async function loadCoreMemoryContext() {
+    // Boot should not pay for memory/PG startup unless explicitly requested.
+    // Recall and memory tools still initialize the memory service on first use.
+    if (process.env.MIXDOG_BOOT_CORE_MEMORY !== '1') {
+      bootProfile('core-memory:skipped');
+      return '';
+    }
+    const startedAt = performance.now();
+    let timer = null;
+    const timeout = new Promise((resolveTimeout) => {
+      timer = setTimeout(() => resolveTimeout(''), 2000);
+      timer.unref?.();
+    });
+    try {
+      return await Promise.race([
+        (async () => {
+          const memoryMod = await getMemoryModule();
+          if (typeof memoryMod?.buildSessionCoreMemoryPayload !== 'function') return '';
+          return formatCoreMemoryLines(await memoryMod.buildSessionCoreMemoryPayload(getCurrentCwd()));
+        })(),
+        timeout,
+      ]);
+    } catch {
+      return '';
+    } finally {
+      if (timer) clearTimeout(timer);
+      bootProfile('core-memory:done', { ms: (performance.now() - startedAt).toFixed(1) });
+    }
+  }
+
+  return {
+    resolveCwdPath,
+    applyResolvedCwd,
+    refreshSessionForCwdIfNeeded,
+    pluginsStatus,
+    formatCoreMemoryLines,
+    loadCoreMemoryContext,
+  };
+}

package/src/session-runtime/effort.mjs

@@ -0,0 +1,128 @@
+// Reasoning-effort catalogs and coercion. Pure helpers.
+import { clean } from './session-text.mjs';
+
+export const TOOL_MODES = new Set(['full', 'readonly', 'lead']);
+export const ALL_EFFORT_LEVELS = new Set(['none', 'low', 'medium', 'high', 'xhigh', 'max']);
+export const EFFORT_LABELS = {
+  none: 'None',
+  low: 'Low',
+  medium: 'Medium',
+  high: 'High',
+  xhigh: 'Extra High',
+  max: 'Max',
+};
+
+export const EFFORT_OPTIONS_BY_PROVIDER = {
+  openai: ['none', 'low', 'medium', 'high', 'xhigh'],
+  'openai-oauth': ['none', 'low', 'medium', 'high', 'xhigh'],
+  anthropic: ['low', 'medium', 'high', 'xhigh', 'max'],
+  'anthropic-oauth': ['low', 'medium', 'high', 'xhigh', 'max'],
+  xai: ['none', 'low', 'medium', 'high'],
+  'grok-oauth': ['none', 'low', 'medium', 'high'],
+  'opencode-go': ['high', 'max'],
+};
+export const EFFORT_BY_FAMILY = {
+  opus: ['low', 'medium', 'high', 'xhigh', 'max'],
+  sonnet: ['low', 'medium', 'high'],
+  haiku: [],
+  'gpt-5.5': ['none', 'low', 'medium', 'high', 'xhigh'],
+  'gpt-5.4': ['none', 'low', 'medium', 'high', 'xhigh'],
+  'gpt-5.2': ['none', 'low', 'medium', 'high', 'xhigh'],
+  'gpt-5': ['none', 'low', 'medium', 'high', 'xhigh'],
+  'gpt-mini': ['none', 'low', 'medium', 'high', 'xhigh'],
+  'gpt-nano': ['none', 'low', 'medium', 'high'],
+  'gpt-codex': ['none', 'low', 'medium', 'high'],
+  grok: ['none', 'low', 'medium', 'high'],
+};
+export const EFFORT_FALLBACKS = {
+  max: ['max', 'xhigh', 'high', 'medium', 'low'],
+  xhigh: ['xhigh', 'high', 'medium', 'low'],
+  high: ['high', 'medium', 'low'],
+  medium: ['medium', 'low'],
+  low: ['low'],
+  none: ['none'],
+};
+
+export function normalizeToolMode(mode) {
+  const value = String(mode || '').trim().toLowerCase();
+  return TOOL_MODES.has(value) ? value : 'full';
+}
+
+export function normalizeEffortInput(value) {
+  const v = clean(value).toLowerCase();
+  if (!v || v === 'auto') return null;
+  if (!ALL_EFFORT_LEVELS.has(v)) {
+    throw new Error(`effort must be one of auto, ${[...ALL_EFFORT_LEVELS].join(', ')}`);
+  }
+  return v;
+}
+
+export function effortOptionsFor(provider, model) {
+  const providerAllowed = EFFORT_OPTIONS_BY_PROVIDER[provider] || null;
+  const filterProvider = (values) => {
+    const unique = [...new Set((values || []).map(clean).filter(Boolean))];
+    return providerAllowed ? unique.filter((v) => providerAllowed.includes(v)) : unique;
+  };
+  const declared = Array.isArray(model?.reasoningLevels)
+    ? model.reasoningLevels.map(clean).filter(Boolean)
+    : [];
+  const family = clean(model?.family).toLowerCase();
+  if (Array.isArray(model?.reasoningLevels)) {
+    if (declared.length) return filterProvider(declared);
+    if (Object.prototype.hasOwnProperty.call(EFFORT_BY_FAMILY, family)) {
+      return filterProvider(EFFORT_BY_FAMILY[family]);
+    }
+    return [];
+  }
+  const reasoningOptionEffort = Array.isArray(model?.reasoningOptions)
+    ? model.reasoningOptions.find((option) => clean(option?.type).toLowerCase() === 'effort')
+    : null;
+  const reasoningOptionValues = Array.isArray(reasoningOptionEffort?.values)
+    ? reasoningOptionEffort.values.map(clean).filter(Boolean)
+    : [];
+  if (reasoningOptionValues.length) return filterProvider(reasoningOptionValues);
+  if (Object.prototype.hasOwnProperty.call(EFFORT_BY_FAMILY, family)) {
+    return filterProvider(EFFORT_BY_FAMILY[family]);
+  }
+  return providerAllowed || [];
+}
+
+export function coerceEffortFor(provider, model, effort) {
+  if (!effort) return null;
+  const allowed = effortOptionsFor(provider, model);
+  if (!allowed || allowed.length === 0) return null;
+  if (allowed.includes(effort)) return effort;
+  for (const candidate of EFFORT_FALLBACKS[effort] || []) {
+    if (allowed.includes(candidate)) return candidate;
+  }
+  return null;
+}
+
+export function normalizeSavedEffort(value) {
+  try {
+    return normalizeEffortInput(value);
+  } catch {
+    return null;
+  }
+}
+
+export function effortItemsFor(provider, model, activeEffort) {
+  const allowed = effortOptionsFor(provider, model);
+  const items = [];
+  for (const value of allowed || []) {
+    items.push({
+      value,
+      label: EFFORT_LABELS[value] || value,
+      description: value === activeEffort ? 'current' : '',
+    });
+  }
+  return items;
+}
+
+export function toolSpecForMode(mode) {
+  return mode === 'readonly' ? ['tools:readonly'] : 'full';
+}
+
+export function deferredSurfaceModeForLead(mode) {
+  return mode === 'readonly' ? 'readonly' : 'lead';
+}

package/src/session-runtime/fs-utils.mjs

@@ -0,0 +1,10 @@
+// Small filesystem read helpers used by session-runtime submodules.
+import { readFileSync } from 'node:fs';
+
+export function readJsonSafe(path) {
+  try { return JSON.parse(readFileSync(path, 'utf8')); } catch { return null; }
+}
+
+export function readTextSafe(path) {
+  try { return readFileSync(path, 'utf8').trim(); } catch { return ''; }
+}

package/src/session-runtime/mcp-glue.mjs

@@ -0,0 +1,177 @@
+// MCP config/status/connect glue, extracted from mixdog-session-runtime.mjs.
+// Dependency-injected factory: all live state (config, currentCwd, connect
+// generation/in-flight/failures) is threaded through accessors + a caller-owned
+// `state` object so the facade's teardown/reconnect paths still observe it.
+// Method behavior is byte-for-byte identical; only grouping changes.
+import { resolve } from 'node:path';
+import { clean } from './session-text.mjs';
+import { readProjectMcpServers } from './plugin-mcp.mjs';
+
+export function createMcpGlue({
+  mcpClient,
+  getConfig,
+  getCurrentCwd,
+  state,
+}) {
+  function mcpTransportLabel(cfg = {}) {
+    if (cfg.autoDetect) return `autoDetect:${cfg.autoDetect}`;
+    try {
+      return mcpClient.resolveMcpTransportKind(cfg);
+    } catch {
+      return 'unknown';
+    }
+  }
+
+  // Merge mixdog-config `agent.mcpServers` with project-local `.mcp.json`.
+  // On name collision the project-local `.mcp.json` entry WINS (Claude Code
+  // precedence: project > user config). `sources[name]` records each server's
+  // origin ('config' | 'project') for status reporting.
+  function resolveEffectiveMcpServers() {
+    const config = getConfig();
+    const configured = config?.mcpServers && typeof config.mcpServers === 'object'
+      ? config.mcpServers
+      : {};
+    const project = readProjectMcpServers(getCurrentCwd());
+    const servers = { ...configured, ...project };
+    const sources = {};
+    for (const name of Object.keys(configured)) sources[name] = 'config';
+    for (const name of Object.keys(project)) sources[name] = 'project';
+    return { servers, sources };
+  }
+
+  function mcpStatus() {
+    const { servers: configured, sources } = resolveEffectiveMcpServers();
+    const connected = new Map((mcpClient.getMcpServerStatus?.() || []).map((row) => [row.name, row]));
+    const failures = new Map((state.mcpFailures || []).map((row) => [row.name, row]));
+    const servers = [];
+    for (const [name, cfg] of Object.entries(configured)) {
+      const live = connected.get(name);
+      const fail = failures.get(name);
+      servers.push({
+        name,
+        configured: true,
+        enabled: cfg?.enabled !== false,
+        connected: Boolean(live),
+        status: cfg?.enabled === false ? 'disabled' : live ? 'connected' : fail ? 'failed' : 'disconnected',
+        transport: mcpTransportLabel(cfg),
+        toolCount: live?.toolCount || 0,
+        tools: live?.tools || [],
+        error: fail?.msg || null,
+        source: sources[name] || 'config',
+      });
+      connected.delete(name);
+    }
+    for (const live of connected.values()) {
+      servers.push({ ...live, configured: false, status: 'connected' });
+    }
+    servers.sort((a, b) => String(a.name).localeCompare(String(b.name)));
+    return {
+      servers,
+      configuredCount: Object.keys(configured).length,
+      connectedCount: servers.filter((row) => row.connected).length,
+      failedCount: servers.filter((row) => row.status === 'failed').length,
+    };
+  }
+
+  async function connectConfiguredMcp({ reset = false } = {}) {
+    // Serialize reconnects: boot connect, cwd-change reset, and rapid cwd
+    // switches must never interleave their disconnect/connect phases, or an
+    // older run finishing after a newer reset could re-add stale servers into
+    // the shared client registry. Approach: a generation token + a single
+    // in-flight promise. Each call bumps the generation, waits for any prior
+    // run to finish, then bails if a newer call has superseded it — leaving the
+    // latest requested effective-server-set in the registry.
+    const gen = ++state.mcpConnectGeneration;
+    if (state.mcpConnectInFlight) {
+      try { await state.mcpConnectInFlight; } catch { /* prior run's failures already captured */ }
+    }
+    if (gen !== state.mcpConnectGeneration) return mcpStatus();
+    const run = (async () => {
+      if (reset) await mcpClient.disconnectAll?.();
+      state.mcpFailures = [];
+      const { servers } = resolveEffectiveMcpServers();
+      if (Object.keys(servers).length === 0) return;
+      try {
+        await mcpClient.connectMcpServers(servers);
+      } catch (error) {
+        state.mcpFailures = Array.isArray(error?.failures)
+          ? error.failures
+          : [{ name: 'mcp', msg: error?.message || String(error) }];
+      }
+    })();
+    state.mcpConnectInFlight = run;
+    try {
+      await run;
+    } finally {
+      if (state.mcpConnectInFlight === run) state.mcpConnectInFlight = null;
+    }
+    return mcpStatus();
+  }
+
+  function normalizeMcpServerInput(input = {}) {
+    const currentCwd = getCurrentCwd();
+    const name = clean(input.name).toLowerCase().replace(/[^a-z0-9_.-]+/g, '-').replace(/^-+|-+$/g, '');
+    if (!name) throw new Error('MCP server name is required');
+    const coerceStringRecord = (value) => {
+      if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+      const out = {};
+      for (const [key, val] of Object.entries(value)) {
+        if (val === undefined || val === null) continue;
+        out[String(key)] = String(val);
+      }
+      return Object.keys(out).length > 0 ? out : null;
+    };
+    const withOptionalHeaders = (config) => {
+      const headers = coerceStringRecord(input.headers);
+      if (headers) config.headers = headers;
+      return config;
+    };
+    const url = clean(input.url);
+    const type = clean(input.type).toLowerCase();
+    if (url) {
+      if (type === 'sse') {
+        if (!/^https?:\/\//i.test(url)) throw new Error('MCP URL must start with http:// or https://');
+        return { name, config: withOptionalHeaders({ type: 'sse', url }) };
+      }
+      if (type === 'ws') {
+        if (!/^(?:wss?|https?):\/\//i.test(url)) {
+          throw new Error('MCP WebSocket URL must start with ws://, wss://, http://, or https://');
+        }
+        return { name, config: withOptionalHeaders({ type: 'ws', url }) };
+      }
+      if (type === 'http' || type === 'streamable-http') {
+        if (!/^https?:\/\//i.test(url)) throw new Error('MCP URL must start with http:// or https://');
+        return { name, config: withOptionalHeaders({ type: 'http', url }) };
+      }
+      if (/^wss?:\/\//i.test(url)) {
+        return { name, config: withOptionalHeaders({ type: 'ws', url }) };
+      }
+      if (!/^https?:\/\//i.test(url)) throw new Error('MCP URL must start with http:// or https://');
+      return { name, config: withOptionalHeaders({ type: 'http', url }) };
+    }
+    const command = clean(input.command);
+    if (!command) throw new Error('MCP server command or URL is required');
+    const args = Array.isArray(input.args)
+      ? input.args.map((v) => String(v)).filter(Boolean)
+      : clean(input.args).split(/\s+/).filter(Boolean);
+    const requestedCwd = clean(input.cwd);
+    const cwdForServer = requestedCwd ? resolve(currentCwd, requestedCwd) : currentCwd;
+    const root = resolve(currentCwd);
+    const resolvedCwd = resolve(cwdForServer);
+    if (resolvedCwd !== root && !resolvedCwd.startsWith(`${root}\\`) && !resolvedCwd.startsWith(`${root}/`)) {
+      throw new Error('MCP server cwd must stay under the current project');
+    }
+    const config = { type: 'stdio', command, args, cwd: resolvedCwd };
+    const env = coerceStringRecord(input.env);
+    if (env) config.env = env;
+    return { name, config };
+  }
+
+  return {
+    mcpTransportLabel,
+    resolveEffectiveMcpServers,
+    mcpStatus,
+    connectConfiguredMcp,
+    normalizeMcpServerInput,
+  };
+}

package/src/session-runtime/model-capabilities.mjs

@@ -0,0 +1,130 @@
+// Provider/model capability probes: fast-tier + hosted web-search support, and
+// model-settings persistence. Pure except saveModelSettings (takes cfgMod).
+import { clean, hasOwn } from './session-text.mjs';
+
+const FAST_CAPABLE_PROVIDERS = new Set(['anthropic', 'anthropic-oauth', 'openai', 'openai-oauth']);
+export const LAZY_SECRET_PROVIDERS = new Set(['openai-oauth', 'anthropic-oauth', 'grok-oauth', 'ollama', 'lmstudio']);
+
+export function routeFastKey(provider, model) {
+  const p = clean(provider);
+  const m = clean(model);
+  return p && m ? `${p}/${m}` : '';
+}
+
+function openAiModelMetaSupportsFast(model) {
+  const tiers = Array.isArray(model?.serviceTiers) ? model.serviceTiers : [];
+  const speedTiers = Array.isArray(model?.additionalSpeedTiers) ? model.additionalSpeedTiers : [];
+  if (tiers.length || speedTiers.length || model?.defaultServiceTier) {
+    return tiers.some((tier) => tier?.id === 'priority')
+      || speedTiers.includes('priority')
+      || model?.defaultServiceTier === 'priority';
+  }
+  const id = clean(model?.id || model).toLowerCase();
+  if (id.includes('mini') || id.includes('nano') || id.includes('codex')) return false;
+  return /^gpt-5(\.|-|$)/.test(id);
+}
+
+function openAiDirectModelSupportsFast(model) {
+  const id = clean(model?.id || model);
+  return /^gpt-5\.5(?:-\d{4}|$)/.test(id)
+    || /^gpt-5\.4(?:-\d{4}|$)/.test(id)
+    || /^gpt-5\.4-mini(?:-\d{4}|$)/.test(id);
+}
+
+function openAiModelSupportsHostedWebSearch(model) {
+  const id = clean(model?.id || model).toLowerCase();
+  if (!id) return false;
+  if (model?.supportsWebSearch === true) return true;
+  const tools = [
+    ...(Array.isArray(model?.supportedTools) ? model.supportedTools : []),
+    ...(Array.isArray(model?.tools) ? model.tools : []),
+    ...(Array.isArray(model?.capabilities?.tools) ? model.capabilities.tools : []),
+  ].map((tool) => clean(tool?.type || tool?.name || tool).toLowerCase());
+  if (tools.some((tool) => tool === 'web_search' || tool === 'web_search_preview')) return true;
+  if (/codex|image|audio|tts|stt|embedding|rerank|moderation|search-preview/.test(id)) return false;
+  return /^gpt-(5(?:\.|$|-)|4\.1(?:-|$)|4o(?:-|$)|4\.5(?:-|$))/.test(id)
+    || /^o[34](?:-|$)/.test(id);
+}
+
+function grokModelSupportsHostedWebSearch(model) {
+  const id = clean(model?.id || model).toLowerCase();
+  if (!id || /imagine|image|video|composer/.test(id)) return false;
+  if (id === 'grok-build') return false;
+  return /^grok-/.test(id);
+}
+
+function geminiModelSupportsHostedWebSearch(model) {
+  const id = clean(model?.id || model).toLowerCase();
+  if (!id || /embedding|aqa|imagen|veo|tts|image|computer-use|customtools/.test(id)) return false;
+  return /^gemini-(3(?:\.|-|$)|2\.5-|2\.0-flash)/.test(id);
+}
+
+function anthropicModelSupportsHostedWebSearch(model) {
+  const id = clean(model?.id || model).toLowerCase();
+  if (!id) return false;
+  const match = id.match(/^claude-(opus|sonnet|haiku)-(\d+)(?:[-.](\d+))?/);
+  if (!match) return false;
+  const major = Number(match[2]) || 0;
+  const minor = Number(match[3]) || 0;
+  return major > 4 || (major === 4 && minor >= 0);
+}
+
+function anthropicModelMetaSupportsFast(model) {
+  const id = clean(model?.id || model).toLowerCase();
+  return /^claude-(opus|sonnet)/.test(id);
+}
+
+export function fastCapableFor(provider, model) {
+  const p = clean(provider);
+  if (!FAST_CAPABLE_PROVIDERS.has(p)) return false;
+  if (p === 'openai') return openAiDirectModelSupportsFast(model);
+  if (p === 'openai-oauth') return openAiModelMetaSupportsFast(model);
+  if (p === 'anthropic' || p === 'anthropic-oauth') return anthropicModelMetaSupportsFast(model);
+  return false;
+}
+
+// searchCapableFor needs the search-route normalizers, which live in
+// search-routes.mjs and themselves are pure. Wire them in via a factory to keep
+// this module free of a circular import at load time.
+export function makeSearchCapableFor(normalizeSearchProviderId, isSearchCapableProvider) {
+  return function searchCapableFor(provider, model) {
+    const p = normalizeSearchProviderId(provider);
+    if (!isSearchCapableProvider(p)) return false;
+    if (p === 'openai' || p === 'openai-oauth') return openAiModelSupportsHostedWebSearch(model);
+    if (p === 'grok-oauth' || p === 'xai') return grokModelSupportsHostedWebSearch(model);
+    if (p === 'gemini') return geminiModelSupportsHostedWebSearch(model);
+    if (p === 'anthropic' || p === 'anthropic-oauth') return anthropicModelSupportsHostedWebSearch(model);
+    return model?.supportsWebSearch === true;
+  };
+}
+
+export function fastPreferenceFor(config, provider, model) {
+  const key = routeFastKey(provider, model);
+  if (!key) return false;
+  const saved = config?.modelSettings?.[key];
+  if (saved && typeof saved === 'object' && hasOwn(saved, 'fast')) return saved.fast === true;
+  return config?.fastModels?.[key] === true;
+}
+
+export function saveModelSettings(cfgMod, route, { fastCapable = true, baseConfig = null } = {}) {
+  const key = routeFastKey(route?.provider, route?.model);
+  if (!key) return baseConfig || cfgMod.loadConfig();
+  const nextConfig = baseConfig || cfgMod.loadConfig();
+  const modelSettings = { ...(nextConfig.modelSettings || {}) };
+  const nextSetting = { ...(modelSettings[key] || {}) };
+  if (hasOwn(route, 'effort') && route.effort) nextSetting.effort = route.effort;
+  else delete nextSetting.effort;
+  if (fastCapable) nextSetting.fast = route.fast === true;
+  else nextSetting.fast = false;
+  modelSettings[key] = nextSetting;
+
+  // Legacy compatibility: keep fastModels true entries for old readers, but
+  // let modelSettings.fast=false override them in new readers.
+  const fastModels = { ...(nextConfig.fastModels || {}) };
+  if (nextSetting.fast === true) fastModels[key] = true;
+  else delete fastModels[key];
+
+  const savedConfig = { ...nextConfig, modelSettings, fastModels };
+  cfgMod.saveConfig(savedConfig);
+  return savedConfig;
+}