@tokenbuddy/tokenbuddy 1.0.4 → 1.0.6

package/src/provider-install.ts

@@ -1,29 +1,75 @@
 import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
-import { BuyerStore, ProviderInstallSnapshot } from "./buyer-store.js";
-
-const PLACEHOLDER_API_KEY = "TOKENBUDDY_PROXY";
+import {
+  BuyerStore,
+  ProviderInstallSnapshot,
+} from "./buyer-store.js";
+import {
+  ProtocolPreference,
+  SellerRoutingPreference,
+} from "./seller-catalog.js";
+
+export const PROXY_ACCESS_TOKEN_PLACEHOLDER = "TOKENBUDDY_PROXY";
 const DESKTOP_PROFILE_ID = "00000000-0000-4000-8000-000000178210";
+const CLAUDE_ONE_M_MARKER = "[1M]";
+const CLAUDE_CLIENT_HAIKU_MODEL = "claude-haiku-4-5";
+const CLAUDE_CLIENT_SONNET_MODEL = "claude-sonnet-4-6";
+const CLAUDE_CLIENT_OPUS_MODEL = "claude-opus-4-7";
+const ROUTING_CONFIG_KEY = "routing";
 
 export const SUPPORTED_PROVIDER_IDS = [
   "codex",
   "claude-code",
   "claude-desktop",
   "openclaw",
-  "hermes"
+  "opencode",
+  "hermes",
 ] as const;
 
 export type ProviderId = typeof SUPPORTED_PROVIDER_IDS[number];
+export type ModelSelectionKind = "single-model" | "claude-role-mapping";
 
 export interface ProviderDetectOptions {
   home?: string;
 }
 
