negodiy/openclaw
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

refactor: split minimax-cn provider

Browse Source
This commit is contained in:
Peter Steinberger
2026-02-14 13:37:04 +01:00
parent bf080c2338
commit 1ba266a8e8
7 changed files with 111 additions and 86 deletions
Download Patch File Download Diff File Expand all files Collapse all files

80
src/commands/auth-choice.apply.minimax.ts
View File

@@ -23,6 +23,30 @@ export async function applyAuthChoiceMiniMax(
): Promise<ApplyAuthChoiceResult | null> {
let nextConfig = params.config;
let agentModelOverride: string | undefined;
const ensureMinimaxApiKey = async (opts: {
profileId: string;
promptMessage: string;
}): Promise<void> => {
let hasCredential = false;
const envKey = resolveEnvApiKey("minimax");
if (envKey) {
const useExisting = await params.prompter.confirm({
message: `Use existing MINIMAX_API_KEY (${envKey.source}, ${formatApiKeyPreview(envKey.apiKey)})?`,
initialValue: true,
});
if (useExisting) {
await setMinimaxApiKey(envKey.apiKey, params.agentDir, opts.profileId);
hasCredential = true;
}
}
if (!hasCredential) {
const key = await params.prompter.text({
message: opts.promptMessage,
validate: validateApiKeyInput,
});
await setMinimaxApiKey(normalizeApiKeyInput(String(key)), params.agentDir, opts.profileId);
}
};
const noteAgentModel = async (model: string) => {
if (!params.agentId) {
return;
@@ -58,25 +82,10 @@ export async function applyAuthChoiceMiniMax(
) {
const modelId =
params.authChoice === "minimax-api-lightning" ? "MiniMax-M2.5-Lightning" : "MiniMax-M2.5";
let hasCredential = false;
const envKey = resolveEnvApiKey("minimax");
if (envKey) {
const useExisting = await params.prompter.confirm({
message: `Use existing MINIMAX_API_KEY (${envKey.source}, ${formatApiKeyPreview(envKey.apiKey)})?`,
initialValue: true,
});
if (useExisting) {
await setMinimaxApiKey(envKey.apiKey, params.agentDir);
hasCredential = true;
}
}
if (!hasCredential) {
const key = await params.prompter.text({
message: "Enter MiniMax API key",
validate: validateApiKeyInput,
});
await setMinimaxApiKey(normalizeApiKeyInput(String(key)), params.agentDir);
}
await ensureMinimaxApiKey({
profileId: "minimax:default",
promptMessage: "Enter MiniMax API key",
});
nextConfig = applyAuthProfileConfig(nextConfig, {
profileId: "minimax:default",
provider: "minimax",
@@ -101,38 +110,23 @@ export async function applyAuthChoiceMiniMax(
if (params.authChoice === "minimax-api-key-cn") {
const modelId = "MiniMax-M2.5";
let hasCredential = false;
const envKey = resolveEnvApiKey("minimax");
if (envKey) {
const useExisting = await params.prompter.confirm({
message: `Use existing MINIMAX_API_KEY (${envKey.source}, ${formatApiKeyPreview(envKey.apiKey)})?`,
initialValue: true,
});
if (useExisting) {
await setMinimaxApiKey(envKey.apiKey, params.agentDir);
hasCredential = true;
}
}
if (!hasCredential) {
const key = await params.prompter.text({
message: "Enter MiniMax China API key",
validate: validateApiKeyInput,
});
await setMinimaxApiKey(normalizeApiKeyInput(String(key)), params.agentDir);
}
await ensureMinimaxApiKey({
profileId: "minimax-cn:default",
promptMessage: "Enter MiniMax China API key",
});
nextConfig = applyAuthProfileConfig(nextConfig, {
profileId: "minimax:default",
provider: "minimax",
profileId: "minimax-cn:default",
provider: "minimax-cn",
mode: "api_key",
});
{
const modelRef = `minimax/${modelId}`;
const modelRef = `minimax-cn/${modelId}`;
const applied = await applyDefaultModelChoice({
config: nextConfig,
setDefaultModel: params.setDefaultModel,
defaultModel: modelRef,
applyDefaultConfig: applyMinimaxApiConfigCn,
applyProviderConfig: applyMinimaxApiProviderConfigCn,
applyDefaultConfig: (config) => applyMinimaxApiConfigCn(config, modelId),
applyProviderConfig: (config) => applyMinimaxApiProviderConfigCn(config, modelId),
noteAgentModel,
prompter: params.prompter,
});

8
src/commands/auth-choice.e2e.test.ts
View File

@@ -253,18 +253,18 @@ describe("applyAuthChoice", () => {
expect(text).toHaveBeenCalledWith(
expect.objectContaining({ message: "Enter MiniMax China API key" }),
);
expect(result.config.auth?.profiles?.["minimax:default"]).toMatchObject({
provider: "minimax",
expect(result.config.auth?.profiles?.["minimax-cn:default"]).toMatchObject({
provider: "minimax-cn",
mode: "api_key",
});
expect(result.config.models?.providers?.minimax?.baseUrl).toBe(MINIMAX_CN_API_BASE_URL);
expect(result.config.models?.providers?.["minimax-cn"]?.baseUrl).toBe(MINIMAX_CN_API_BASE_URL);
const authProfilePath = authProfilePathFor(requireAgentDir());
const raw = await fs.readFile(authProfilePath, "utf8");
const parsed = JSON.parse(raw) as {
profiles?: Record<string, { key?: string }>;
};
expect(parsed.profiles?.["minimax:default"]?.key).toBe("sk-minimax-test");
expect(parsed.profiles?.["minimax-cn:default"]?.key).toBe("sk-minimax-test");
});
it("prompts and writes Synthetic API key when selecting synthetic-api-key", async () => {

2
src/commands/auth-choice.preferred-provider.ts
View File

@@ -34,7 +34,7 @@ const PREFERRED_PROVIDER_BY_AUTH_CHOICE: Partial<Record<AuthChoice, string>> = {
"copilot-proxy": "copilot-proxy",
"minimax-cloud": "minimax",
"minimax-api": "minimax",
"minimax-api-key-cn": "minimax",
"minimax-api-key-cn": "minimax-cn",
"minimax-api-lightning": "minimax",
minimax: "lmstudio",
"opencode-zen": "opencode",

68
src/commands/onboard-auth.config-minimax.ts
View File

@@ -1,4 +1,5 @@
import type { OpenClawConfig } from "../config/config.js";
import type { ModelProviderConfig } from "../config/types.models.js";
import {
buildMinimaxApiModelDefinition,
buildMinimaxModelDefinition,
@@ -151,14 +152,22 @@ export function applyMinimaxApiProviderConfig(
cfg: OpenClawConfig,
modelId: string = "MiniMax-M2.5",
): OpenClawConfig {
return applyMinimaxApiProviderConfigWithBaseUrl(cfg, modelId, MINIMAX_API_BASE_URL);
return applyMinimaxApiProviderConfigWithBaseUrl(cfg, {
providerId: "minimax",
modelId,
baseUrl: MINIMAX_API_BASE_URL,
});
}
export function applyMinimaxApiConfig(
cfg: OpenClawConfig,
modelId: string = "MiniMax-M2.5",
): OpenClawConfig {
return applyMinimaxApiConfigWithBaseUrl(cfg, modelId, MINIMAX_API_BASE_URL);
return applyMinimaxApiConfigWithBaseUrl(cfg, {
providerId: "minimax",
modelId,
baseUrl: MINIMAX_API_BASE_URL,
});
}
// MiniMax China API (api.minimaxi.com)
@@ -166,44 +175,58 @@ export function applyMinimaxApiProviderConfigCn(
cfg: OpenClawConfig,
modelId: string = "MiniMax-M2.5",
): OpenClawConfig {
return applyMinimaxApiProviderConfigWithBaseUrl(cfg, modelId, MINIMAX_CN_API_BASE_URL);
return applyMinimaxApiProviderConfigWithBaseUrl(cfg, {
providerId: "minimax-cn",
modelId,
baseUrl: MINIMAX_CN_API_BASE_URL,
});
}
export function applyMinimaxApiConfigCn(
cfg: OpenClawConfig,
modelId: string = "MiniMax-M2.5",
): OpenClawConfig {
return applyMinimaxApiConfigWithBaseUrl(cfg, modelId, MINIMAX_CN_API_BASE_URL);
return applyMinimaxApiConfigWithBaseUrl(cfg, {
providerId: "minimax-cn",
modelId,
baseUrl: MINIMAX_CN_API_BASE_URL,
});
}
type MinimaxApiProviderConfigParams = {
providerId: string;
modelId: string;
baseUrl: string;
};
function applyMinimaxApiProviderConfigWithBaseUrl(
cfg: OpenClawConfig,
modelId: string,
baseUrl: string,
params: MinimaxApiProviderConfigParams,
): OpenClawConfig {
const providers = { ...cfg.models?.providers };
const existingProvider = providers.minimax;
const existingModels = Array.isArray(existingProvider?.models) ? existingProvider.models : [];
const apiModel = buildMinimaxApiModelDefinition(modelId);
const hasApiModel = existingModels.some((model) => model.id === modelId);
const providers = { ...cfg.models?.providers } as Record<string, ModelProviderConfig>;
const existingProvider = providers[params.providerId];
const existingModels = existingProvider?.models ?? [];
const apiModel = buildMinimaxApiModelDefinition(params.modelId);
const hasApiModel = existingModels.some((model) => model.id === params.modelId);
const mergedModels = hasApiModel ? existingModels : [...existingModels, apiModel];
const { apiKey: existingApiKey, ...existingProviderRest } = (existingProvider ?? {}) as Record<
string,
unknown
> as { apiKey?: string };
const { apiKey: existingApiKey, ...existingProviderRest } = existingProvider ?? {
baseUrl: params.baseUrl,
models: [],
};
const resolvedApiKey = typeof existingApiKey === "string" ? existingApiKey : undefined;
const normalizedApiKey = resolvedApiKey?.trim() === "minimax" ? "" : resolvedApiKey;
providers.minimax = {
providers[params.providerId] = {
...existingProviderRest,
baseUrl,
baseUrl: params.baseUrl,
api: "anthropic-messages",
...(normalizedApiKey?.trim() ? { apiKey: normalizedApiKey } : {}),
models: mergedModels.length > 0 ? mergedModels : [apiModel],
};
const models = { ...cfg.agents?.defaults?.models };
models[`minimax/${modelId}`] = {
...models[`minimax/${modelId}`],
const modelRef = `${params.providerId}/${params.modelId}`;
models[modelRef] = {
...models[modelRef],
alias: "Minimax",
};
@@ -222,10 +245,9 @@ function applyMinimaxApiProviderConfigWithBaseUrl(
function applyMinimaxApiConfigWithBaseUrl(
cfg: OpenClawConfig,
modelId: string,
baseUrl: string,
params: MinimaxApiProviderConfigParams,
): OpenClawConfig {
const next = applyMinimaxApiProviderConfigWithBaseUrl(cfg, modelId, baseUrl);
const next = applyMinimaxApiProviderConfigWithBaseUrl(cfg, params);
return {
...next,
agents: {
@@ -239,7 +261,7 @@ function applyMinimaxApiConfigWithBaseUrl(
fallbacks: (next.agents.defaults.model as { fallbacks?: string[] }).fallbacks,
}
: undefined),
primary: `minimax/${modelId}`,
primary: `${params.providerId}/${params.modelId}`,
},
},
},

11
src/commands/onboard-auth.credentials.ts
View File

@@ -50,13 +50,18 @@ export async function setGeminiApiKey(key: string, agentDir?: string) {
});
}
export async function setMinimaxApiKey(key: string, agentDir?: string) {
export async function setMinimaxApiKey(
key: string,
agentDir?: string,
profileId: string = "minimax:default",
) {
const provider = profileId.split(":")[0] ?? "minimax";
// Write to resolved agent dir so gateway finds credentials on startup.
upsertAuthProfile({
profileId: "minimax:default",
profileId,
credential: {
type: "api_key",
provider: "minimax",
provider,
key,
},
agentDir: resolveAuthAgentDir(agentDir),

15
src/commands/onboard-non-interactive.provider-auth.e2e.test.ts
View File

@@ -3,6 +3,7 @@ import os from "node:os";
import path from "node:path";
import { setTimeout as delay } from "node:timers/promises";
import { describe, expect, it } from "vitest";
import { MINIMAX_API_BASE_URL, MINIMAX_CN_API_BASE_URL } from "./onboard-auth.js";
import { OPENAI_DEFAULT_MODEL } from "./openai-model-default.js";
type RuntimeMock = {
@@ -178,7 +179,7 @@ describe("onboard (non-interactive): provider auth", () => {
expect(cfg.auth?.profiles?.["minimax:default"]?.provider).toBe("minimax");
expect(cfg.auth?.profiles?.["minimax:default"]?.mode).toBe("api_key");
expect(cfg.models?.providers?.minimax?.baseUrl).toBe("https://api.minimax.io/anthropic");
expect(cfg.models?.providers?.minimax?.baseUrl).toBe(MINIMAX_API_BASE_URL);
expect(cfg.agents?.defaults?.model?.primary).toBe("minimax/MiniMax-M2.5");
await expectApiKeyProfile({
profileId: "minimax:default",
@@ -209,13 +210,13 @@ describe("onboard (non-interactive): provider auth", () => {
models?: { providers?: Record<string, { baseUrl?: string }> };
}>(configPath);
expect(cfg.auth?.profiles?.["minimax:default"]?.provider).toBe("minimax");
expect(cfg.auth?.profiles?.["minimax:default"]?.mode).toBe("api_key");
expect(cfg.models?.providers?.minimax?.baseUrl).toBe("https://api.minimaxi.com/anthropic");
expect(cfg.agents?.defaults?.model?.primary).toBe("minimax/MiniMax-M2.5");
expect(cfg.auth?.profiles?.["minimax-cn:default"]?.provider).toBe("minimax-cn");
expect(cfg.auth?.profiles?.["minimax-cn:default"]?.mode).toBe("api_key");
expect(cfg.models?.providers?.["minimax-cn"]?.baseUrl).toBe(MINIMAX_CN_API_BASE_URL);
expect(cfg.agents?.defaults?.model?.primary).toBe("minimax-cn/MiniMax-M2.5");
await expectApiKeyProfile({
profileId: "minimax:default",
provider: "minimax",
profileId: "minimax-cn:default",
provider: "minimax-cn",
key: "sk-minimax-test",
});
});

13
src/commands/onboard-non-interactive/local/auth-choice.ts
View File

@@ -574,8 +574,11 @@ export async function applyNonInteractiveAuthChoice(params: {
authChoice === "minimax-api-key-cn" ||
authChoice === "minimax-api-lightning"
) {
const isCn = authChoice === "minimax-api-key-cn";
const providerId = isCn ? "minimax-cn" : "minimax";
const profileId = `${providerId}:default`;
const resolved = await resolveNonInteractiveApiKey({
provider: "minimax",
provider: providerId,
cfg: baseConfig,
flagValue: opts.minimaxApiKey,
flagName: "--minimax-api-key",
@@ -586,16 +589,16 @@ export async function applyNonInteractiveAuthChoice(params: {
return null;
}
if (resolved.source !== "profile") {
await setMinimaxApiKey(resolved.key);
await setMinimaxApiKey(resolved.key, undefined, profileId);
}
nextConfig = applyAuthProfileConfig(nextConfig, {
profileId: "minimax:default",
provider: "minimax",
profileId,
provider: providerId,
mode: "api_key",
});
const modelId =
authChoice === "minimax-api-lightning" ? "MiniMax-M2.5-Lightning" : "MiniMax-M2.5";
return authChoice === "minimax-api-key-cn"
return isCn
? applyMinimaxApiConfigCn(nextConfig, modelId)
: applyMinimaxApiConfig(nextConfig, modelId);
}