服务商与模型

// extensions/my-provider/provider-catalog.ts
export function buildMyProvider(): ModelProviderConfig {
  return {
    baseUrl: "https://api.myprovider.com/v1",
    api: "openai-completions",
    models: [
      { id: "my-model-1", name: "My Model 1", reasoning: false, input: ["text"], contextWindow: 128000, maxTokens: 4096, cost: { input: 0.001, output: 0.002 } }
    ]
  };
}

export const CATALOG_TO_CONFIG_PROVIDER: Record<string, string> = {
  // 核心服务商
  "anthropic":                "anthropic",
  "openai":                   "openai",
  "openai-codex":             "openai",
  "openai-responses":         "openai",
  "azure-openai-responses":   "azure",
  "google":                   "google",
  "google-vertex":            "google",
  "google-gemini-cli":        "google",
  "deepseek":                 "deepseek",
  "mistral":                  "mistral",
  "openrouter":               "openrouter",
  "ollama":                   "ollama",
  // Moonshot / Kimi 系列
  "moonshot":                 "moonshot",
  "kimi":                     "moonshot",
  "kimi-coding":              "moonshot",
  // xAI
  "xai":                      "xai",
  // 通义（阿里云百炼）
  "modelstudio":              "modelstudio",
  // 火山引擎（豆包/字节跳动）
  "volcengine":               "volcengine",
  "volcengine-plan":          "volcengine",
  // GitHub Copilot
  "github-copilot":           "github-copilot",
  // 其他
  "together":                 "together",
  "nvidia":                   "nvidia",
  "venice":                   "venice",
  "qianfan":                  "qianfan",
  "amazon-bedrock":           "amazon-bedrock",
  "huggingface":              "huggingface",
  "minimax":                  "minimax",
  "minimax-portal":           "minimax",
  "byteplus":                 "volcengine",
  "byteplus-plan":            "volcengine",
};

// 查找映射到指定配置服务商的所有目录服务商
_modelsForConfigProvider(configId: string) {
  const catalogProviders = Object.entries(CATALOG_TO_CONFIG_PROVIDER)
    .filter(([, cfg]) => cfg === configId)
    .map(([cat]) => cat);
  return this._modelCatalog.filter(m =>
    m.provider && catalogProviders.includes(m.provider)
  );
}

// 1. 获取完整配置（API 密钥已脱敏）
// 注意: config.get 返回 { config: {...}, hash: "..." } —— 需要提取 .config 属性
const configResult = await gateway.call<ConfigGetResult>("config.get");
const cfg = (configResult?.config as Record<string, unknown>) ?? configResult ?? {};
const baseHash = configResult.payload?.baseHash;

// 2. 提取已配置的服务商
const providers = cfg.models?.providers ?? {};
// providers = { anthropic: { baseUrl, apiKey: "__OPENCLAW_REDACTED__", models: [...] }, ... }

// 3. 检测哪些服务商设置了密钥
for (const [id, provider] of Object.entries(providers)) {
  const hasKey = provider.apiKey && provider.apiKey !== "";
  const isRedacted = provider.apiKey === "__OPENCLAW_REDACTED__";
  // hasKey || isRedacted → 服务商已配置
}

// 4. 同时检查认证配置文件（替代密钥存储方式）
const authProfiles = cfg.auth?.profiles ?? {};
for (const [profileId, profile] of Object.entries(authProfiles)) {
  // profile.provider 告诉你这个配置文件对应哪个服务商
}

import { catalogToConfigProvider } from "../models/provider-mapping.js";

// 调用 models.list —— 返回完整合并目录（所有服务商，不仅仅是已配置的）
const result = await gateway.call<ModelsListResult>("models.list");
const allModels = result.payload.models;
// allModels 可能包含 800+ 个跨 23+ 服务商的模型

// 重要：使用映射过滤到仅已配置的服务商
const configuredProviders = new Set(Object.keys(cfg.models?.providers ?? {}));
const models = allModels.filter(m =>
  m.provider ? configuredProviders.has(catalogToConfigProvider(m.provider)) : false
);
// 现在 models 只包含用户已设置 API 密钥的服务商的模型

// 1. 读取当前配置 + baseHash
const { config, baseHash } = (await gateway.call("config.get")).payload;

// 2. 在配置中设置 API 密钥
config.models ??= {};
config.models.providers ??= {};
config.models.providers["anthropic"] ??= { baseUrl: "https://api.anthropic.com", models: [] };
config.models.providers["anthropic"].apiKey = "sk-ant-...";

// 3. 带 baseHash 写回（乐观并发控制）
await gateway.call("config.set", {
  raw: JSON.stringify(config),
  baseHash,
});