+export interface SingleModelProviderRuntimeConfig {
+  selectionKind: "single-model";
+  protocolPreference?: ProtocolPreference;
+  defaultModel: string;
+  sellerId?: string;
+}
+
+export interface ClaudeRoleBinding {
+  upstreamModel: string;
+  displayName?: string;
+  declareOneM?: boolean;
+}
+
+export interface ClaudeCodeModelMappingConfig {
+  selectionKind: "claude-role-mapping";
+  protocolPreference?: ProtocolPreference;
+  fallbackModel?: string;
+  roles: {
+    haiku?: ClaudeRoleBinding;
+    sonnet?: ClaudeRoleBinding;
+    opus?: ClaudeRoleBinding;
+  };
+}
+
+export type ProviderRuntimeConfig =
+  | SingleModelProviderRuntimeConfig
+  | ClaudeCodeModelMappingConfig;
+
+export type ProviderSelections = Partial<Record<ProviderId, ProviderRuntimeConfig>>;
+
 export interface ProviderInstallOptions extends ProviderDetectOptions {
   providers: string[];
   proxyUrl: string;
-  model: string;
+  model?: string;
+  providerSelections?: ProviderSelections;
+  sellerRouting?: SellerRoutingPreference;
 }
 
 export interface ProviderRollbackOptions extends ProviderDetectOptions {
@@ -34,7 +80,12 @@ export interface ProviderCandidate {
   id: ProviderId;
   name: string;
   detected: boolean;
+  configured: boolean;
+  status: "configured" | "installed" | "missing";
   configPath: string;
+  commandName?: string;
+  executablePath?: string;
+  observedPaths?: string[];
   reason: string;
 }
 
@@ -63,7 +114,11 @@ interface ProviderDefinition {
   id: ProviderId;
   name: string;
   configPath(home: string): string;
-  changes(home: string, proxyUrl: string, model: string): ProviderFileChange[];
+  commandName?: string;
+  observedPaths?(home: string): string[];
+  changes(home: string, proxyUrl: string, config: ProviderRuntimeConfig): ProviderFileChange[];
+  modelSelectionKind: ModelSelectionKind;
+  protocolPreference?: ProtocolPreference;
 }
 
 function resolveHome(home?: string): string {
@@ -105,7 +160,7 @@ function readJsonObject(filePath: string): Record<string, unknown> {
   try {
     const parsed = JSON.parse(text) as unknown;
     return parsed && typeof parsed === "object" && !Array.isArray(parsed)
-      ? parsed as Record<string, unknown>
+      ? (parsed as Record<string, unknown>)
       : {};
   } catch {
     return {};
@@ -116,6 +171,33 @@ function jsonContent(value: unknown): string {
   return `${JSON.stringify(value, null, 2)}\n`;
 }
 
+function displayPath(home: string, filePath: string): string {
+  return filePath.startsWith(home) ? `~${filePath.slice(home.length)}` : filePath;
+}
+
+function resolveExecutable(commandName: string): string | undefined {
+  const pathValue = process.env.PATH || "";
+  const pathEntries = pathValue.split(path.delimiter).filter(Boolean);
+  const windowsExts = process.platform === "win32"
+    ? (process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM")
+      .split(";")
+      .filter(Boolean)
+    : [""];
+
+  for (const entry of pathEntries) {
+    for (const ext of windowsExts) {
+      const candidate = path.join(entry, process.platform === "win32" ? `${commandName}${ext}` : commandName);
+      try {
+        fs.accessSync(candidate, fs.constants.X_OK);
+        return candidate;
+      } catch {
+        continue;
+      }
+    }
+  }
+  return undefined;
+}
+
 function escapeTomlString(value: string): string {
   return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
 }
@@ -130,34 +212,201 @@ function replaceTomlSection(existing: string, sectionName: string, sectionBody:
   return `${normalized}${normalized ? "\n\n" : ""}${nextSection}`;
 }
 
-function codexConfig(home: string, proxyUrl: string, model: string): ProviderFileChange[] {
+function stripClaudeOneMMarker(model: string): string {
+  const trimmed = model.trimEnd();
+  if (!trimmed.toLowerCase().endsWith(CLAUDE_ONE_M_MARKER.toLowerCase())) {
+    return model;
+  }
+  return trimmed.slice(0, -CLAUDE_ONE_M_MARKER.length).trimEnd();
+}
+
+function setClaudeOneMMarker(model: string, enabled: boolean): string {
+  const base = stripClaudeOneMMarker(model).trim();
+  if (!base) {
+    return "";
+  }
+  return enabled ? `${base}${CLAUDE_ONE_M_MARKER}` : base;
+}
+
+function makeChange(providerId: ProviderId, filePath: string, summary: string, content: string): ProviderFileChange {
+  const existed = fs.existsSync(filePath);
+  return {
+    providerId,
+    path: filePath,
+    action: existed ? "update" : "create",
+    existed,
+    summary,
+    content,
+  };
+}
+
+function makeSingleModelRuntimeConfig(
+  provider: ProviderDefinition,
+  model: string,
+  sellerId?: string,
+): SingleModelProviderRuntimeConfig {
+  return {
+    selectionKind: "single-model",
+    protocolPreference: provider.protocolPreference,
+    defaultModel: model,
+    sellerId,
+  };
+}
+
+function pickConfiguredModel(config: ProviderRuntimeConfig): string {
+  if (config.selectionKind === "single-model") {
+    return config.defaultModel;
+  }
+  const sonnetModel = config.roles.sonnet?.upstreamModel;
+  const opusModel = config.roles.opus?.upstreamModel;
+  const haikuModel = config.roles.haiku?.upstreamModel;
+  return sonnetModel || opusModel || haikuModel || config.fallbackModel || "";
+}
+
+function resolveProviderRuntimeConfig(
+  provider: ProviderDefinition,
+  options: ProviderInstallOptions,
+): ProviderRuntimeConfig {
+  const selection = options.providerSelections?.[provider.id];
+  if (selection) {
+    return selection;
+  }
+  const model = options.model?.trim();
+  if (!model) {
+    throw new Error(`model is required for provider ${provider.id}`);
+  }
+  return makeSingleModelRuntimeConfig(
+    provider,
+    model,
+    options.sellerRouting?.mode === "fixed" ? options.sellerRouting.sellerId : undefined,
+  );
+}
+
+function codexConfig(home: string, proxyUrl: string, config: ProviderRuntimeConfig): ProviderFileChange[] {
+  const model = pickConfiguredModel(config);
   const configPath = path.join(home, ".codex", "config.toml");
   const existing = readText(configPath) || "";
-  const content = replaceTomlSection(existing, "tokenbuddy", [
-    `proxy_url = "${escapeTomlString(proxyUrl)}"`,
-    `api_key = "${PLACEHOLDER_API_KEY}"`,
-    `model = "${escapeTomlString(model)}"`
-  ].join("\n"));
+  const content = replaceTomlSection(
+    existing,
+    "tokenbuddy",
+    [
+      `proxy_url = "${escapeTomlString(proxyUrl)}"`,
+      `api_key = "${PROXY_ACCESS_TOKEN_PLACEHOLDER}"`,
+      `model = "${escapeTomlString(model)}"`,
+    ].join("\n"),
+  );
   return [makeChange("codex", configPath, "configure TokenBuddy proxy for Codex", content)];
 }
 
-function claudeCodeConfig(home: string, proxyUrl: string, model: string): ProviderFileChange[] {
+function resolveClaudeFallbackAlias(config: ClaudeCodeModelMappingConfig): string {
+  if (config.roles.sonnet?.upstreamModel) {
+    return setClaudeOneMMarker(
+      CLAUDE_CLIENT_SONNET_MODEL,
+      Boolean(config.roles.sonnet.declareOneM),
+    );
+  }
+  if (config.roles.opus?.upstreamModel) {
+    return setClaudeOneMMarker(
+      CLAUDE_CLIENT_OPUS_MODEL,
+      Boolean(config.roles.opus.declareOneM),
+    );
+  }
+  if (config.roles.haiku?.upstreamModel) {
+    return CLAUDE_CLIENT_HAIKU_MODEL;
+  }
+  return CLAUDE_CLIENT_SONNET_MODEL;
+}
+
+function buildClaudeRoleEnv(config: ClaudeCodeModelMappingConfig): Record<string, string> {
+  const env: Record<string, string> = {};
+  const roleConfigs: Array<{
+    binding?: ClaudeRoleBinding;
+    modelKey: string;
+    displayNameKey: string;
+    alias: string;
+    allowOneM: boolean;
+  }> = [
+    {
+      binding: config.roles.haiku,
+      modelKey: "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+      displayNameKey: "ANTHROPIC_DEFAULT_HAIKU_MODEL_NAME",
+      alias: CLAUDE_CLIENT_HAIKU_MODEL,
+      allowOneM: false,
+    },
+    {
+      binding: config.roles.sonnet,
+      modelKey: "ANTHROPIC_DEFAULT_SONNET_MODEL",
+      displayNameKey: "ANTHROPIC_DEFAULT_SONNET_MODEL_NAME",
+      alias: CLAUDE_CLIENT_SONNET_MODEL,
+      allowOneM: true,
+    },
+    {
+      binding: config.roles.opus,
+      modelKey: "ANTHROPIC_DEFAULT_OPUS_MODEL",
+      displayNameKey: "ANTHROPIC_DEFAULT_OPUS_MODEL_NAME",
+      alias: CLAUDE_CLIENT_OPUS_MODEL,
+      allowOneM: true,
+    },
+  ];
+
+  for (const role of roleConfigs) {
+    if (!role.binding?.upstreamModel?.trim()) {
+      continue;
+    }
+    env[role.modelKey] = role.allowOneM
+      ? setClaudeOneMMarker(role.alias, Boolean(role.binding.declareOneM))
+      : role.alias;
+    const displayName = role.binding.displayName?.trim() || stripClaudeOneMMarker(role.binding.upstreamModel).trim();
+    if (displayName) {
+      env[role.displayNameKey] = displayName;
+    }
+  }
+
+  env.ANTHROPIC_MODEL = resolveClaudeFallbackAlias(config);
+  return env;
+}
+
+function claudeCodeConfig(home: string, proxyUrl: string, config: ProviderRuntimeConfig): ProviderFileChange[] {
   const configPath = path.join(home, ".claude", "settings.json");
-  const config = readJsonObject(configPath);
-  const env = config.env && typeof config.env === "object" && !Array.isArray(config.env)
-    ? config.env as Record<string, unknown>
+  const current = readJsonObject(configPath);
+  const env = current.env && typeof current.env === "object" && !Array.isArray(current.env)
+    ? (current.env as Record<string, unknown>)
     : {};
-  config.env = {
+
+  const nextEnv: Record<string, unknown> = {
     ...env,
     ANTHROPIC_BASE_URL: proxyUrl,
-    ANTHROPIC_AUTH_TOKEN: PLACEHOLDER_API_KEY,
-    ANTHROPIC_MODEL: model,
-    ANTHROPIC_DEFAULT_SONNET_MODEL: model
+    ANTHROPIC_AUTH_TOKEN: PROXY_ACCESS_TOKEN_PLACEHOLDER,
   };
-  return [makeChange("claude-code", configPath, "configure Anthropic proxy env for Claude Code", jsonContent(config))];
+
+  delete nextEnv.ANTHROPIC_DEFAULT_HAIKU_MODEL;
+  delete nextEnv.ANTHROPIC_DEFAULT_HAIKU_MODEL_NAME;
+  delete nextEnv.ANTHROPIC_DEFAULT_SONNET_MODEL;
+  delete nextEnv.ANTHROPIC_DEFAULT_SONNET_MODEL_NAME;
+  delete nextEnv.ANTHROPIC_DEFAULT_OPUS_MODEL;
+  delete nextEnv.ANTHROPIC_DEFAULT_OPUS_MODEL_NAME;
+  delete nextEnv.ANTHROPIC_MODEL;
+
+  if (config.selectionKind === "claude-role-mapping") {
+    Object.assign(nextEnv, buildClaudeRoleEnv(config));
+  } else {
+    nextEnv.ANTHROPIC_MODEL = config.defaultModel;
+    nextEnv.ANTHROPIC_DEFAULT_SONNET_MODEL = config.defaultModel;
+  }
+
+  current.env = nextEnv;
+  return [
+    makeChange(
+      "claude-code",
+      configPath,
+      "configure Anthropic proxy env for Claude Code",
+      jsonContent(current),
+    ),
+  ];
 }
 
-function claudeDesktopConfig(home: string, proxyUrl: string, model: string): ProviderFileChange[] {
+function claudeDesktopConfig(home: string, proxyUrl: string, config: ProviderRuntimeConfig): ProviderFileChange[] {
+  const model = pickConfiguredModel(config);
   const configDir = path.join(home, "Library", "Application Support", "Claude");
   const configPath = path.join(configDir, "claude_desktop_config.json");
   const threepDir = path.join(home, "Library", "Application Support", "Claude-3p");
@@ -173,134 +422,223 @@ function claudeDesktopConfig(home: string, proxyUrl: string, model: string): Pro
 
   const profile = {
     disableDeploymentModeChooser: true,
-    inferenceGatewayApiKey: PLACEHOLDER_API_KEY,
+    inferenceGatewayApiKey: PROXY_ACCESS_TOKEN_PLACEHOLDER,
     inferenceGatewayAuthScheme: "bearer",
     inferenceGatewayBaseUrl: proxyUrl,
     inferenceProvider: "gateway",
-    inferenceModels: [{ name: model }]
+    inferenceModels: [{ name: model }],
   };
 
   const meta = readJsonObject(metaPath);
   const existingEntries = Array.isArray(meta.entries) ? meta.entries : [];
   meta.appliedId = DESKTOP_PROFILE_ID;
   meta.entries = [
-    ...existingEntries.filter((entry) => {
-      return !(entry && typeof entry === "object" && "id" in entry && entry.id === DESKTOP_PROFILE_ID);
-    }),
-    { id: DESKTOP_PROFILE_ID, name: "TokenBuddy" }
+    ...existingEntries.filter((entry) => !(entry && typeof entry === "object" && "id" in entry && entry.id === DESKTOP_PROFILE_ID)),
+    { id: DESKTOP_PROFILE_ID, name: "TokenBuddy" },
   ];
 
   return [
     makeChange("claude-desktop", configPath, "enable Claude Desktop 3p deployment mode", jsonContent(primary)),
     makeChange("claude-desktop", threepConfigPath, "enable Claude Desktop 3p config", jsonContent(threep)),
     makeChange("claude-desktop", profilePath, "write TokenBuddy Claude Desktop profile", jsonContent(profile)),
-    makeChange("claude-desktop", metaPath, "select TokenBuddy Claude Desktop profile", jsonContent(meta))
+    makeChange("claude-desktop", metaPath, "select TokenBuddy Claude Desktop profile", jsonContent(meta)),
   ];
 }
 
-function openclawConfig(home: string, proxyUrl: string, model: string): ProviderFileChange[] {
+function openclawConfig(home: string, proxyUrl: string, config: ProviderRuntimeConfig): ProviderFileChange[] {
+  const model = pickConfiguredModel(config);
   const configPath = path.join(home, ".openclaw", "config.json");
-  const config = readJsonObject(configPath);
-  config.api_url = proxyUrl;
-  config.api_key = PLACEHOLDER_API_KEY;
-  config.model = model;
-  return [makeChange("openclaw", configPath, "configure OpenClaw proxy settings", jsonContent(config))];
+  const current = readJsonObject(configPath);
+  current.api_url = proxyUrl;
+  current.api_key = PROXY_ACCESS_TOKEN_PLACEHOLDER;
+  current.model = model;
+  return [makeChange("openclaw", configPath, "configure OpenClaw proxy settings", jsonContent(current))];
 }
 
-function hermesConfig(home: string, proxyUrl: string, model: string): ProviderFileChange[] {
-  const configPath = path.join(home, ".hermes", "settings.json");
-  const config = readJsonObject(configPath);
-  const openai = config.openai && typeof config.openai === "object" && !Array.isArray(config.openai)
-    ? config.openai as Record<string, unknown>
+function openAiBaseUrl(proxyUrl: string): string {
+  const normalized = proxyUrl.replace(/\/+$/, "");
+  return normalized.endsWith("/v1") ? normalized : `${normalized}/v1`;
+}
+
+function opencodeConfig(home: string, proxyUrl: string, config: ProviderRuntimeConfig): ProviderFileChange[] {
+  const model = pickConfiguredModel(config);
+  const configPath = path.join(home, ".config", "opencode", "opencode.json");
+  const current = readJsonObject(configPath);
+  const providers = current.provider && typeof current.provider === "object" && !Array.isArray(current.provider)
+    ? (current.provider as Record<string, unknown>)
     : {};
-  config.openai = {
-    ...openai,
-    base_url: proxyUrl,
-    api_key: PLACEHOLDER_API_KEY,
-    model
+  providers.tokenbuddy = {
+    name: "TokenBuddy",
+    npm: "@ai-sdk/openai",
+    options: {
+      apiKey: PROXY_ACCESS_TOKEN_PLACEHOLDER,
+      baseURL: openAiBaseUrl(proxyUrl),
+    },
+    models: {
+      [model]: {
+        name: model,
+        attachment: true,
+        tool_call: true,
+      },
+    },
   };
-  return [makeChange("hermes", configPath, "configure Hermes OpenAI proxy settings", jsonContent(config))];
+  current.provider = providers;
+  return [makeChange("opencode", configPath, "configure OpenCode provider for TokenBuddy proxy", jsonContent(current))];
 }
 
-function makeChange(providerId: ProviderId, filePath: string, summary: string, content: string): ProviderFileChange {
-  const existed = fs.existsSync(filePath);
-  return {
-    providerId,
-    path: filePath,
-    action: existed ? "update" : "create",
-    existed,
-    summary,
-    content
+function hermesConfig(home: string, proxyUrl: string, config: ProviderRuntimeConfig): ProviderFileChange[] {
+  const model = pickConfiguredModel(config);
+  const configPath = path.join(home, ".hermes", "settings.json");
+  const current = readJsonObject(configPath);
+  const openai = current.openai && typeof current.openai === "object" && !Array.isArray(current.openai)
+    ? (current.openai as Record<string, unknown>)
+    : {};
+  current.openai = {
+    ...openai,
+    base_url: proxyUrl,
+    api_key: PROXY_ACCESS_TOKEN_PLACEHOLDER,
+    model,
   };
+  return [makeChange("hermes", configPath, "configure Hermes OpenAI proxy settings", jsonContent(current))];
 }
 
 const PROVIDERS: ProviderDefinition[] = [
   {
     id: "codex",
     name: "Codex CLI",
+    commandName: "codex",
     configPath: (home) => path.join(home, ".codex", "config.toml"),
-    changes: codexConfig
+    changes: codexConfig,
+    modelSelectionKind: "single-model",
+    protocolPreference: "responses",
   },
   {
     id: "claude-code",
     name: "Claude Code CLI",
+    commandName: "claude",
     configPath: (home) => path.join(home, ".claude", "settings.json"),
-    changes: claudeCodeConfig
+    changes: claudeCodeConfig,
+    modelSelectionKind: "claude-role-mapping",
+    protocolPreference: "messages",
   },
   {
     id: "claude-desktop",
     name: "Claude Desktop App",
     configPath: (home) => path.join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json"),
-    changes: claudeDesktopConfig
+    changes: claudeDesktopConfig,
+    modelSelectionKind: "single-model",
+    protocolPreference: "messages",
   },
   {
     id: "openclaw",
     name: "OpenClaw Agent",
+    commandName: "openclaw",
     configPath: (home) => path.join(home, ".openclaw", "config.json"),
-    changes: openclawConfig
+    observedPaths: (home) => [
+      path.join(home, ".openclaw", "openclaw.json"),
+      path.join(home, ".openclaw", "configs"),
+    ],
+    changes: openclawConfig,
+    modelSelectionKind: "single-model",
+    protocolPreference: "chat_completions",
+  },
+  {
+    id: "opencode",
+    name: "OpenCode",
+    commandName: "opencode",
+    configPath: (home) => path.join(home, ".config", "opencode", "opencode.json"),
+    changes: opencodeConfig,
+    modelSelectionKind: "single-model",
+    protocolPreference: "responses",
   },
   {
     id: "hermes",
     name: "Hermes Terminal",
+    commandName: "hermes",
     configPath: (home) => path.join(home, ".hermes", "settings.json"),
-    changes: hermesConfig
-  }
+    observedPaths: (home) => [
+      path.join(home, ".hermes", "config.yaml"),
+      path.join(home, ".hermes", "auth.json"),
+    ],
+    changes: hermesConfig,
+    modelSelectionKind: "single-model",
+    protocolPreference: "chat_completions",
+  },
 ];
 
+function getProviderDefinition(providerId: ProviderId): ProviderDefinition {
+  const provider = PROVIDERS.find((entry) => entry.id === providerId);
+  if (!provider) {
+    throw new Error(`unsupported provider: ${providerId}`);
+  }
+  return provider;
+}
+
 export function detectProviders(options: ProviderDetectOptions = {}): ProviderCandidate[] {
   const home = resolveHome(options.home);
   return PROVIDERS.map((provider) => {
     const configPath = provider.configPath(home);
-    const detected = fs.existsSync(configPath);
+    const configured = fs.existsSync(configPath);
+    const executablePath = provider.commandName ? resolveExecutable(provider.commandName) : undefined;
+    const observedPaths = provider.observedPaths?.(home).filter((entry) => fs.existsSync(entry)) || [];
+    const installed = Boolean(executablePath) || observedPaths.length > 0;
+    const status: ProviderCandidate["status"] = configured
+      ? "configured"
+      : installed
+        ? "installed"
+        : "missing";
+    const reasonParts: string[] = [];
+    if (configured) {
+      reasonParts.push(`Configured at ${displayPath(home, configPath)}`);
+    } else if (installed) {
+      reasonParts.push(`Installed, TokenBuddy config missing at ${displayPath(home, configPath)}`);
+    } else {
+      reasonParts.push(`Missing ${displayPath(home, configPath)}`);
+    }
+    if (executablePath) {
+      reasonParts.push(`CLI ${displayPath(home, executablePath)}`);
+    }
+    if (observedPaths.length > 0) {
+      reasonParts.push(`Native files ${observedPaths.map((entry) => displayPath(home, entry)).join(", ")}`);
+    }
     return {
       id: provider.id,
       name: provider.name,
-      detected,
+      detected: status !== "missing",
+      configured,
+      status,
       configPath,
-      reason: detected ? `Found ${configPath}` : `Missing ${configPath}`
+      commandName: provider.commandName,
+      executablePath,
+      observedPaths,
+      reason: reasonParts.join(" · "),
     };
   });
 }
 
+export function getProviderProtocolPreference(providerId: ProviderId): ProtocolPreference | undefined {
+  return getProviderDefinition(providerId).protocolPreference;
+}
+
+export function getProviderModelSelectionKind(providerId: ProviderId): ModelSelectionKind {
+  return getProviderDefinition(providerId).modelSelectionKind;
+}
+
 export function previewProviderInstall(options: ProviderInstallOptions): ProviderFileChange[] {
   const home = resolveHome(options.home);
   const providerIds = assertProviderIds(options.providers);
   if (!options.proxyUrl || !options.proxyUrl.trim()) {
     throw new Error("proxyUrl is required");
   }
-  if (!options.model || !options.model.trim()) {
-    throw new Error("model is required");
-  }
   return providerIds.flatMap((providerId) => {
-    const provider = PROVIDERS.find((entry) => entry.id === providerId);
-    if (!provider) {
-      throw new Error(`unsupported provider: ${providerId}`);
-    }
-    return provider.changes(home, options.proxyUrl, options.model);
+    const provider = getProviderDefinition(providerId);
+    const runtimeConfig = resolveProviderRuntimeConfig(provider, options);
+    return provider.changes(home, options.proxyUrl, runtimeConfig);
   });
 }
 
 export function applyProviderInstall(options: ProviderInstallOptions, store: BuyerStore): ProviderApplyResult[] {
+  const providerIds = assertProviderIds(options.providers);
   const changes = previewProviderInstall(options);
   const byProvider = new Map<ProviderId, ProviderFileChange[]>();
   for (const change of changes) {
@@ -313,12 +651,22 @@ export function applyProviderInstall(options: ProviderInstallOptions, store: Buy
       files: providerChanges.map((change) => ({
         path: change.path,
         existed: fs.existsSync(change.path),
-        content: readText(change.path)
-      }))
+        content: readText(change.path),
+      })),
     };
     store.saveProviderInstallSnapshot(snapshot);
   }
 
+  for (const providerId of providerIds) {
+    const provider = getProviderDefinition(providerId);
+    const runtimeConfig = resolveProviderRuntimeConfig(provider, options);
+    store.saveProviderRuntimeConfig(providerId, runtimeConfig);
+  }
+
+  if (options.sellerRouting) {
+    store.saveDaemonRuntimeConfig(ROUTING_CONFIG_KEY, options.sellerRouting);
+  }
+
   const applied: ProviderApplyResult[] = [];
   for (const change of changes) {
     const dir = path.dirname(change.path);
@@ -329,7 +677,7 @@ export function applyProviderInstall(options: ProviderInstallOptions, store: Buy
     applied.push({
       providerId: change.providerId,
       path: change.path,
-      action: change.existed ? "updated" : "created"
+      action: change.existed ? "updated" : "created",
     });
   }
   return applied;
@@ -358,6 +706,8 @@ export function rollbackProviderInstall(options: ProviderRollbackOptions, store:
       }
     }
     store.removeProviderInstallSnapshot(providerId);
+    store.removeProviderRuntimeConfig(providerId);
   }
+  store.removeDaemonRuntimeConfig(ROUTING_CONFIG_KEY);
   return results;
 }