338 lines
11 KiB
TypeScript
338 lines
11 KiB
TypeScript
import fs from "node:fs/promises";
|
|
import path from "node:path";
|
|
|
|
import { type ClawdbotConfig, loadConfig } from "../config/config.js";
|
|
import {
|
|
DEFAULT_COPILOT_API_BASE_URL,
|
|
resolveCopilotApiToken,
|
|
} from "../providers/github-copilot-token.js";
|
|
import { resolveClawdbotAgentDir } from "./agent-paths.js";
|
|
import {
|
|
ensureAuthProfileStore,
|
|
listProfilesForProvider,
|
|
} from "./auth-profiles.js";
|
|
import { resolveEnvApiKey } from "./model-auth.js";
|
|
|
|
type ModelsConfig = NonNullable<ClawdbotConfig["models"]>;
|
|
type ProviderConfig = NonNullable<ModelsConfig["providers"]>[string];
|
|
|
|
const DEFAULT_MODE: NonNullable<ModelsConfig["mode"]> = "merge";
|
|
|
|
const MINIMAX_API_BASE_URL = "https://api.minimax.io/anthropic";
|
|
const MINIMAX_DEFAULT_MODEL_ID = "MiniMax-M2.1";
|
|
const MINIMAX_DEFAULT_CONTEXT_WINDOW = 200000;
|
|
const MINIMAX_DEFAULT_MAX_TOKENS = 8192;
|
|
// Pricing: MiniMax doesn't publish public rates. Override in models.json for accurate costs.
|
|
const MINIMAX_API_COST = {
|
|
input: 15,
|
|
output: 60,
|
|
cacheRead: 2,
|
|
cacheWrite: 10,
|
|
};
|
|
|
|
const MOONSHOT_BASE_URL = "https://api.moonshot.ai/v1";
|
|
const MOONSHOT_DEFAULT_MODEL_ID = "kimi-k2-0905-preview";
|
|
const MOONSHOT_DEFAULT_CONTEXT_WINDOW = 256000;
|
|
const MOONSHOT_DEFAULT_MAX_TOKENS = 8192;
|
|
const MOONSHOT_DEFAULT_COST = {
|
|
input: 0,
|
|
output: 0,
|
|
cacheRead: 0,
|
|
cacheWrite: 0,
|
|
};
|
|
|
|
function isRecord(value: unknown): value is Record<string, unknown> {
|
|
return Boolean(value && typeof value === "object" && !Array.isArray(value));
|
|
}
|
|
|
|
function normalizeApiKeyConfig(value: string): string {
|
|
const trimmed = value.trim();
|
|
const match = /^\$\{([A-Z0-9_]+)\}$/.exec(trimmed);
|
|
return match ? match[1]! : trimmed;
|
|
}
|
|
|
|
function resolveEnvApiKeyVarName(provider: string): string | undefined {
|
|
const resolved = resolveEnvApiKey(provider);
|
|
if (!resolved) return undefined;
|
|
const match = /^(?:env: |shell env: )([A-Z0-9_]+)$/.exec(resolved.source);
|
|
return match ? match[1] : undefined;
|
|
}
|
|
|
|
function resolveApiKeyFromProfiles(params: {
|
|
provider: string;
|
|
store: ReturnType<typeof ensureAuthProfileStore>;
|
|
}): string | undefined {
|
|
const ids = listProfilesForProvider(params.store, params.provider);
|
|
for (const id of ids) {
|
|
const cred = params.store.profiles[id];
|
|
if (!cred) continue;
|
|
if (cred.type === "api_key") return cred.key;
|
|
if (cred.type === "token") return cred.token;
|
|
}
|
|
return undefined;
|
|
}
|
|
|
|
function normalizeGoogleModelId(id: string): string {
|
|
if (id === "gemini-3-pro") return "gemini-3-pro-preview";
|
|
if (id === "gemini-3-flash") return "gemini-3-flash-preview";
|
|
return id;
|
|
}
|
|
|
|
function normalizeGoogleProvider(provider: ProviderConfig): ProviderConfig {
|
|
let mutated = false;
|
|
const models = provider.models.map((model) => {
|
|
const nextId = normalizeGoogleModelId(model.id);
|
|
if (nextId === model.id) return model;
|
|
mutated = true;
|
|
return { ...model, id: nextId };
|
|
});
|
|
return mutated ? { ...provider, models } : provider;
|
|
}
|
|
|
|
function normalizeProviders(params: {
|
|
providers: ModelsConfig["providers"];
|
|
agentDir: string;
|
|
}): ModelsConfig["providers"] {
|
|
const { providers } = params;
|
|
if (!providers) return providers;
|
|
const authStore = ensureAuthProfileStore(params.agentDir, {
|
|
allowKeychainPrompt: false,
|
|
});
|
|
let mutated = false;
|
|
const next: Record<string, ProviderConfig> = {};
|
|
for (const [key, provider] of Object.entries(providers)) {
|
|
const normalizedKey = key.trim();
|
|
let normalizedProvider = provider;
|
|
|
|
// Fix common misconfig: apiKey set to "${ENV_VAR}" instead of "ENV_VAR".
|
|
if (
|
|
normalizedProvider.apiKey &&
|
|
normalizeApiKeyConfig(normalizedProvider.apiKey) !==
|
|
normalizedProvider.apiKey
|
|
) {
|
|
mutated = true;
|
|
normalizedProvider = {
|
|
...normalizedProvider,
|
|
apiKey: normalizeApiKeyConfig(normalizedProvider.apiKey),
|
|
};
|
|
}
|
|
|
|
// If a provider defines models, pi's ModelRegistry requires apiKey to be set.
|
|
// Fill it from the environment or auth profiles when possible.
|
|
const hasModels =
|
|
Array.isArray(normalizedProvider.models) &&
|
|
normalizedProvider.models.length > 0;
|
|
if (hasModels && !normalizedProvider.apiKey?.trim()) {
|
|
const fromEnv = resolveEnvApiKeyVarName(normalizedKey);
|
|
const fromProfiles = resolveApiKeyFromProfiles({
|
|
provider: normalizedKey,
|
|
store: authStore,
|
|
});
|
|
const apiKey = fromEnv ?? fromProfiles;
|
|
if (apiKey?.trim()) {
|
|
mutated = true;
|
|
normalizedProvider = { ...normalizedProvider, apiKey };
|
|
}
|
|
}
|
|
|
|
if (normalizedKey === "google") {
|
|
const googleNormalized = normalizeGoogleProvider(normalizedProvider);
|
|
if (googleNormalized !== normalizedProvider) mutated = true;
|
|
normalizedProvider = googleNormalized;
|
|
}
|
|
|
|
next[key] = normalizedProvider;
|
|
}
|
|
return mutated ? next : providers;
|
|
}
|
|
|
|
async function readJson(pathname: string): Promise<unknown> {
|
|
try {
|
|
const raw = await fs.readFile(pathname, "utf8");
|
|
return JSON.parse(raw) as unknown;
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
function buildMinimaxApiProvider(): ProviderConfig {
|
|
return {
|
|
baseUrl: MINIMAX_API_BASE_URL,
|
|
api: "anthropic-messages",
|
|
models: [
|
|
{
|
|
id: MINIMAX_DEFAULT_MODEL_ID,
|
|
name: "MiniMax M2.1",
|
|
reasoning: false,
|
|
input: ["text"],
|
|
cost: MINIMAX_API_COST,
|
|
contextWindow: MINIMAX_DEFAULT_CONTEXT_WINDOW,
|
|
maxTokens: MINIMAX_DEFAULT_MAX_TOKENS,
|
|
},
|
|
],
|
|
};
|
|
}
|
|
|
|
function buildMoonshotProvider(): ProviderConfig {
|
|
return {
|
|
baseUrl: MOONSHOT_BASE_URL,
|
|
api: "openai-completions",
|
|
models: [
|
|
{
|
|
id: MOONSHOT_DEFAULT_MODEL_ID,
|
|
name: "Kimi K2 0905 Preview",
|
|
reasoning: false,
|
|
input: ["text"],
|
|
cost: MOONSHOT_DEFAULT_COST,
|
|
contextWindow: MOONSHOT_DEFAULT_CONTEXT_WINDOW,
|
|
maxTokens: MOONSHOT_DEFAULT_MAX_TOKENS,
|
|
},
|
|
],
|
|
};
|
|
}
|
|
|
|
function resolveImplicitProviders(params: {
|
|
cfg: ClawdbotConfig;
|
|
agentDir: string;
|
|
}): ModelsConfig["providers"] {
|
|
const providers: Record<string, ProviderConfig> = {};
|
|
|
|
const authStore = ensureAuthProfileStore(params.agentDir, {
|
|
allowKeychainPrompt: false,
|
|
});
|
|
|
|
const minimaxKey =
|
|
resolveEnvApiKeyVarName("minimax") ??
|
|
resolveApiKeyFromProfiles({ provider: "minimax", store: authStore });
|
|
if (minimaxKey) {
|
|
providers.minimax = { ...buildMinimaxApiProvider(), apiKey: minimaxKey };
|
|
}
|
|
|
|
const moonshotKey =
|
|
resolveEnvApiKeyVarName("moonshot") ??
|
|
resolveApiKeyFromProfiles({ provider: "moonshot", store: authStore });
|
|
if (moonshotKey) {
|
|
providers.moonshot = { ...buildMoonshotProvider(), apiKey: moonshotKey };
|
|
}
|
|
|
|
return providers;
|
|
}
|
|
|
|
async function maybeBuildCopilotProvider(params: {
|
|
agentDir: string;
|
|
env?: NodeJS.ProcessEnv;
|
|
}): Promise<ProviderConfig | null> {
|
|
const env = params.env ?? process.env;
|
|
const authStore = ensureAuthProfileStore(params.agentDir);
|
|
const hasProfile =
|
|
listProfilesForProvider(authStore, "github-copilot").length > 0;
|
|
const envToken = env.COPILOT_GITHUB_TOKEN ?? env.GH_TOKEN ?? env.GITHUB_TOKEN;
|
|
const githubToken = (envToken ?? "").trim();
|
|
|
|
if (!hasProfile && !githubToken) return null;
|
|
|
|
let selectedGithubToken = githubToken;
|
|
if (!selectedGithubToken && hasProfile) {
|
|
// Use the first available profile as a default for discovery (it will be
|
|
// re-resolved per-run by the embedded runner).
|
|
const profileId = listProfilesForProvider(authStore, "github-copilot")[0];
|
|
const profile = profileId ? authStore.profiles[profileId] : undefined;
|
|
if (profile && profile.type === "token") {
|
|
selectedGithubToken = profile.token;
|
|
}
|
|
}
|
|
|
|
let baseUrl = DEFAULT_COPILOT_API_BASE_URL;
|
|
if (selectedGithubToken) {
|
|
try {
|
|
const token = await resolveCopilotApiToken({
|
|
githubToken: selectedGithubToken,
|
|
env,
|
|
});
|
|
baseUrl = token.baseUrl;
|
|
} catch {
|
|
baseUrl = DEFAULT_COPILOT_API_BASE_URL;
|
|
}
|
|
}
|
|
|
|
// pi-coding-agent's ModelRegistry marks a model "available" only if its
|
|
// `AuthStorage` has auth configured for that provider (via auth.json/env/etc).
|
|
// Our Copilot auth lives in Clawdbot's auth-profiles store instead, so we also
|
|
// write a runtime-only auth.json entry for pi-coding-agent to pick up.
|
|
//
|
|
// This is safe because it's (1) within Clawdbot's agent dir, (2) contains the
|
|
// GitHub token (not the exchanged Copilot token), and (3) matches existing
|
|
// patterns for OAuth-like providers in pi-coding-agent.
|
|
// Note: we deliberately do not write pi-coding-agent's `auth.json` here.
|
|
// Clawdbot uses its own auth store and exchanges tokens at runtime.
|
|
// `models list` uses Clawdbot's auth heuristics for availability.
|
|
|
|
// We intentionally do NOT define custom models for Copilot in models.json.
|
|
// pi-coding-agent treats providers with models as replacements requiring apiKey.
|
|
// We only override baseUrl; the model list comes from pi-ai built-ins.
|
|
return {
|
|
baseUrl,
|
|
models: [],
|
|
} satisfies ProviderConfig;
|
|
}
|
|
|
|
export async function ensureClawdbotModelsJson(
|
|
config?: ClawdbotConfig,
|
|
agentDirOverride?: string,
|
|
): Promise<{ agentDir: string; wrote: boolean }> {
|
|
const cfg = config ?? loadConfig();
|
|
const agentDir = agentDirOverride?.trim()
|
|
? agentDirOverride.trim()
|
|
: resolveClawdbotAgentDir();
|
|
|
|
const explicitProviders = cfg.models?.providers ?? {};
|
|
const implicitProviders = resolveImplicitProviders({ cfg, agentDir });
|
|
const providers: Record<string, ProviderConfig> = {
|
|
...implicitProviders,
|
|
...explicitProviders,
|
|
};
|
|
const implicitCopilot = await maybeBuildCopilotProvider({ agentDir });
|
|
if (implicitCopilot && !providers["github-copilot"]) {
|
|
providers["github-copilot"] = implicitCopilot;
|
|
}
|
|
|
|
if (Object.keys(providers).length === 0) {
|
|
return { agentDir, wrote: false };
|
|
}
|
|
|
|
const mode = cfg.models?.mode ?? DEFAULT_MODE;
|
|
const targetPath = path.join(agentDir, "models.json");
|
|
|
|
let mergedProviders = providers;
|
|
let existingRaw = "";
|
|
if (mode === "merge") {
|
|
const existing = await readJson(targetPath);
|
|
if (isRecord(existing) && isRecord(existing.providers)) {
|
|
const existingProviders = existing.providers as Record<
|
|
string,
|
|
NonNullable<ModelsConfig["providers"]>[string]
|
|
>;
|
|
mergedProviders = { ...existingProviders, ...providers };
|
|
}
|
|
}
|
|
|
|
const normalizedProviders = normalizeProviders({
|
|
providers: mergedProviders,
|
|
agentDir,
|
|
});
|
|
const next = `${JSON.stringify({ providers: normalizedProviders }, null, 2)}\n`;
|
|
try {
|
|
existingRaw = await fs.readFile(targetPath, "utf8");
|
|
} catch {
|
|
existingRaw = "";
|
|
}
|
|
|
|
if (existingRaw === next) {
|
|
return { agentDir, wrote: false };
|
|
}
|
|
|
|
await fs.mkdir(agentDir, { recursive: true, mode: 0o700 });
|
|
await fs.writeFile(targetPath, next, { mode: 0o600 });
|
|
return { agentDir, wrote: true };
|
|
}
|