conductor-oss 0.3.4 → 0.4.0

package/web/.next/standalone/packages/web/src/lib/runtimeAgentModels.ts

@@ -1,788 +0,0 @@
-import { execFile } from "node:child_process";
-import { readFile, readdir, stat } from "node:fs/promises";
-import { homedir } from "node:os";
-import { extname, join } from "node:path";
-import { promisify } from "node:util";
-import {
-  resolveAgentModelAccess,
-  type AgentModelAccess,
-  type AgentModelOption,
-  type AgentReasoningOption,
-  type ModelAccessPreferences,
-  type SupportedModelAgent,
-} from "@conductor-oss/core/types";
-import {
-  getRuntimeCatalogDefaultModelForAccess,
-  getRuntimeCatalogDefaultReasoning,
-  type RuntimeAgentModelCatalog,
-} from "./runtimeAgentModelsShared";
-
-const execFileAsync = promisify(execFile);
-const RUNTIME_MODEL_CATALOG_TTL_MS = 60_000;
-
-type RuntimeModelCatalogCacheEntry = {
-  value: RuntimeAgentModelCatalog | null;
-  expiresAt: number;
-};
-
-const runtimeModelCatalogCache = new Map<string, RuntimeModelCatalogCacheEntry>();
-const runtimeModelCatalogInflight = new Map<string, Promise<RuntimeAgentModelCatalog | null>>();
-
-type CodexCacheReasoningLevel = {
-  effort?: unknown;
-  description?: unknown;
-};
-
-type CodexCacheModel = {
-  slug?: unknown;
-  display_name?: unknown;
-  description?: unknown;
-  default_reasoning_level?: unknown;
-  supported_reasoning_levels?: unknown;
-  visibility?: unknown;
-  supported_in_api?: unknown;
-  priority?: unknown;
-};
-
-type ClaudeSettings = {
-  model?: unknown;
-  alwaysThinkingEnabled?: unknown;
-};
-
-type ClaudeStatsCache = {
-  dailyModelTokens?: Array<{
-    tokensByModel?: Record<string, unknown>;
-  }>;
-};
-
-type SimpleAuthSettings = {
-  security?: {
-    auth?: {
-      selectedType?: unknown;
-    };
-  };
-};
-
-type RecentFileMatchOptions = {
-  extensions?: string[];
-  filenamePattern?: RegExp;
-  maxDepth?: number;
-  maxFiles?: number;
-  maxDirectories?: number;
-};
-
-const DEFAULT_REASONING_DESCRIPTIONS: Record<string, string> = {
-  low: "Fast responses with lighter reasoning.",
-  medium: "Balanced speed and reasoning depth for everyday tasks.",
-  high: "Deeper reasoning for more complex tasks.",
-  xhigh: "Maximum reasoning depth for the hardest tasks.",
-};
-
-function toObject(value: unknown): Record<string, unknown> {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return {};
-  }
-  return value as Record<string, unknown>;
-}
-
-async function readTextFileIfPresent(path: string): Promise<string | null> {
-  try {
-    return await readFile(path, "utf8");
-  } catch {
-    return null;
-  }
-}
-
-async function readJsonFileIfPresent<T>(path: string): Promise<T | null> {
-  const contents = await readTextFileIfPresent(path);
-  if (!contents) return null;
-  try {
-    return JSON.parse(contents) as T;
-  } catch {
-    return null;
-  }
-}
-
-function formatReasoningLabel(raw: string): string {
-  const normalized = raw.trim().toLowerCase();
-  if (normalized === "xhigh") return "Extra High";
-  return normalized
-    .split(/[_\s-]+/g)
-    .filter(Boolean)
-    .map((part) => part[0]?.toUpperCase() + part.slice(1))
-    .join(" ");
-}
-
-function toReasoningOption(effort: string, description?: string | null): AgentReasoningOption {
-  const normalized = effort.trim().toLowerCase();
-  return {
-    id: normalized,
-    label: formatReasoningLabel(normalized),
-    description: description?.trim() || DEFAULT_REASONING_DESCRIPTIONS[normalized] || "Reasoning effort supported by the local CLI.",
-  };
-}
-
-function pickRuntimeDefaultModel(
-  availableModels: AgentModelOption[],
-  configuredModel: string | null,
-): string | null {
-  if (configuredModel && availableModels.some((model) => model.id === configuredModel)) {
-    return configuredModel;
-  }
-  return availableModels[0]?.id ?? null;
-}
-
-function pickRuntimeDefaultReasoning(
-  availableOptions: AgentReasoningOption[],
-  configuredReasoning: string | null,
-  fallbackReasoning: string | null,
-): string | null {
-  const normalizedConfigured = configuredReasoning?.trim().toLowerCase() ?? null;
-  if (normalizedConfigured && availableOptions.some((option) => option.id === normalizedConfigured)) {
-    return normalizedConfigured;
-  }
-
-  const normalizedFallback = fallbackReasoning?.trim().toLowerCase() ?? null;
-  if (normalizedFallback && availableOptions.some((option) => option.id === normalizedFallback)) {
-    return normalizedFallback;
-  }
-
-  const first = availableOptions[0]?.id;
-  return typeof first === "string" && first.trim().length > 0 ? first : null;
-}
-
-function uniqueModelOptions(models: AgentModelOption[]): AgentModelOption[] {
-  const seen = new Set<string>();
-  const ordered: AgentModelOption[] = [];
-  for (const model of models) {
-    if (seen.has(model.id)) continue;
-    seen.add(model.id);
-    ordered.push(model);
-  }
-  return ordered;
-}
-
-function uniqueStringValues(values: Array<string | null | undefined>): string[] {
-  const seen = new Set<string>();
-  const ordered: string[] = [];
-  for (const value of values) {
-    const normalized = value?.trim();
-    if (!normalized || seen.has(normalized)) continue;
-    seen.add(normalized);
-    ordered.push(normalized);
-  }
-  return ordered;
-}
-
-function formatCodexModelLabel(raw: string): string {
-  return raw
-    .trim()
-    .split("-")
-    .filter(Boolean)
-    .map((part, index) => {
-      const lower = part.toLowerCase();
-      if (lower === "gpt") return "GPT";
-      if (lower === "codex") return "Codex";
-      if (lower === "spark") return "Spark";
-      if (lower === "mini") return "Mini";
-      if (lower === "max") return "Max";
-      if (index === 0) return part.toUpperCase();
-      return part[0]?.toUpperCase() + part.slice(1);
-    })
-    .join("-");
-}
-
-function toCodexModelOption(entry: CodexCacheModel): AgentModelOption | null {
-  if (typeof entry.slug !== "string" || entry.slug.trim().length === 0) {
-    return null;
-  }
-
-  const slug = entry.slug.trim();
-  const rawLabel = typeof entry.display_name === "string" && entry.display_name.trim().length > 0
-    ? entry.display_name.trim()
-    : slug;
-
-  return {
-    id: slug,
-    label: formatCodexModelLabel(rawLabel),
-    description: typeof entry.description === "string" && entry.description.trim().length > 0
-      ? entry.description.trim()
-      : `Model exposed by the local Codex installation (${slug}).`,
-    access: entry.supported_in_api === false ? ["chatgpt"] : ["chatgpt", "api"],
-  };
-}
-
-function parseCodexReasoningOptions(entry: CodexCacheModel): AgentReasoningOption[] {
-  const rawLevels = Array.isArray(entry.supported_reasoning_levels)
-    ? entry.supported_reasoning_levels as CodexCacheReasoningLevel[]
-    : [];
-
-  return rawLevels
-    .map((level) => {
-      if (typeof level.effort !== "string" || level.effort.trim().length === 0) {
-        return null;
-      }
-      return toReasoningOption(
-        level.effort,
-        typeof level.description === "string" ? level.description : null,
-      );
-    })
-    .filter((option): option is AgentReasoningOption => Boolean(option));
-}
-
-async function readCodexConfiguredState(): Promise<{ model: string | null; reasoningEffort: string | null }> {
-  const contents = await readTextFileIfPresent(join(homedir(), ".codex", "config.toml"));
-  if (!contents) {
-    return { model: null, reasoningEffort: null };
-  }
-
-  const modelMatch = contents.match(/^\s*model\s*=\s*"([^"]+)"\s*$/m);
-  const reasoningMatch = contents.match(/^\s*model_reasoning_effort\s*=\s*"([^"]+)"\s*$/m);
-
-  return {
-    model: modelMatch?.[1]?.trim() || null,
-    reasoningEffort: reasoningMatch?.[1]?.trim().toLowerCase() || null,
-  };
-}
-
-export function parseCodexRuntimeModelCatalog(
-  value: unknown,
-  configuredModel: string | null = null,
-  configuredReasoningEffort: string | null = null,
-): RuntimeAgentModelCatalog | null {
-  if (!value || typeof value !== "object") return null;
-
-  const models = Array.isArray((value as { models?: unknown }).models)
-    ? (value as { models: CodexCacheModel[] }).models
-    : [];
-
-  const listedModels = models
-    .map((entry, index) => ({ entry, index }))
-    .filter(({ entry }) => entry.visibility === "list")
-    .sort((left, right) => {
-      const leftPriority = typeof left.entry.priority === "number" ? left.entry.priority : Number.MAX_SAFE_INTEGER;
-      const rightPriority = typeof right.entry.priority === "number" ? right.entry.priority : Number.MAX_SAFE_INTEGER;
-      if (leftPriority !== rightPriority) return leftPriority - rightPriority;
-      return left.index - right.index;
-    })
-    .map(({ entry }) => ({ option: toCodexModelOption(entry), entry }))
-    .filter((entry): entry is { option: AgentModelOption; entry: CodexCacheModel } => Boolean(entry.option));
-
-  if (listedModels.length === 0) return null;
-
-  const reasoningOptionsByModel: Record<string, AgentReasoningOption[]> = {};
-  const defaultReasoningByModel: Record<string, string> = {};
-
-  for (const { option, entry } of listedModels) {
-    const reasoningOptions = parseCodexReasoningOptions(entry);
-    if (reasoningOptions.length > 0) {
-      reasoningOptionsByModel[option.id] = reasoningOptions;
-      const defaultReasoning = typeof entry.default_reasoning_level === "string"
-        ? entry.default_reasoning_level.trim().toLowerCase()
-        : null;
-      const resolvedDefaultReasoning = pickRuntimeDefaultReasoning(
-        reasoningOptions,
-        configuredReasoningEffort,
-        defaultReasoning,
-      );
-      if (resolvedDefaultReasoning) {
-        defaultReasoningByModel[option.id] = resolvedDefaultReasoning;
-      }
-    }
-  }
-
-  const chatgptModels = listedModels.map(({ option }) => option);
-  const apiModels = listedModels
-    .map(({ option }) => option)
-    .filter((model) => model.access.includes("api"));
-
-  const fallbackPlaceholder = configuredModel?.trim() || chatgptModels[0]?.id || "";
-  const chatgptDefault = pickRuntimeDefaultModel(chatgptModels, configuredModel);
-  const apiDefault = pickRuntimeDefaultModel(apiModels, configuredModel);
-
-  const defaultReasoningByAccess: Partial<Record<AgentModelAccess, string>> = {};
-  if (chatgptDefault) {
-    const chatgptReasoning = pickRuntimeDefaultReasoning(
-      reasoningOptionsByModel[chatgptDefault] ?? [],
-      configuredReasoningEffort,
-      defaultReasoningByModel[chatgptDefault] ?? null,
-    );
-    if (chatgptReasoning) defaultReasoningByAccess.chatgpt = chatgptReasoning;
-  }
-  if (apiDefault) {
-    const apiReasoning = pickRuntimeDefaultReasoning(
-      reasoningOptionsByModel[apiDefault] ?? [],
-      configuredReasoningEffort,
-      defaultReasoningByModel[apiDefault] ?? null,
-    );
-    if (apiReasoning) defaultReasoningByAccess.api = apiReasoning;
-  }
-
-  return {
-    agent: "codex",
-    customModelPlaceholder: fallbackPlaceholder,
-    defaultModelByAccess: {
-      ...(chatgptDefault ? { chatgpt: chatgptDefault } : {}),
-      ...(apiDefault ? { api: apiDefault } : {}),
-    },
-    defaultReasoningByAccess,
-    modelsByAccess: {
-      chatgpt: chatgptModels,
-      api: apiModels,
-    },
-    defaultReasoningByModel,
-    reasoningOptionsByModel,
-  };
-}
-
-function formatClaudeModelLabel(model: string): string {
-  const normalized = model.trim().toLowerCase();
-  if (normalized === "opus") return "Claude Opus";
-  if (normalized === "sonnet") return "Claude Sonnet";
-  if (normalized === "haiku") return "Claude Haiku";
-
-  const match = normalized.match(/^claude-(sonnet|opus|haiku)-(\d+)-(\d+)(?:-(\d{8}))?$/);
-  if (!match) {
-    return normalized
-      .split(/[-_]+/g)
-      .filter(Boolean)
-      .map((part) => part[0]?.toUpperCase() + part.slice(1))
-      .join(" ");
-  }
-
-  const family = match[1];
-  const major = match[2];
-  const minor = match[3];
-  return `Claude ${family[0]?.toUpperCase() + family.slice(1)} ${major}.${minor}`;
-}
-
-function getClaudeAccessForModel(model: string): AgentModelAccess[] {
-  const normalized = model.trim().toLowerCase();
-  if (normalized === "opus" || normalized.includes("claude-opus")) {
-    return ["max", "api"];
-  }
-  if (normalized === "haiku" || normalized.includes("claude-haiku")) {
-    return ["pro", "max", "api"];
-  }
-  return ["pro", "max", "api"];
-}
-
-function toRuntimeModelOption(
-  id: string,
-  description: string,
-  access: AgentModelAccess[],
-  labelFormatter: (value: string) => string,
-): AgentModelOption {
-  return {
-    id,
-    label: labelFormatter(id),
-    description,
-    access,
-  };
-}
-
-function resolveClaudeConfiguredModel(
-  configuredModel: string | null,
-  availableModels: AgentModelOption[],
-  family: "sonnet" | "opus" | "haiku",
-): string | null {
-  if (!configuredModel) return null;
-  const normalized = configuredModel.trim().toLowerCase();
-  if (availableModels.some((model) => model.id === normalized)) {
-    return normalized;
-  }
-  if (normalized === family) {
-    return availableModels.find((model) => model.id.toLowerCase().includes(`claude-${family}`))?.id ?? null;
-  }
-  return null;
-}
-
-function collectClaudeStatsModels(stats: ClaudeStatsCache | null): string[] {
-  const entries = Array.isArray(stats?.dailyModelTokens) ? stats.dailyModelTokens : [];
-  const seen = new Set<string>();
-  const ordered: string[] = [];
-
-  for (const entry of [...entries].reverse()) {
-    const tokensByModel = toObject(entry.tokensByModel);
-    for (const model of Object.keys(tokensByModel)) {
-      const normalized = model.trim();
-      if (!normalized.startsWith("claude-") || seen.has(normalized)) continue;
-      seen.add(normalized);
-      ordered.push(normalized);
-    }
-  }
-
-  return ordered;
-}
-
-async function readCommandHelp(commands: string[]): Promise<string | null> {
-  for (const command of commands) {
-    try {
-      const result = await execFileAsync(command, ["--help"], {
-        encoding: "utf8",
-        timeout: 1_500,
-        windowsHide: true,
-        maxBuffer: 256_000,
-      }) as { stdout?: string; stderr?: string };
-      const output = `${result.stdout ?? ""}\n${result.stderr ?? ""}`.trim();
-      if (output.length > 0) {
-        return output;
-      }
-    } catch {
-      // Try the next alias.
-    }
-  }
-  return null;
-}
-
-async function detectReasoningOptionsFromHelp(commands: string[]): Promise<AgentReasoningOption[]> {
-  const help = await readCommandHelp(commands);
-  if (!help) return [];
-
-  const match = help.match(/--effort\s+<[^>]+>.*?\(([^)]+)\)/s);
-  if (!match?.[1]) return [];
-
-  return uniqueStringValues(
-    match[1]
-      .split(",")
-      .map((value) => value.trim().toLowerCase()),
-  ).map((effort) => toReasoningOption(effort));
-}
-
-async function buildClaudeRuntimeModelCatalog(): Promise<RuntimeAgentModelCatalog | null> {
-  const settings = await readJsonFileIfPresent<ClaudeSettings>(join(homedir(), ".claude", "settings.json"));
-  const stats = await readJsonFileIfPresent<ClaudeStatsCache>(join(homedir(), ".claude", "stats-cache.json"));
-  const reasoningOptions = await detectReasoningOptionsFromHelp(["claude", "claude-code", "cc"]);
-  const discoveredModels = collectClaudeStatsModels(stats);
-  const configuredModel = typeof settings?.model === "string" ? settings.model.trim().toLowerCase() : null;
-
-  const availableModels = uniqueModelOptions(discoveredModels.map((model) => {
-    return toRuntimeModelOption(
-      model,
-      `Model discovered from the local Claude Code installation (${model}).`,
-      getClaudeAccessForModel(model),
-      formatClaudeModelLabel,
-    );
-  }));
-
-  if (availableModels.length === 0 && !configuredModel) {
-    return null;
-  }
-
-  const allModels = availableModels.length > 0
-    ? availableModels
-    : [
-        toRuntimeModelOption(
-          configuredModel ?? "sonnet",
-          "Model configured in the local Claude Code settings.",
-          getClaudeAccessForModel(configuredModel ?? "sonnet"),
-          formatClaudeModelLabel,
-        ),
-      ];
-
-  const proModels = allModels.filter((model) => model.access.includes("pro"));
-  const maxModels = allModels.filter((model) => model.access.includes("max"));
-  const apiModels = allModels.filter((model) => model.access.includes("api"));
-
-  const defaultModelByAccess: Partial<Record<AgentModelAccess, string>> = {};
-  const proDefault = resolveClaudeConfiguredModel(configuredModel, proModels, "sonnet") ?? proModels[0]?.id ?? null;
-  const maxDefault = resolveClaudeConfiguredModel(configuredModel, maxModels, "opus")
-    ?? maxModels.find((model) => model.id.toLowerCase().includes("claude-opus"))?.id
-    ?? maxModels[0]?.id
-    ?? null;
-  const apiDefault = resolveClaudeConfiguredModel(configuredModel, apiModels, "sonnet") ?? apiModels[0]?.id ?? null;
-
-  if (proDefault) defaultModelByAccess.pro = proDefault;
-  if (maxDefault) defaultModelByAccess.max = maxDefault;
-  if (apiDefault) defaultModelByAccess.api = apiDefault;
-
-  const defaultReasoning = settings?.alwaysThinkingEnabled === true ? "high" : "medium";
-  const defaultReasoningByAccess: Partial<Record<AgentModelAccess, string>> = {};
-  for (const access of ["pro", "max", "api"] as const) {
-    const resolvedDefault = pickRuntimeDefaultReasoning(reasoningOptions, defaultReasoning, defaultReasoning);
-    if (resolvedDefault) {
-      defaultReasoningByAccess[access] = resolvedDefault;
-    }
-  }
-
-  return {
-    agent: "claude-code",
-    customModelPlaceholder: configuredModel || allModels[0]?.id || "",
-    defaultModelByAccess,
-    defaultReasoningByAccess,
-    modelsByAccess: {
-      ...(proModels.length > 0 ? { pro: proModels } : {}),
-      ...(maxModels.length > 0 ? { max: maxModels } : {}),
-      ...(apiModels.length > 0 ? { api: apiModels } : {}),
-    },
-    ...(reasoningOptions.length > 0
-      ? {
-          reasoningOptionsByAccess: {
-            pro: reasoningOptions,
-            max: reasoningOptions,
-            api: reasoningOptions,
-          },
-        }
-      : {}),
-  };
-}
-
-async function collectRecentFiles(rootDir: string, options: RecentFileMatchOptions = {}): Promise<string[]> {
-  const maxDepth = options.maxDepth ?? 5;
-  const maxFiles = options.maxFiles ?? 24;
-  const maxDirectories = options.maxDirectories ?? 64;
-  const extensions = new Set((options.extensions ?? []).map((value) => value.toLowerCase()));
-  const files: Array<{ path: string; mtimeMs: number }> = [];
-  let visitedDirectories = 0;
-
-  async function walk(currentDir: string, depth: number): Promise<void> {
-    if (depth > maxDepth || visitedDirectories >= maxDirectories) return;
-    visitedDirectories += 1;
-
-    let entries;
-    try {
-      entries = await readdir(currentDir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-
-    if (files.length >= maxFiles * 3 && depth > 1) {
-      return;
-    }
-
-    await Promise.all(entries.map(async (entry) => {
-      const fullPath = join(currentDir, entry.name);
-      if (entry.isDirectory()) {
-        await walk(fullPath, depth + 1);
-        return;
-      }
-      if (!entry.isFile()) return;
-      if (options.filenamePattern && !options.filenamePattern.test(entry.name)) return;
-      if (extensions.size > 0 && !extensions.has(extname(entry.name).toLowerCase())) return;
-
-      try {
-        const fileStats = await stat(fullPath);
-        files.push({ path: fullPath, mtimeMs: fileStats.mtimeMs });
-      } catch {
-        // Ignore files that disappear during the scan.
-      }
-    }));
-  }
-
-  await walk(rootDir, 0);
-
-  return files
-    .sort((left, right) => right.mtimeMs - left.mtimeMs)
-    .slice(0, maxFiles)
-    .map((entry) => entry.path);
-}
-
-async function collectRegexMatchesFromRecentFiles(
-  rootDir: string,
-  pattern: RegExp,
-  options: RecentFileMatchOptions = {},
-): Promise<string[]> {
-  const files = await collectRecentFiles(rootDir, options);
-  const matches: string[] = [];
-  const seen = new Set<string>();
-
-  for (const file of files) {
-    const contents = await readTextFileIfPresent(file);
-    if (!contents) continue;
-
-    pattern.lastIndex = 0;
-    let match: RegExpExecArray | null = null;
-    while ((match = pattern.exec(contents)) !== null) {
-      const rawValue = match[1]?.trim();
-      if (!rawValue || seen.has(rawValue)) continue;
-      seen.add(rawValue);
-      matches.push(rawValue);
-    }
-  }
-
-  return matches;
-}
-
-function formatGeminiModelLabel(model: string): string {
-  return model
-    .trim()
-    .split(/[-_]+/g)
-    .filter(Boolean)
-    .map((part, index) => {
-      if (index === 0) return part[0]?.toUpperCase() + part.slice(1);
-      if (/^\d+(?:\.\d+)?$/.test(part)) return part;
-      return part[0]?.toUpperCase() + part.slice(1);
-    })
-    .join(" ");
-}
-
-async function buildGeminiRuntimeModelCatalog(): Promise<RuntimeAgentModelCatalog | null> {
-  const settings = await readJsonFileIfPresent<SimpleAuthSettings>(join(homedir(), ".gemini", "settings.json"));
-  const models = await collectRegexMatchesFromRecentFiles(
-    join(homedir(), ".gemini"),
-    /"(?:model|modelVersion)"\s*:\s*"([^"]+)"/g,
-    { extensions: [".json", ".jsonl"], filenamePattern: /\.(json|jsonl)$/i, maxDepth: 4, maxFiles: 12, maxDirectories: 48 },
-  );
-
-  if (models.length === 0) {
-    return null;
-  }
-
-  const runtimeModels = uniqueModelOptions(models.map((model) => toRuntimeModelOption(
-    model,
-    `Model discovered from the local Gemini CLI installation (${model}).`,
-    ["oauth", "api"],
-    formatGeminiModelLabel,
-  )));
-  const selectedType = typeof settings?.security?.auth?.selectedType === "string"
-    ? settings.security.auth.selectedType.trim().toLowerCase()
-    : null;
-  const defaultModel = runtimeModels[0]?.id ?? null;
-
-  return {
-    agent: "gemini",
-    customModelPlaceholder: defaultModel ?? "",
-    defaultModelByAccess: {
-      ...(defaultModel ? { oauth: defaultModel, api: defaultModel } : {}),
-    },
-    modelsByAccess: {
-      oauth: runtimeModels,
-      api: runtimeModels,
-    },
-    defaultReasoningByAccess: {},
-    ...(selectedType?.includes("oauth")
-      ? { customModelPlaceholder: defaultModel ?? "" }
-      : {}),
-  };
-}
-
-function formatQwenModelLabel(model: string): string {
-  return model
-    .trim()
-    .split(/[-_]+/g)
-    .filter(Boolean)
-    .map((part) => part[0]?.toUpperCase() + part.slice(1))
-    .join(" ");
-}
-
-async function buildQwenRuntimeModelCatalog(): Promise<RuntimeAgentModelCatalog | null> {
-  const models = await collectRegexMatchesFromRecentFiles(
-    join(homedir(), ".qwen"),
-    /"(?:model|modelVersion)"\s*:\s*"([^"]+)"/g,
-    { extensions: [".json", ".jsonl"], filenamePattern: /\.(json|jsonl)$/i, maxDepth: 5, maxFiles: 12, maxDirectories: 48 },
-  );
-
-  if (models.length === 0) {
-    return null;
-  }
-
-  const runtimeModels = uniqueModelOptions(models.map((model) => toRuntimeModelOption(
-    model,
-    `Model discovered from the local Qwen Code installation (${model}).`,
-    ["oauth", "api"],
-    formatQwenModelLabel,
-  )));
-  const defaultModel = runtimeModels[0]?.id ?? null;
-
-  return {
-    agent: "qwen-code",
-    customModelPlaceholder: defaultModel ?? "",
-    defaultModelByAccess: {
-      ...(defaultModel ? { oauth: defaultModel, api: defaultModel } : {}),
-    },
-    modelsByAccess: {
-      oauth: runtimeModels,
-      api: runtimeModels,
-    },
-    defaultReasoningByAccess: {},
-  };
-}
-
-async function loadRuntimeAgentModelCatalog(agent: string): Promise<RuntimeAgentModelCatalog | null> {
-  const normalizedAgent = agent.trim().toLowerCase();
-
-  if (normalizedAgent === "codex") {
-    const contents = await readTextFileIfPresent(join(homedir(), ".codex", "models_cache.json"));
-    if (!contents) return null;
-
-    try {
-      const parsed = JSON.parse(contents) as unknown;
-      const configuredState = await readCodexConfiguredState();
-      return parseCodexRuntimeModelCatalog(
-        parsed,
-        configuredState.model,
-        configuredState.reasoningEffort,
-      );
-    } catch {
-      return null;
-    }
-  }
-
-  if (normalizedAgent === "claude-code") {
-    return buildClaudeRuntimeModelCatalog();
-  }
-
-  if (normalizedAgent === "gemini") {
-    return buildGeminiRuntimeModelCatalog();
-  }
-
-  if (normalizedAgent === "qwen-code") {
-    return buildQwenRuntimeModelCatalog();
-  }
-
-  return null;
-}
-
-export async function getRuntimeAgentModelCatalog(agent: string): Promise<RuntimeAgentModelCatalog | null> {
-  const normalizedAgent = agent.trim().toLowerCase();
-  if (!normalizedAgent) {
-    return null;
-  }
-
-  const now = Date.now();
-  const cached = runtimeModelCatalogCache.get(normalizedAgent);
-  if (cached && cached.expiresAt > now) {
-    return cached.value;
-  }
-
-  const inFlight = runtimeModelCatalogInflight.get(normalizedAgent);
-  if (inFlight) {
-    return inFlight;
-  }
-
-  const promise = loadRuntimeAgentModelCatalog(normalizedAgent)
-    .then((value) => {
-      runtimeModelCatalogCache.set(normalizedAgent, {
-        value,
-        expiresAt: Date.now() + RUNTIME_MODEL_CATALOG_TTL_MS,
-      });
-      return value;
-    })
-    .finally(() => {
-      runtimeModelCatalogInflight.delete(normalizedAgent);
-    });
-
-  runtimeModelCatalogInflight.set(normalizedAgent, promise);
-  return promise;
-}
-
-export async function getResolvedDefaultAgentModel(
-  agent: string,
-  preferences?: ModelAccessPreferences | null,
-): Promise<string | null> {
-  const runtimeCatalog = await getRuntimeAgentModelCatalog(agent);
-  const access = resolveAgentModelAccess(agent, preferences);
-  return getRuntimeCatalogDefaultModelForAccess(runtimeCatalog, access);
-}
-
-export async function getResolvedDefaultAgentReasoningEffort(
-  agent: string,
-  preferences?: ModelAccessPreferences | null,
-  model?: string | null,
-): Promise<string | null> {
-  const runtimeCatalog = await getRuntimeAgentModelCatalog(agent);
-  const access = resolveAgentModelAccess(agent, preferences);
-  const resolvedModel = model?.trim()
-    || getRuntimeCatalogDefaultModelForAccess(runtimeCatalog, access);
-  return getRuntimeCatalogDefaultReasoning(runtimeCatalog, resolvedModel, access);
-}