Providers & Models

// 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> = {
  // Core providers
  "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 (Alibaba / Qwen)
  "modelstudio":              "modelstudio",
  // Volcengine (Doubao / ByteDance)
  "volcengine":               "volcengine",
  "volcengine-plan":          "volcengine",
  // GitHub Copilot
  "github-copilot":           "github-copilot",
  // Others
  "together":                 "together",
  "nvidia":                   "nvidia",
  "venice":                   "venice",
  "qianfan":                  "qianfan",
  "amazon-bedrock":           "amazon-bedrock",
  "huggingface":              "huggingface",
  "minimax":                  "minimax",
  "minimax-portal":           "minimax",
  "byteplus":                 "volcengine",
  "byteplus-plan":            "volcengine",
};

// Find all catalog providers that map to a config provider
_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. Get full config (API keys are redacted)
// Note: config.get returns { config: {...}, hash: "..." } — unwrap the .config property
const configResult = await gateway.call<ConfigGetResult>("config.get");
const cfg = (configResult?.config as Record<string, unknown>) ?? configResult ?? {};
const baseHash = configResult.payload?.baseHash;

// 2. Extract configured providers
const providers = cfg.models?.providers ?? {};
// providers = { anthropic: { baseUrl, apiKey: "__OPENCLAW_REDACTED__", models: [...] }, ... }

// 3. Detect which providers have keys set
for (const [id, provider] of Object.entries(providers)) {
  const hasKey = provider.apiKey && provider.apiKey !== "";
  const isRedacted = provider.apiKey === "__OPENCLAW_REDACTED__";
  // hasKey || isRedacted → provider is configured
}

// 4. Also check auth profiles (alternative key storage)
const authProfiles = config.auth?.profiles ?? {};
for (const [profileId, profile] of Object.entries(authProfiles)) {
  // profile.provider tells you which provider this profile configures
}

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

// Call models.list — returns the full merged catalog (ALL providers, not just configured ones)
const result = await gateway.call<ModelsListResult>("models.list");
const allModels = result.payload.models;
// allModels may contain 800+ models across 23+ providers

// IMPORTANT: Filter to only configured providers using the mapping
const configuredProviders = new Set(Object.keys(cfg.models?.providers ?? {}));
const models = allModels.filter(m =>
  m.provider ? configuredProviders.has(catalogToConfigProvider(m.provider)) : false
);
// Now models only contains models from providers the user has API keys for

// 1. Read current config + baseHash
const { config, baseHash } = (await gateway.call("config.get")).payload;

// 2. Set the API key in the config
config.models ??= {};
config.models.providers ??= {};
config.models.providers["anthropic"] ??= { baseUrl: "https://api.anthropic.com", models: [] };
config.models.providers["anthropic"].apiKey = "sk-ant-...";

// 3. Write back with baseHash (optimistic concurrency)
await gateway.call("config.set", {
  raw: JSON.stringify(config),
  baseHash,
});

// After config.set, the gateway restarts and model catalog refreshes

// 1. Read config
const { config, baseHash } = (await gateway.call("config.get")).payload;

// 2. Set default model (format: "provider/model-id")
config.agents ??= {};
config.agents.defaults ??= {};
config.agents.defaults.model = "anthropic/claude-opus-4-6";

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

// Use updateConfig (read-modify-write) to delete the provider entry
await updateConfig((cfg) => {
  const providers = cfg.models?.providers;
  if (providers) delete providers["anthropic"];

  // Also clean auth profiles that reference this provider
  const profiles = cfg.auth?.profiles;
  if (profiles) {
    for (const [key, val] of Object.entries(profiles)) {
      if (val?.provider === "anthropic") delete profiles[key];
    }
  }

  // If the default model used this provider, clear it
  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";

// After calling models.list
const models = result.payload.models;

// Filter to only configured providers
const configuredProviders = new Set(Object.keys(config.models?.providers ?? {}));
const filtered = models.filter(m =>
  m.provider ? configuredProviders.has(catalogToConfigProvider(m.provider)) : false
);

// For a selected config provider (e.g. "moonshot"),
// find ALL catalog providers that map to it
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 → returns models from both "moonshot" and "kimi-coding" providers
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"),
  ]);

  // Handle config.get response wrapper: { config: {...}, hash: "..." }
  const cfg = (configResult?.config as Record<string, unknown>) ?? configResult ?? {};

  // Which config providers are configured (have API keys)?
  const providers = cfg.models?.providers;
  const configuredProviders = new Set(providers ? Object.keys(providers) : []);

  // Read the user-saved default model from agents.defaults.model
  const savedDefaultModel = cfg.agents?.defaults?.model ?? "";

  // Filter models to only configured providers using the mapping
  const filtered = modelsResult.models.filter(m =>
    m.provider ? configuredProviders.has(catalogToConfigProvider(m.provider)) : false
  );

  // Build dropdown options
  this._availableModels = filtered.map(m => ({
    value: m.provider ? `${m.provider}/${m.id}` : m.id,
    label: m.provider ? `${m.name} · ${m.provider}` : m.name,
  }));

  // Display the saved default model, or fall back to first available
  if (savedDefaultModel) {
    const match = filtered.find(m => `${m.provider}/${m.id}` === savedDefaultModel);
    this._defaultModelDisplay = match
      ? `${match.name} · ${match.provider}`
      : savedDefaultModel;  // Show raw ID if provider is unconfigured
  }
}

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

// Combine providers from config + models.list for the complete picture
function getProviderList(config: OpenClawConfig, models: ModelCatalogEntry[]): ProviderInfo[] {
  const seen = new Map<string, ProviderInfo>();

  // 1. Providers with API keys configured
  for (const [id, p] of Object.entries(config.models?.providers ?? {})) {
    seen.set(id, { id, configured: true, modelCount: 0 });
  }

  // 2. Providers from model catalog (includes built-in + plugin-discovered)
  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));
}