@tonyclaw/agent-inspector 3.1.32 → 4.0.2

package/src/proxy/providers.ts

@@ -1,998 +0,0 @@
-import { z } from "zod";
-import Conf from "conf";
-import { randomUUID } from "crypto";
-import { existsSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { maskApiKey } from "../lib/mask";
-import { logger } from "./logger";
-import { getDataDir, hasExplicitDataDir } from "./dataDir";
-import {
-  ProviderConfigSchema,
-  ProviderModelMetadataListSchema,
-  ProviderModelNameSchema,
-  ProviderModelsSchema,
-  REDACTED_PROVIDER_API_KEY,
-  toRedactedProviderDto,
-  toRedactedProviderDtos,
-  type ProviderConfig,
-  type ProviderModelMetadata,
-  type RedactedProviderDto,
-} from "../lib/providerContract";
-import { withBuiltinProviderModelMetadata } from "../lib/providerModelMetadata";
-import {
-  createProviderSecretStore,
-  secretValuesEqual,
-  type ProviderSecretStore,
-} from "./providerSecretStore";
-import {
-  ensurePrivateDirectorySync,
-  PRIVATE_FILE_MODE,
-  securePrivateFileSync,
-} from "./privateDataPath";
-
-export { ProviderConfigSchema };
-export type { ProviderConfig };
-
-const ProvidersStoreSchema = z.object({
-  providers: z.array(ProviderConfigSchema),
-});
-
-type ProvidersStore = z.infer<typeof ProvidersStoreSchema>;
-
-function normalizeMetadataModelName(value: string): string {
-  return value.trim().toLowerCase().replace(/\s+/g, "-");
-}
-
-function mergeModelMetadata(
-  existing: readonly ProviderModelMetadata[] | undefined,
-  incoming: readonly ProviderModelMetadata[] | undefined,
-): ProviderModelMetadata[] | undefined {
-  if (existing === undefined && incoming === undefined) return undefined;
-
-  const merged = new Map<string, ProviderModelMetadata>();
-  for (const metadata of existing ?? []) {
-    merged.set(normalizeMetadataModelName(metadata.model), metadata);
-  }
-  for (const metadata of incoming ?? []) {
-    merged.set(normalizeMetadataModelName(metadata.model), metadata);
-  }
-
-  return [...merged.values()].toSorted((left, right) => left.model.localeCompare(right.model));
-}
-
-const LegacyProviderConfigSchema = z.object({
-  id: z.string().optional(),
-  name: z.string().optional(),
-  type: z.enum(["anthropic", "openai"]).optional(),
-  format: z.enum(["anthropic", "openai"]).optional(),
-  apiKey: z.string().optional(),
-  model: ProviderModelNameSchema.optional(),
-  models: ProviderModelsSchema.optional(),
-  baseUrl: z.string().optional(),
-  anthropicBaseUrl: z.string().optional(),
-  openaiBaseUrl: z.string().optional(),
-  openaiResponsesBaseUrl: z.string().optional(),
-  authHeader: z.enum(["bearer", "x-api-key"]).optional(),
-  apiDocsUrl: z.string().optional(),
-  modelMetadataUrl: z.string().optional(),
-  modelMetadata: ProviderModelMetadataListSchema.optional(),
-  source: z.enum(["company", "personal"]).optional(),
-  createdAt: z.string().optional(),
-  updatedAt: z.string().optional(),
-});
-
-export type LegacyProviderConfig = z.infer<typeof LegacyProviderConfigSchema>;
-
-const LegacyProviderStoreSchema = z.object({
-  providers: z.array(LegacyProviderConfigSchema),
-});
-
-function legacyModels(provider: LegacyProviderConfig): string[] {
-  const modelList = provider.models?.map((model) => model.trim()).filter((model) => model !== "");
-  if (modelList !== undefined && modelList.length > 0) return modelList;
-  const model = provider.model?.trim();
-  if (model !== undefined && model !== "") return [model];
-  return [""];
-}
-
-export function migrateLegacyProvider(
-  provider: LegacyProviderConfig,
-  index: number,
-  now: string,
-): ProviderConfig | null {
-  const apiKey = normalizeApiKey(provider.apiKey ?? "");
-  if (apiKey === "") return null;
-
-  const format = provider.format ?? provider.type;
-  const fallbackName =
-    format === "openai" ? "OpenAI" : format === "anthropic" ? "Anthropic" : "Legacy Provider";
-  const trimmedName = provider.name?.trim();
-  const name =
-    trimmedName !== undefined && trimmedName !== "" ? trimmedName : `${fallbackName} ${index + 1}`;
-  const baseUrl = provider.baseUrl;
-  const anthropicBaseUrl =
-    provider.anthropicBaseUrl ?? (format === "anthropic" && baseUrl !== undefined ? baseUrl : "");
-  const openaiBaseUrl =
-    provider.openaiBaseUrl ?? (format === "openai" && baseUrl !== undefined ? baseUrl : "");
-  const openaiResponsesBaseUrl = provider.openaiResponsesBaseUrl ?? "";
-
-  const candidate: ProviderConfig = {
-    id: provider.id ?? randomUUID(),
-    name,
-    apiKey,
-    model: provider.model,
-    models: legacyModels(provider),
-    format,
-    baseUrl,
-    anthropicBaseUrl,
-    openaiBaseUrl,
-    openaiResponsesBaseUrl,
-    authHeader: provider.authHeader ?? "bearer",
-    apiDocsUrl: provider.apiDocsUrl,
-    modelMetadataUrl: provider.modelMetadataUrl,
-    modelMetadata: provider.modelMetadata,
-    source: provider.source,
-    createdAt: provider.createdAt ?? now,
-    updatedAt: provider.updatedAt ?? now,
-  };
-
-  const parsed = ProviderConfigSchema.safeParse(candidate);
-  return parsed.success ? withBuiltinProviderModelMetadata(parsed.data, now) : null;
-}
-
-function migrateFromDataDirConfig(targetStore: Conf<ProvidersStore>, dataDirPath: string): void {
-  if (process.env["AGENT_INSPECTOR_CONFIG_PATH"] !== undefined) return;
-  if (targetStore.get("providers", []).length > 0) return;
-
-  const legacyConfigPath = join(dataDirPath, "config.json");
-  if (!existsSync(legacyConfigPath)) return;
-
-  try {
-    const raw = readFileSync(legacyConfigPath, "utf-8");
-    const parsedJson: unknown = JSON.parse(raw);
-    const parsed = LegacyProviderStoreSchema.safeParse(parsedJson);
-    if (!parsed.success) return;
-
-    const now = new Date().toISOString();
-    const migrated: ProviderConfig[] = [];
-    for (let index = 0; index < parsed.data.providers.length; index++) {
-      const provider = parsed.data.providers[index];
-      if (provider === undefined) continue;
-      const current = migrateLegacyProvider(provider, index, now);
-      if (current !== null) migrated.push(current);
-    }
-    if (migrated.length === 0) return;
-
-    if (!persistProviders(migrated)) {
-      logger.warn(`[providers] Data-dir config migration left ${targetStore.path} unchanged`);
-      return;
-    }
-    logger.info(
-      `[providers] Migrated ${migrated.length} provider(s) from ${legacyConfigPath} to ${targetStore.path}`,
-    );
-  } catch (err) {
-    logger.warn(`[providers] Data-dir config migration failed: ${String(err)}`);
-  }
-}
-
-/**
- * One-time migration from the legacy conf v15 default location
- * (`%APPDATA%\agent-inspector-nodejs\Config\config.json` on Windows,
- * `$XDG_CONFIG_HOME/agent-inspector-nodejs/Config/config.json` on Linux).
- * Older versions of agent-inspector let the `conf` library pick the path,
- * which produced a project-suffixed directory under the OS user-config
- * root. Users who upgrade now have their providers copied to the new
- * `<dataDir>/providers.json` location; the legacy file is left in
- * place for safety and can be deleted manually.
- *
- * The check is "new store is still empty" rather than "new file doesn't
- * exist" because `Conf` materialises the defaults file on construction
- * — so the file is always present immediately after the `new Conf()`
- * call above, even on a brand-new install.
- */
-function migrateFromLegacyConfLocation(targetStore: Conf<ProvidersStore>): void {
-  if (process.env["AGENT_INSPECTOR_CONFIG_PATH"] !== undefined) return;
-  if (hasExplicitDataDir()) return;
-  if (targetStore.get("providers", []).length > 0) return;
-  let legacyStore: Conf<ProvidersStore> | undefined;
-  try {
-    legacyStore = new Conf<ProvidersStore>({
-      projectName: "agent-inspector",
-      defaults: { providers: [] },
-    });
-    const legacyProviders = legacyStore.get("providers", []);
-    if (legacyProviders.length === 0) return;
-    const now = new Date().toISOString();
-    const migrated = legacyProviders.map((provider) =>
-      withBuiltinProviderModelMetadata(provider, now),
-    );
-    if (!persistProviders(migrated)) {
-      logger.warn(`[providers] Legacy migration left ${targetStore.path} unchanged`);
-      return;
-    }
-    logger.info(
-      `[providers] Migrated ${legacyProviders.length} provider(s) from ${legacyStore.path} to ${targetStore.path}`,
-    );
-  } catch (err) {
-    logger.warn(`[providers] Legacy migration failed: ${String(err)}`);
-  } finally {
-    legacyStore?._closeWatcher();
-  }
-}
-
-// Provider metadata uses Conf; API keys are stored separately by ProviderSecretStore.
-const configPath = process.env["AGENT_INSPECTOR_CONFIG_PATH"];
-
-// The data directory is shared with the runtime config (`config.ts`).
-// We pass `cwd` so conf writes the file as `<cwd>/<configName>.<ext>`,
-// i.e. `<dataDir>/providers.json`. The runtime config lives at
-// `<dataDir>/config.json`; the different filenames keep the two stores
-// from overwriting each other.
-const dataDir = getDataDir();
-const providerDataDir = configPath === undefined ? dataDir : dirname(configPath);
-if (!ensurePrivateDirectorySync(providerDataDir)) {
-  logger.error(`[providers] Could not secure provider data directory ${providerDataDir}`);
-}
-
-export const store = new Conf<ProvidersStore>({
-  cwd: dataDir,
-  configName: "providers",
-  defaults: {
-    providers: [],
-  },
-  ...(configPath !== undefined ? { path: configPath } : {}),
-});
-
-const providerSecretStore: ProviderSecretStore = createProviderSecretStore(dirname(store.path));
-
-function providerMetadataStorageIsPrivate(forceFile = false): boolean {
-  if (!ensurePrivateDirectorySync(dirname(store.path))) return false;
-  if (!existsSync(store.path)) return true;
-  return securePrivateFileSync(store.path, forceFile);
-}
-
-function writeProviderMetadata(providers: readonly ProviderConfig[]): boolean {
-  if (!providerMetadataStorageIsPrivate()) {
-    logger.error(`[providers] Refusing provider metadata write to unsafe path ${store.path}`);
-    return false;
-  }
-  try {
-    store.set("providers", [...providers]);
-  } catch (error) {
-    logger.error(`[providers] Could not persist provider metadata: ${String(error)}`);
-    return false;
-  }
-  if (securePrivateFileSync(store.path, true)) return true;
-  logger.error(`[providers] Could not secure provider metadata at ${store.path}`);
-  return false;
-}
-
-if (!providerMetadataStorageIsPrivate(true)) {
-  logger.error(`[providers] Provider metadata path is not private: ${store.path}`);
-}
-
-function providerWithResolvedSecret(provider: ProviderConfig): ProviderConfig | null {
-  if (!providerSecretStore.isReference(provider.apiKey)) {
-    logger.error(
-      `[providers] Refusing plaintext secret for provider ${provider.id}; secure migration is required`,
-    );
-    return null;
-  }
-  const apiKey = providerSecretStore.read(provider.apiKey);
-  if (apiKey !== null) return { ...provider, apiKey };
-  logger.error(`[providers] Secret is missing or unreadable for provider "${provider.name}"`);
-  return null;
-}
-
-function persistProviders(
-  providers: readonly ProviderConfig[],
-  removedProviderIds: ReadonlySet<string> = new Set(),
-): boolean {
-  const existingReferences = new Map<string, string>();
-  const unresolvedRecords = new Map<string, ProviderConfig>();
-  for (const candidate of store.get("providers", [])) {
-    const parsed = ProviderConfigSchema.safeParse(candidate);
-    if (parsed.success && providerSecretStore.isReference(parsed.data.apiKey)) {
-      existingReferences.set(parsed.data.id, parsed.data.apiKey);
-      if (providerSecretStore.read(parsed.data.apiKey) === null) {
-        unresolvedRecords.set(parsed.data.id, parsed.data);
-      }
-    }
-  }
-
-  const persisted: ProviderConfig[] = [];
-  for (const provider of providers) {
-    const existingReference = existingReferences.get(provider.id);
-    if (existingReference !== undefined) {
-      const existingSecret = providerSecretStore.read(existingReference);
-      if (existingSecret !== null && secretValuesEqual(existingSecret, provider.apiKey)) {
-        persisted.push({ ...provider, apiKey: existingReference });
-        continue;
-      }
-    }
-
-    const reference = providerSecretStore.write(provider.id, provider.apiKey);
-    if (reference !== null) {
-      persisted.push({ ...provider, apiKey: reference });
-      continue;
-    }
-    logger.error(
-      `[providers] Secret store unavailable; refusing to persist provider ${provider.id}`,
-    );
-    return false;
-  }
-  const persistedIds = new Set(persisted.map((provider) => provider.id));
-  for (const [id, provider] of unresolvedRecords) {
-    if (!persistedIds.has(id) && !removedProviderIds.has(id)) persisted.push(provider);
-  }
-  return writeProviderMetadata(persisted);
-}
-
-function migratePlaintextProviderSecrets(): boolean {
-  const raw = store.get("providers", []);
-  let changed = false;
-  const migrated: ProviderConfig[] = [];
-  for (const candidate of raw) {
-    const parsed = ProviderConfigSchema.safeParse(candidate);
-    if (!parsed.success) {
-      migrated.push(candidate);
-      continue;
-    }
-    if (providerSecretStore.isReference(parsed.data.apiKey)) {
-      migrated.push(parsed.data);
-      continue;
-    }
-    const reference = providerSecretStore.write(parsed.data.id, parsed.data.apiKey);
-    if (reference === null) {
-      logger.error(
-        `[providers] Could not migrate provider ${parsed.data.id} to secure storage; leaving the existing file unchanged`,
-      );
-      return false;
-    }
-    changed = true;
-    migrated.push({ ...parsed.data, apiKey: reference });
-  }
-  if (!changed) return true;
-  if (writeProviderMetadata(migrated)) return true;
-  logger.error("[providers] Could not finish provider secret migration");
-  return false;
-}
-
-function sanitizeProviderBackupValue(value: unknown): unknown {
-  if (Array.isArray(value)) return value.map(sanitizeProviderBackupValue);
-  if (value === null || typeof value !== "object") return value;
-
-  return Object.fromEntries(
-    Object.entries(value).map(([key, entry]) => {
-      if (key === "apiKey" && typeof entry === "string") {
-        return [key, "redacted"];
-      }
-      return [key, sanitizeProviderBackupValue(entry)];
-    }),
-  );
-}
-
-function sanitizeProviderBackup(): void {
-  const backupPath = `${store.path}.bak`;
-  if (!existsSync(backupPath)) return;
-
-  const temporaryPath = `${backupPath}.${String(process.pid)}.tmp`;
-  try {
-    const parsed: unknown = JSON.parse(readFileSync(backupPath, "utf-8"));
-    const sanitized = sanitizeProviderBackupValue(parsed);
-    writeFileSync(temporaryPath, JSON.stringify(sanitized, null, 2), {
-      encoding: "utf8",
-      mode: PRIVATE_FILE_MODE,
-    });
-    if (!securePrivateFileSync(temporaryPath, true)) {
-      rmSync(temporaryPath, { force: true });
-      rmSync(backupPath, { force: true });
-      logger.error("[providers] Removed provider backup after temporary permission failure");
-      return;
-    }
-    renameSync(temporaryPath, backupPath);
-    if (!securePrivateFileSync(backupPath, true)) {
-      rmSync(backupPath, { force: true });
-      logger.error("[providers] Removed provider backup after permission failure");
-    }
-  } catch (error) {
-    rmSync(temporaryPath, { force: true });
-    rmSync(backupPath, { force: true });
-    logger.error(
-      `[providers] Removed provider backup that could not be sanitized: ${String(error)}`,
-    );
-  }
-}
-
-// Older builds stored providers in `<dataDir>/config.json`. Migrate that
-// shape before checking the older Conf-managed default location.
-migrateFromDataDirConfig(store, dataDir);
-
-// Run the legacy migration once on module load. No-op when the new file
-// already has data, when the user has set AGENT_INSPECTOR_CONFIG_PATH or
-// an explicit data dir, or when the legacy file is empty.
-migrateFromLegacyConfLocation(store);
-sanitizeProviderBackup();
-const providerSecretsReady = migratePlaintextProviderSecrets();
-
-/**
- * Expands the old `{ format, baseUrl }` representation into the matching
- * format-specific URL. Once either format-specific field exists, the record is
- * already on the current schema and must be preserved exactly: an empty or
- * missing counterpart means that API format was intentionally not configured.
- */
-export function migrateProvider(p: ProviderConfig): ProviderConfig {
-  if (
-    p.anthropicBaseUrl !== undefined ||
-    p.openaiBaseUrl !== undefined ||
-    p.openaiResponsesBaseUrl !== undefined
-  ) {
-    return p;
-  }
-  if (p.format === undefined || p.baseUrl === undefined || p.baseUrl === "") {
-    return p;
-  }
-
-  return p.format === "openai"
-    ? { ...p, anthropicBaseUrl: "", openaiBaseUrl: p.baseUrl, openaiResponsesBaseUrl: "" }
-    : { ...p, anthropicBaseUrl: p.baseUrl, openaiBaseUrl: "", openaiResponsesBaseUrl: "" };
-}
-
-/**
- * Migrates existing provider configs to preserve Anthropic and OpenAI routing URLs.
- */
-function migrateProviders(): void {
-  const providers = getProviders();
-  const updated = providers.map(migrateProvider);
-  const migrated = updated.some((p, i) => JSON.stringify(p) !== JSON.stringify(providers[i]));
-
-  if (migrated) {
-    void persistProviders(updated);
-  }
-}
-
-// Run migration on module load
-if (providerSecretsReady) migrateProviders();
-
-/**
- * Migrate: merge providers with identical API key and routing URLs.
- * into multi-model providers. Existing single-model providers get their `model`
- * value promoted to `models: [model]`.
- */
-function migrateMultiModel(): void {
-  const providers = getProviders();
-  if (providers.length === 0) return;
-  let changed = false;
-
-  // Step 1: Promote single model to models array for any provider missing models
-  const promoted = providers.map((p) => {
-    if (p.models !== undefined && p.models.length > 0) return p;
-    const models = p.model !== undefined && p.model !== "" ? [p.model] : [];
-    changed = true;
-    return { ...p, models };
-  });
-
-  // Step 2: Merge providers with the same API key and routing URLs.
-  const groups = new Map<string, ProviderConfig[]>();
-  for (const p of promoted) {
-    const key = `${p.apiKey}::${p.anthropicBaseUrl ?? ""}::${p.openaiBaseUrl ?? ""}::${p.openaiResponsesBaseUrl ?? ""}`;
-    const group = groups.get(key);
-    if (group !== undefined) {
-      group.push(p);
-    } else {
-      groups.set(key, [p]);
-    }
-  }
-
-  const merged: ProviderConfig[] = [];
-  for (const group of groups.values()) {
-    const first = group[0];
-    if (group.length === 1 && first !== undefined) {
-      merged.push(first);
-      continue;
-    }
-    changed = true;
-    // Merge: keep the earliest provider's metadata, combine all models (deduplicated)
-    const sorted = group.toSorted(
-      (a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime(),
-    );
-    const earliest = sorted[0];
-    if (earliest === undefined) continue;
-    const allModels = new Set<string>();
-    for (const p of sorted) {
-      for (const m of p.models ?? []) {
-        if (m !== "") allModels.add(m);
-      }
-    }
-    // Take first non-empty source
-    const mergedSource = sorted.find((p) => p.source !== undefined)?.source;
-    merged.push({
-      ...earliest,
-      models: [...allModels],
-      source: mergedSource,
-      updatedAt: new Date().toISOString(),
-    });
-  }
-
-  if (changed && merged.length > 0) {
-    // Safety backup before writing
-    try {
-      writeFileSync(`${store.path}.bak`, readFileSync(store.path, "utf-8"), {
-        mode: PRIVATE_FILE_MODE,
-      });
-      sanitizeProviderBackup();
-    } catch {
-      // best-effort, ignore
-    }
-    void persistProviders(merged);
-  }
-}
-
-if (providerSecretsReady) migrateMultiModel();
-
-function migrateBuiltinModelMetadata(): void {
-  const providers = getProviders();
-  if (providers.length === 0) return;
-
-  const now = new Date().toISOString();
-  const updated = providers.map((provider) => withBuiltinProviderModelMetadata(provider, now));
-  const changed = updated.some(
-    (provider, index) => JSON.stringify(provider) !== JSON.stringify(providers[index]),
-  );
-
-  if (changed) {
-    void persistProviders(updated);
-  }
-}
-
-if (providerSecretsReady) migrateBuiltinModelMetadata();
-
-// Override with JSON env var if provided (for testing)
-const providersJson = process.env["AGENT_INSPECTOR_PROVIDERS_JSON"];
-if (providersJson !== undefined) {
-  try {
-    const parsed = ProviderConfigSchema.array().safeParse(JSON.parse(providersJson));
-    if (parsed.success) {
-      // Apply migration to JSON providers (e.g., convert baseUrl to openaiBaseUrl/anthropicBaseUrl)
-      const now = new Date().toISOString();
-      const migrated = parsed.data
-        .map(migrateProvider)
-        .map((provider) => withBuiltinProviderModelMetadata(provider, now));
-      void persistProviders(migrated);
-    }
-  } catch {
-    // Ignore invalid JSON
-  }
-}
-
-export function getProviders(): ProviderConfig[] {
-  const raw = store.get("providers", []);
-  // Validate the on-disk store entry-by-entry so a single corrupted record
-  // cannot wipe out the entire provider list. The whole-store safeParse was
-  // too strict — once any legacy/in-flight provider failed validation the
-  // whole list was discarded, which broke `updateProvider` and routing.
-  const valid: ProviderConfig[] = [];
-  for (const candidate of raw) {
-    const entry = ProviderConfigSchema.safeParse(candidate);
-    if (entry.success) {
-      const resolved = providerWithResolvedSecret(entry.data);
-      if (resolved !== null) valid.push(resolved);
-      continue;
-    }
-    let candidateName = "<unknown>";
-    if (typeof candidate === "object" && candidate !== null) {
-      const nameResult = z.object({ name: z.string() }).safeParse(candidate);
-      if (nameResult.success) candidateName = nameResult.data.name;
-    }
-    logger.warn(
-      `[providers] Skipping invalid on-disk provider "${candidateName}": ${entry.error.message}`,
-    );
-  }
-  return valid;
-}
-
-export function getProvider(id: string): ProviderConfig | undefined {
-  const providers = getProviders();
-  return providers.find((p) => p.id === id);
-}
-
-export function redactProvider(provider: ProviderConfig): RedactedProviderDto {
-  return toRedactedProviderDto(provider);
-}
-
-export function redactProviders(providers: readonly ProviderConfig[]): RedactedProviderDto[] {
-  return toRedactedProviderDtos(providers);
-}
-
-/**
- * Normalizes an API key by stripping "Bearer " prefix if present.
- */
-export function normalizeApiKey(apiKey: string): string {
-  return apiKey.replace(/^Bearer\s+/i, "").trim();
-}
-
-function providerUpdateApiKey(candidate: string | undefined, existingApiKey: string): string {
-  if (candidate === undefined) return existingApiKey;
-  const normalized = normalizeApiKey(candidate);
-  return normalized === REDACTED_PROVIDER_API_KEY ? existingApiKey : normalized;
-}
-
-export function addProvider(
-  name: string,
-  apiKey: string,
-  format?: "anthropic" | "openai",
-  baseUrl?: string,
-  models?: string[],
-  authHeader?: "bearer" | "x-api-key",
-  apiDocsUrl?: string,
-  anthropicBaseUrl?: string,
-  openaiBaseUrl?: string,
-  source?: "company" | "personal",
-  modelMetadataUrl?: string,
-  modelMetadata?: ProviderModelMetadata[],
-  openaiResponsesBaseUrl?: string,
-): ProviderConfig | null {
-  const providers = getProviders();
-  const normalizedKey = normalizeApiKey(apiKey);
-  const resolvedAnthropicUrl =
-    anthropicBaseUrl ?? (format === "anthropic" && baseUrl !== undefined ? baseUrl : "");
-  const resolvedOpenaiUrl =
-    openaiBaseUrl ?? (format === "openai" && baseUrl !== undefined ? baseUrl : "");
-  const resolvedOpenaiResponsesUrl = openaiResponsesBaseUrl ?? "";
-  const now = new Date().toISOString();
-
-  // If a provider with the same API key and routing URLs already exists,
-  // merge the new models into it instead of creating a duplicate.
-  const existing = providers.find(
-    (p) =>
-      secretValuesEqual(p.apiKey, normalizedKey) &&
-      (p.anthropicBaseUrl ?? "") === (resolvedAnthropicUrl ?? "") &&
-      (p.openaiBaseUrl ?? "") === (resolvedOpenaiUrl ?? "") &&
-      (p.openaiResponsesBaseUrl ?? "") === (resolvedOpenaiResponsesUrl ?? ""),
-  );
-  if (existing) {
-    const existingIndex = providers.findIndex((p) => p.id === existing.id);
-    const newModels = (models ?? []).filter((m) => m !== "");
-    existing.modelMetadataUrl = modelMetadataUrl ?? existing.modelMetadataUrl;
-    existing.modelMetadata = mergeModelMetadata(existing.modelMetadata, modelMetadata);
-    if (newModels.length > 0) {
-      const mergedModels = new Set(existing.models ?? []);
-      for (const m of newModels) mergedModels.add(m);
-      existing.models = [...mergedModels];
-    }
-    existing.updatedAt = now;
-    const enriched = withBuiltinProviderModelMetadata(existing, now);
-    if (existingIndex >= 0) {
-      providers[existingIndex] = enriched;
-    }
-    if (!persistProviders(providers)) return null;
-    return enriched;
-  }
-
-  const newProvider: ProviderConfig = withBuiltinProviderModelMetadata(
-    {
-      id: randomUUID(),
-      name,
-      apiKey: normalizedKey,
-      format:
-        format ??
-        (anthropicBaseUrl !== undefined
-          ? "anthropic"
-          : openaiBaseUrl !== undefined || openaiResponsesBaseUrl !== undefined
-            ? "openai"
-            : undefined),
-      baseUrl,
-      models: models ?? [],
-      authHeader: authHeader ?? "bearer",
-      apiDocsUrl,
-      modelMetadataUrl,
-      modelMetadata,
-      createdAt: now,
-      updatedAt: now,
-      anthropicBaseUrl: resolvedAnthropicUrl,
-      openaiBaseUrl: resolvedOpenaiUrl,
-      openaiResponsesBaseUrl: resolvedOpenaiResponsesUrl,
-      source,
-    },
-    now,
-  );
-  providers.push(newProvider);
-  if (!persistProviders(providers)) return null;
-  return newProvider;
-}
-
-export function updateProvider(
-  id: string,
-  updates: Partial<Omit<ProviderConfig, "id" | "createdAt">>,
-): ProviderConfig | null {
-  const providers = getProviders();
-  const existing = providers.find((p) => p.id === id);
-  if (!existing) return null;
-
-  const updatedAt = new Date().toISOString();
-  const updated: ProviderConfig = withBuiltinProviderModelMetadata(
-    {
-      id: existing.id,
-      name: updates.name ?? existing.name,
-      apiKey: providerUpdateApiKey(updates.apiKey, existing.apiKey),
-      models: updates.models !== undefined ? updates.models : existing.models,
-      format: updates.format ?? existing.format,
-      baseUrl: updates.baseUrl !== undefined ? updates.baseUrl : existing.baseUrl,
-      authHeader: updates.authHeader ?? existing.authHeader,
-      apiDocsUrl: updates.apiDocsUrl ?? existing.apiDocsUrl,
-      modelMetadataUrl:
-        updates.modelMetadataUrl !== undefined
-          ? updates.modelMetadataUrl
-          : existing.modelMetadataUrl,
-      modelMetadata:
-        updates.modelMetadata !== undefined ? updates.modelMetadata : existing.modelMetadata,
-      createdAt: existing.createdAt,
-      updatedAt,
-      // Handle format-specific URLs
-      anthropicBaseUrl:
-        updates.anthropicBaseUrl !== undefined
-          ? updates.anthropicBaseUrl
-          : existing.anthropicBaseUrl,
-      openaiBaseUrl:
-        updates.openaiBaseUrl !== undefined ? updates.openaiBaseUrl : existing.openaiBaseUrl,
-      openaiResponsesBaseUrl:
-        updates.openaiResponsesBaseUrl !== undefined
-          ? updates.openaiResponsesBaseUrl
-          : existing.openaiResponsesBaseUrl,
-      source: updates.source !== undefined ? updates.source : existing.source,
-    },
-    updatedAt,
-  );
-  const index = providers.findIndex((p) => p.id === id);
-  providers[index] = updated;
-  if (!persistProviders(providers)) return null;
-  return updated;
-}
-
-export function deleteProvider(id: string): boolean {
-  const providers = getProviders();
-  const filtered = providers.filter((p) => p.id !== id);
-  if (filtered.length === providers.length) return false;
-
-  if (!persistProviders(filtered, new Set([id]))) return false;
-  providerSecretStore.delete(id);
-  return true;
-}
-
-/**
- * Export all providers as a JSON string (without API keys for security).
- */
-export function exportProviders(): string {
-  const providers = getProviders();
-  // Mask API keys for security
-  const safeProviders = providers.map(({ apiKey, ...rest }) => ({
-    ...rest,
-    apiKey: maskApiKey(apiKey),
-  }));
-  return JSON.stringify(safeProviders, null, 2);
-}
-
-/**
- * Export all providers as a JSON string including API keys (user must opt-in).
- */
-export function exportProvidersWithKeys(): string {
-  return JSON.stringify(getProviders(), null, 2);
-}
-
-/**
- * Import providers from a JSON string.
- * Returns { imported: number, errors: string[] }
- */
-export function importProviders(json: string): { imported: number; errors: string[] } {
-  const errors: string[] = [];
-  let imported = 0;
-
-  try {
-    const parsed: unknown = JSON.parse(json);
-
-    // Use Zod to validate the structure
-    const ImportSchema = z.union([
-      z.array(ProviderConfigSchema),
-      z.object({
-        providers: z.array(ProviderConfigSchema),
-      }),
-    ]);
-
-    const parseResult = ImportSchema.safeParse(parsed);
-    if (!parseResult.success) {
-      return {
-        imported: 0,
-        errors: [`Invalid format: ${parseResult.error.message}`],
-      };
-    }
-
-    const providerArray = Array.isArray(parseResult.data)
-      ? parseResult.data
-      : parseResult.data.providers;
-
-    // Snapshot existing providers once
-    const existingProviders = getProviders();
-
-    // Build a Set of existing (name, anthropicBaseUrl) keys for O(1) duplicate lookup
-    const existingKeys = new Set<string>();
-    for (const p of existingProviders) {
-      existingKeys.add(`${p.name}::${p.anthropicBaseUrl ?? ""}`);
-    }
-
-    const newProviders: ProviderConfig[] = [];
-
-    for (let i = 0; i < providerArray.length; i++) {
-      const item = providerArray[i];
-      const result = ProviderConfigSchema.safeParse(item);
-
-      if (!result.success) {
-        errors.push(`Provider ${i + 1}: ${result.error.message}`);
-        continue;
-      }
-
-      const provider = result.data;
-      const key = `${provider.name}::${provider.anthropicBaseUrl ?? ""}`;
-
-      if (existingKeys.has(key)) {
-        errors.push(`Provider "${provider.name}" already exists, skipping`);
-        continue;
-      }
-
-      // Generate new ID and add
-      const now = new Date().toISOString();
-      const newProvider: ProviderConfig = withBuiltinProviderModelMetadata(
-        {
-          ...provider,
-          id: randomUUID(),
-          createdAt: now,
-          updatedAt: now,
-        },
-        now,
-      );
-
-      newProviders.push(newProvider);
-      existingKeys.add(key);
-    }
-
-    // Single write: append all new providers at once
-    if (newProviders.length > 0) {
-      if (!persistProviders([...existingProviders, ...newProviders])) {
-        return {
-          imported: 0,
-          errors: ["Secure provider storage is unavailable; no providers were imported"],
-        };
-      }
-      imported = newProviders.length;
-    }
-  } catch (err) {
-    return {
-      imported: 0,
-      errors: [`Failed to parse JSON: ${err instanceof Error ? err.message : String(err)}`],
-    };
-  }
-
-  return { imported, errors };
-}
-
-/**
- * Converts display model name to API usage name based on provider-specific rules.
- * Default behavior: returns model as-is.
- * MiniMax: replaces spaces with hyphens.
- */
-export function getModelUsageName(model: string, providerName?: string): string {
-  if (
-    providerName !== undefined &&
-    providerName !== "" &&
-    providerName.toLowerCase().includes("minimax")
-  ) {
-    return model.replace(/ /g, "-");
-  }
-  return model;
-}
-
-/**
- * Normalize a model name for comparison: lowercase, replace whitespace with hyphens.
- */
-function normalizeModelName(name: string): string {
-  return name.toLowerCase().replace(/\s+/g, "-");
-}
-
-const ZHIPU_MODEL_PREFIXES = ["glm-", "charglm-", "cogview-", "embedding-", "rerank-"];
-const ZHIPU_PROVIDER_ALIASES = ["zhipu", "zhipuai", "bigmodel", "zai", "glm"];
-const ZHIPU_BASE_URL_MARKERS = [
-  "open.bigmodel.cn/api/paas/v4",
-  "open.bigmodel.cn/api/coding/paas/v4",
-  "open.bigmodel.cn/api/anthropic",
-];
-
-function normalizeProviderAlias(name: string): string {
-  return name.toLowerCase().replace(/[^a-z0-9]/g, "");
-}
-
-function providerRoutingUrls(provider: ProviderConfig): string[] {
-  const urls: string[] = [];
-  if (provider.anthropicBaseUrl !== undefined && provider.anthropicBaseUrl.trim() !== "") {
-    urls.push(provider.anthropicBaseUrl);
-  }
-  if (provider.openaiBaseUrl !== undefined && provider.openaiBaseUrl.trim() !== "") {
-    urls.push(provider.openaiBaseUrl);
-  }
-  if (
-    provider.openaiResponsesBaseUrl !== undefined &&
-    provider.openaiResponsesBaseUrl.trim() !== ""
-  ) {
-    urls.push(provider.openaiResponsesBaseUrl);
-  }
-  if (provider.baseUrl !== undefined && provider.baseUrl.trim() !== "") {
-    urls.push(provider.baseUrl);
-  }
-  return urls;
-}
-
-function isZhipuProvider(provider: ProviderConfig): boolean {
-  const normalizedName = normalizeProviderAlias(provider.name);
-  const nameMatches = ZHIPU_PROVIDER_ALIASES.some((alias) => {
-    const normalizedAlias = normalizeProviderAlias(alias);
-    return normalizedName.includes(normalizedAlias) || normalizedAlias.includes(normalizedName);
-  });
-  if (nameMatches) return true;
-
-  return providerRoutingUrls(provider).some((url) => {
-    const normalizedUrl = url.toLowerCase().replace(/\/+$/, "");
-    return ZHIPU_BASE_URL_MARKERS.some((marker) => normalizedUrl.includes(marker));
-  });
-}
-
-function modelMatchesKnownProviderPrefix(
-  modelNormalized: string,
-  provider: ProviderConfig,
-): boolean {
-  if (isZhipuProvider(provider)) {
-    return ZHIPU_MODEL_PREFIXES.some((prefix) => modelNormalized.startsWith(prefix));
-  }
-  return false;
-}
-
-/**
- * Finds a provider by model name using three strategies:
- * 1. Case-insensitive prefix match against "{provider.name}-" (e.g., "deepseek-" matches "deepseek-*")
- * 2. Case-insensitive match against provider.model field (with whitespace/hyphen normalization)
- * 3. Fallback: concatenate provider name with provider's model and check if the request model matches
- *    this concatenation (handles "MiniMax" + "M3" → "MiniMax-M3" pattern when case differs)
- */
-export function findProviderByModel(model: string): ProviderConfig | null {
-  const providers = getProviders();
-  const modelLower = model.toLowerCase();
-  const modelNormalized = normalizeModelName(model);
-
-  for (const provider of providers) {
-    // Strategy 1: provider name prefix match
-    const providerPrefix = (provider.name + "-").toLowerCase();
-    if (modelLower.startsWith(providerPrefix)) {
-      return provider;
-    }
-    // Strategy 1b: known model-family prefixes for providers whose public
-    // model names do not start with the provider brand, e.g. ZhipuAI -> glm-*.
-    if (modelMatchesKnownProviderPrefix(modelNormalized, provider)) {
-      return provider;
-    }
-    // Strategy 2: match against provider.models array with normalization
-    const modelList = provider.models ?? (provider.model !== undefined ? [provider.model] : []);
-    for (const m of modelList) {
-      if (m !== "" && modelNormalized === normalizeModelName(m)) {
-        return provider;
-      }
-    }
-    // Strategy 3: fallback - concatenate provider name with model part and compare
-    for (const m of modelList) {
-      if (m !== "") {
-        const modelPart = modelNormalized.replace(normalizeModelName(provider.name), "");
-        const concatenated = normalizeModelName(provider.name) + modelPart;
-        if (modelNormalized === concatenated) {
-          return provider;
-        }
-      }
-    }
-  }
-  return null;
-}