// config.set 后，网关重启，模型目录刷新

// 1. 读取配置
const { config, baseHash } = (await gateway.call("config.get")).payload;

// 2. 设置默认模型（格式："provider/model-id"）
config.agents ??= {};
config.agents.defaults ??= {};
config.agents.defaults.model = "anthropic/claude-opus-4-6";

// 3. 写回
await gateway.call("config.set", { raw: JSON.stringify(config), baseHash });

// 使用 updateConfig（读-改-写）删除服务商条目
await updateConfig((cfg) => {
  const providers = cfg.models?.providers;
  if (providers) delete providers["anthropic"];

  // 同时清理引用此服务商的认证配置文件
  const profiles = cfg.auth?.profiles;
  if (profiles) {
    for (const [key, val] of Object.entries(profiles)) {
      if (val?.provider === "anthropic") delete profiles[key];
    }
  }

  // 如果默认模型使用了此服务商，清除它
  const defaultModel = cfg.agents?.defaults?.model;
  if (typeof defaultModel === "string" && defaultModel.startsWith("anthropic/")) {
    delete cfg.agents.defaults.model;
  }

  return cfg;
});

import { catalogToConfigProvider, CATALOG_TO_CONFIG_PROVIDER } from "../models/provider-mapping.js";

// 调用 models.list 后
const models = result.payload.models;

// 过滤到仅已配置的服务商
const configuredProviders = new Set(Object.keys(config.models?.providers ?? {}));
const filtered = models.filter(m =>
  m.provider ? configuredProviders.has(catalogToConfigProvider(m.provider)) : false
);

// 对于选定的配置服务商（如 "moonshot"），
// 查找映射到它的所有目录服务商
function modelsForConfigProvider(configId: string) {
  const catalogProviders = Object.entries(CATALOG_TO_CONFIG_PROVIDER)
    .filter(([, cfg]) => cfg === configId)
    .map(([cat]) => cat);
  return models.filter(m => m.provider && catalogProviders.includes(m.provider));
}

// moonshot → 返回 "moonshot" 和 "kimi-coding" 两个服务商的模型
const moonshotModels = modelsForConfigProvider("moonshot");

import { catalogToConfigProvider } from "../models/provider-mapping.js";

async _loadModels() {
  const [modelsResult, configResult] = await Promise.all([
    gateway.call("models.list", {}),
    gateway.call("config.get"),
  ]);

  // 处理 config.get 响应包装：{ config: {...}, hash: "..." }
  const cfg = (configResult?.config as Record<string, unknown>) ?? configResult ?? {};

  // 哪些配置服务商已配置（有 API 密钥）？
  const providers = cfg.models?.providers;
  const configuredProviders = new Set(providers ? Object.keys(providers) : []);

  // 从 agents.defaults.model 读取用户保存的默认模型
  const savedDefaultModel = cfg.agents?.defaults?.model ?? "";

  // 使用映射过滤模型到仅已配置的服务商
  const filtered = modelsResult.models.filter(m =>
    m.provider ? configuredProviders.has(catalogToConfigProvider(m.provider)) : false
  );

  // 构建下拉选项
  this._availableModels = filtered.map(m => ({
    value: m.provider ? `${m.provider}/${m.id}` : m.id,
    label: m.provider ? `${m.name} · ${m.provider}` : m.name,
  }));

  // 显示保存的默认模型，或回退到第一个可用模型
  if (savedDefaultModel) {
    const match = filtered.find(m => `${m.provider}/${m.id}` === savedDefaultModel);
    this._defaultModelDisplay = match
      ? `${match.name} · ${match.provider}`
      : savedDefaultModel;  // 服务商未配置时显示原始 ID
  }
}

async function testConnection(): Promise<boolean> {
  try {
    const result = await gateway.call<ModelsListResult>("models.list");
    return result.payload.models.length > 0;
  } catch {
    return false;
  }
}

// 结合 config + models.list 的服务商获得完整列表
function getProviderList(config: OpenClawConfig, models: ModelCatalogEntry[]): ProviderInfo[] {
  const seen = new Map<string, ProviderInfo>();

  // 1. 已配置 API 密钥的服务商
  for (const [id, p] of Object.entries(config.models?.providers ?? {})) {
    seen.set(id, { id, configured: true, modelCount: 0 });
  }

  // 2. 模型目录中的服务商（包括内置 + 插件发现的）
  for (const model of models) {
    const info = seen.get(model.provider) ?? { id: model.provider, configured: false, modelCount: 0 };
    info.modelCount++;
    seen.set(model.provider, info);
  }

  return [...seen.values()].sort((a, b) => a.id.localeCompare(b.id));
}