@tokenbuddy/tokenbuddy 1.0.37 → 1.0.39

package/dist/src/provider-install.js

@@ -3,6 +3,9 @@ import * as os from "os";
 import * as path from "path";
 export const PROXY_ACCESS_TOKEN_PLACEHOLDER = "tbp_local_17821_d7f4c9a2b8e1";
 const DESKTOP_PROFILE_ID = "00000000-0000-4000-8000-000000178210";
+const CODEX_PROVIDER_ID = "TokenBuddy";
+const HERMES_PROVIDER_ID = "TokenBuddy";
+const OPENCLAW_TOKENBUDDY_PROVIDER_IDS = ["tokenbuddy", "tokens-buddy"];
 const CLAUDE_ONE_M_MARKER = "[1M]";
 const CLAUDE_CLIENT_HAIKU_MODEL = "claude-haiku-4-5";
 const CLAUDE_CLIENT_SONNET_MODEL = "claude-sonnet-4-6";
@@ -206,6 +209,100 @@ function removeTopLevelYamlSection(existing, sectionName) {
         ...lines.slice(sectionEnd),
     ].join("\n").replace(/\n*$/, "")}\n`;
 }
+function upsertTopLevelYamlObjectEntry(existing, sectionName, entryName, entryValue) {
+    const current = parseSimpleYamlObject(existing);
+    const section = isPlainRecord(current[sectionName])
+        ? { ...current[sectionName] }
+        : {};
+    const existingEntry = isPlainRecord(section[entryName])
+        ? section[entryName]
+        : {};
+    section[entryName] = {
+        ...existingEntry,
+        ...entryValue,
+    };
+    return replaceTopLevelYamlSection(existing, sectionName, yamlContent(section));
+}
+function removeTopLevelYamlObjectEntry(existing, sectionName, entryName, shouldRemove) {
+    const current = parseSimpleYamlObject(existing);
+    const section = isPlainRecord(current[sectionName])
+        ? { ...current[sectionName] }
+        : {};
+    const entry = section[entryName];
+    if (!isPlainRecord(entry) || !shouldRemove(entry)) {
+        return existing;
+    }
+    delete section[entryName];
+    if (Object.keys(section).length === 0) {
+        return removeTopLevelYamlSection(existing, sectionName);
+    }
+    return replaceTopLevelYamlSection(existing, sectionName, yamlContent(section));
+}
+function unquoteYamlScalar(value) {
+    const trimmed = value.trim();
+    if ((trimmed.startsWith('"') && trimmed.endsWith('"')) || (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+}
+function normalizedProviderName(value) {
+    return value.trim().toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function isTokenBuddyProviderIdentifier(value) {
+    if (typeof value !== "string") {
+        return false;
+    }
+    const normalized = normalizedProviderName(value);
+    return normalized === "tokenbuddy" || normalized === "tokensbuddy";
+}
+function isTokenBuddyProxyUrl(value) {
+    return typeof value === "string" && /(?:127\.0\.0\.1|localhost):17821\b/.test(value);
+}
+function yamlTopLevelListSectionEnd(lines, sectionStart) {
+    let index = sectionStart + 1;
+    while (index < lines.length) {
+        const line = lines[index];
+        if (line.trim() && /^[A-Za-z_][A-Za-z0-9_-]*:/.test(line)) {
+            break;
+        }
+        index += 1;
+    }
+    return index;
+}
+function removeTopLevelYamlListItems(existing, sectionName, shouldRemove) {
+    const lines = existing.split(/\r?\n/);
+    const sectionStart = lines.findIndex((line) => line === `${sectionName}:` || line.startsWith(`${sectionName}: `));
+    if (sectionStart < 0) {
+        return existing;
+    }
+    const sectionEnd = yamlTopLevelListSectionEnd(lines, sectionStart);
+    const sectionLines = lines.slice(sectionStart + 1, sectionEnd);
+    const keptLines = [];
+    let index = 0;
+    while (index < sectionLines.length) {
+        const line = sectionLines[index];
+        if (!line.startsWith("- ")) {
+            keptLines.push(line);
+            index += 1;
+            continue;
+        }
+        const itemStart = index;
+        index += 1;
+        while (index < sectionLines.length && !sectionLines[index].startsWith("- ")) {
+            index += 1;
+        }
+        const itemLines = sectionLines.slice(itemStart, index);
+        if (!shouldRemove(itemLines)) {
+            keptLines.push(...itemLines);
+        }
+    }
+    const before = lines.slice(0, sectionStart);
+    const after = lines.slice(sectionEnd);
+    const nextLines = keptLines.some((line) => line.trim())
+        ? [...before, `${sectionName}:`, ...keptLines, ...after]
+        : [...before, ...after];
+    return `${nextLines.join("\n").replace(/\n*$/, "")}\n`;
+}
 function readObjectField(value, key) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
         return undefined;
@@ -253,8 +350,11 @@ function resolveExecutable(commandName) {
 function escapeTomlString(value) {
     return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
 }
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 function replaceTomlSection(existing, sectionName, sectionBody) {
-    const sectionPattern = new RegExp(`^\\[${sectionName}\\]\\n[\\s\\S]*?(?=^\\[|\\s*$)`, "m");
+    const sectionPattern = new RegExp(`^\\[${escapeRegex(sectionName)}\\]\\n[\\s\\S]*?(?=^\\[|(?![\\s\\S]))`, "m");
     const normalized = existing.trimEnd();
     const nextSection = `[${sectionName}]\n${sectionBody.trimEnd()}\n`;
     if (sectionPattern.test(normalized)) {
@@ -262,6 +362,65 @@ function replaceTomlSection(existing, sectionName, sectionBody) {
     }
     return `${normalized}${normalized ? "\n\n" : ""}${nextSection}`;
 }
+function removeTomlSection(existing, sectionName) {
+    const sectionPattern = new RegExp(`^\\[${escapeRegex(sectionName)}\\]\\n[\\s\\S]*?(?=^\\[|(?![\\s\\S]))`, "m");
+    return `${existing.trimEnd().replace(sectionPattern, "").trimEnd()}\n`;
+}
+function tomlTopLevelEnd(lines) {
+    const sectionStart = lines.findIndex((line) => line.trimStart().startsWith("["));
+    return sectionStart >= 0 ? sectionStart : lines.length;
+}
+function upsertTopLevelTomlString(existing, key, value) {
+    const lines = existing.trimEnd() ? existing.trimEnd().split(/\r?\n/) : [];
+    const keyPattern = new RegExp(`^\\s*${escapeRegex(key)}\\s*=`);
+    const sectionStart = tomlTopLevelEnd(lines);
+    for (let index = 0; index < sectionStart; index += 1) {
+        if (keyPattern.test(lines[index])) {
+            lines[index] = `${key} = "${escapeTomlString(value)}"`;
+            return `${lines.join("\n")}\n`;
+        }
+    }
+    const entry = `${key} = "${escapeTomlString(value)}"`;
+    if (sectionStart < lines.length) {
+        const before = lines.slice(0, sectionStart);
+        const after = lines.slice(sectionStart);
+        if (before.length > 0 && before[before.length - 1].trim()) {
+            before.push(entry, "");
+        }
+        else {
+            before.push(entry);
+        }
+        return `${[...before, ...after].join("\n")}\n`;
+    }
+    lines.push(entry);
+    return `${lines.join("\n")}\n`;
+}
+function removeTopLevelTomlKey(existing, key) {
+    const lines = existing.trimEnd() ? existing.trimEnd().split(/\r?\n/) : [];
+    const keyPattern = new RegExp(`^\\s*${escapeRegex(key)}\\s*=`);
+    const sectionStart = tomlTopLevelEnd(lines);
+    const nextLines = [
+        ...lines.slice(0, sectionStart).filter((line) => !keyPattern.test(line)),
+        ...lines.slice(sectionStart),
+    ];
+    return nextLines.length > 0 ? `${nextLines.join("\n").replace(/\n*$/, "")}\n` : "";
+}
+function readTomlSection(existing, sectionName) {
+    const sectionPattern = new RegExp(`^\\[${escapeRegex(sectionName)}\\]\\n([\\s\\S]*?)(?=^\\[|(?![\\s\\S]))`, "m");
+    return sectionPattern.exec(existing)?.[1];
+}
+function readTopLevelTomlString(existing, key) {
+    const lines = existing.trimEnd() ? existing.trimEnd().split(/\r?\n/) : [];
+    const sectionStart = tomlTopLevelEnd(lines);
+    const keyPattern = new RegExp(`^\\s*${escapeRegex(key)}\\s*=\\s*["']([^"']+)["']`);
+    for (const line of lines.slice(0, sectionStart)) {
+        const match = keyPattern.exec(line);
+        if (match) {
+            return match[1];
+        }
+    }
+    return undefined;
+}
 function stripClaudeOneMMarker(model) {
     const trimmed = model.trimEnd();
     if (!trimmed.toLowerCase().endsWith(CLAUDE_ONE_M_MARKER.toLowerCase())) {
@@ -303,6 +462,23 @@ function pickConfiguredModel(config) {
     const haikuModel = config.roles.haiku?.upstreamModel;
     return sonnetModel || opusModel || haikuModel || config.fallbackModel || "";
 }
+function modelsForProtocol(config, protocol, defaultModel) {
+    if (config.selectionKind === "single-model" && config.availableModelsByProtocol) {
+        const models = uniqueModelIds(config.availableModelsByProtocol[protocol]);
+        if (models.length > 0) {
+            return models;
+        }
+    }
+    return uniqueModelIds([defaultModel]);
+}
+function orderedModelsForProtocol(config, protocol, defaultModel) {
+    const models = modelsForProtocol(config, protocol, defaultModel);
+    const trimmedDefault = defaultModel.trim();
+    if (!trimmedDefault || !models.includes(trimmedDefault)) {
+        return models;
+    }
+    return [trimmedDefault, ...models.filter((model) => model !== trimmedDefault)];
+}
 function resolveProviderRuntimeConfig(provider, options) {
     const selection = options.providerSelections?.[provider.id];
     if (selection) {
@@ -317,14 +493,52 @@ function resolveProviderRuntimeConfig(provider, options) {
 function codexConfig(home, proxyUrl, config) {
     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 = "${PROXY_ACCESS_TOKEN_PLACEHOLDER}"`,
-        `model = "${escapeTomlString(model)}"`,
+    const existing = removeTomlSection(readText(configPath) || "", "tokenbuddy");
+    let content = replaceTomlSection(existing, `model_providers.${CODEX_PROVIDER_ID}`, [
+        `name = "TokenBuddy"`,
+        `base_url = "${escapeTomlString(openAiBaseUrl(proxyUrl))}"`,
+        `wire_api = "responses"`,
+        `requires_openai_auth = true`,
+        `experimental_bearer_token = "${PROXY_ACCESS_TOKEN_PLACEHOLDER}"`,
     ].join("\n"));
+    content = upsertTopLevelTomlString(content, "model_provider", CODEX_PROVIDER_ID);
+    content = upsertTopLevelTomlString(content, "model", model);
     return [makeChange("codex", configPath, "configure TokenBuddy proxy for Codex", content)];
 }
+function isCodexTokenBuddyConfigured(filePath) {
+    const text = readText(filePath) || "";
+    const providerSection = readTomlSection(text, `model_providers.${CODEX_PROVIDER_ID}`);
+    const legacySection = readTomlSection(text, "tokenbuddy");
+    const topLevelProvider = readTopLevelTomlString(text, "model_provider");
+    const hasCurrentProvider = Boolean(providerSection) &&
+        topLevelProvider === CODEX_PROVIDER_ID &&
+        /wire_api\s*=\s*["']responses["']/.test(providerSection || "") &&
+        /base_url\s*=\s*["'][^"']*127\.0\.0\.1[^"']*\/v1["']/.test(providerSection || "") &&
+        new RegExp(`experimental_bearer_token\\s*=\\s*["']${escapeRegex(PROXY_ACCESS_TOKEN_PLACEHOLDER)}["']`).test(providerSection || "");
+    const hasLegacyProvider = Boolean(legacySection) &&
+        /proxy_url\s*=\s*["'][^"']*127\.0\.0\.1/.test(legacySection || "") &&
+        new RegExp(`api_key\\s*=\\s*["']${escapeRegex(PROXY_ACCESS_TOKEN_PLACEHOLDER)}["']`).test(legacySection || "");
+    return hasCurrentProvider || hasLegacyProvider;
+}
+function cleanupCodexConfig(home) {
+    const configPath = path.join(home, ".codex", "config.toml");
+    if (!fs.existsSync(configPath) || !isCodexTokenBuddyConfigured(configPath)) {
+        return [];
+    }
+    let next = readText(configPath) || "";
+    next = removeTomlSection(next, `model_providers.${CODEX_PROVIDER_ID}`);
+    next = removeTomlSection(next, "tokenbuddy");
+    if (readTopLevelTomlString(next, "model_provider") === CODEX_PROVIDER_ID) {
+        next = removeTopLevelTomlKey(next, "model_provider");
+        next = removeTopLevelTomlKey(next, "model");
+    }
+    if (next.trim()) {
+        fs.writeFileSync(configPath, next, "utf8");
+        return [{ providerId: "codex", path: configPath, action: "cleaned" }];
+    }
+    fs.rmSync(configPath, { force: true });
+    return [{ providerId: "codex", path: configPath, action: "removed" }];
+}
 function resolveClaudeFallbackAlias(config) {
     if (config.roles.sonnet?.upstreamModel) {
         return setClaudeOneMMarker(CLAUDE_CLIENT_SONNET_MODEL, Boolean(config.roles.sonnet.declareOneM));
@@ -448,6 +662,7 @@ function cleanupClaudeCodeConfig(home) {
 }
 function claudeDesktopConfig(home, proxyUrl, config) {
     const model = pickConfiguredModel(config);
+    const models = orderedModelsForProtocol(config, "messages", model);
     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");
@@ -465,7 +680,7 @@ function claudeDesktopConfig(home, proxyUrl, config) {
         inferenceGatewayAuthScheme: "bearer",
         inferenceGatewayBaseUrl: proxyUrl,
         inferenceProvider: "gateway",
-        inferenceModels: [{ name: model }],
+        inferenceModels: models.map((modelName) => ({ name: modelName })),
     };
     const meta = readJsonObject(metaPath);
     const existingEntries = Array.isArray(meta.entries) ? meta.entries : [];
@@ -507,12 +722,11 @@ function isClaudeDesktopTokenBuddyConfigured(_filePath, home) {
 }
 function cleanupClaudeDesktopConfig(home) {
     const paths = claudeDesktopPaths(home);
-    if (!isClaudeDesktopTokenBuddyConfigured(paths.configPath, home)) {
-        return [];
-    }
     const results = [];
+    const meta = readJsonObject(paths.metaPath);
+    const tokenBuddyIsActive = meta.appliedId === DESKTOP_PROFILE_ID;
     const primary = readJsonObject(paths.configPath);
-    if (primary.deploymentMode === "3p") {
+    if (tokenBuddyIsActive && primary.deploymentMode === "3p") {
         delete primary.deploymentMode;
         if (Object.keys(primary).length > 0) {
             fs.writeFileSync(paths.configPath, jsonContent(primary), "utf8");
@@ -524,7 +738,7 @@ function cleanupClaudeDesktopConfig(home) {
         }
     }
     const threep = readJsonObject(paths.threepConfigPath);
-    if (threep.deploymentMode === "3p") {
+    if (tokenBuddyIsActive && threep.deploymentMode === "3p") {
         delete threep.deploymentMode;
         if (Object.keys(threep).length > 0) {
             fs.writeFileSync(paths.threepConfigPath, jsonContent(threep), "utf8");
@@ -539,7 +753,6 @@ function cleanupClaudeDesktopConfig(home) {
         fs.rmSync(paths.profilePath, { force: true });
         results.push({ providerId: "claude-desktop", path: paths.profilePath, action: "removed" });
     }
-    const meta = readJsonObject(paths.metaPath);
     let changedMeta = false;
     if (meta.appliedId === DESKTOP_PROFILE_ID) {
         delete meta.appliedId;
@@ -547,7 +760,8 @@ function cleanupClaudeDesktopConfig(home) {
     }
     if (Array.isArray(meta.entries)) {
         const nextEntries = meta.entries.filter((entry) => {
-            return !(isPlainRecord(entry) && entry.id === DESKTOP_PROFILE_ID);
+            return !(isPlainRecord(entry) &&
+                (entry.id === DESKTOP_PROFILE_ID || entry.name === "TokenBuddy"));
         });
         if (nextEntries.length !== meta.entries.length) {
             meta.entries = nextEntries;
@@ -562,23 +776,19 @@ function cleanupClaudeDesktopConfig(home) {
 }
 function openclawConfig(home, proxyUrl, config) {
     const model = pickConfiguredModel(config);
+    const configuredModels = orderedModelsForProtocol(config, "chat_completions", model);
+    const defaultModel = configuredModels.includes(model) ? model : configuredModels[0] || model;
     const configPath = path.join(home, ".openclaw", "openclaw.json");
     const current = readJsonObject(configPath);
     const models = isPlainRecord(current.models) ? current.models : {};
     const providers = isPlainRecord(models.providers) ? models.providers : {};
     const existingProvider = isPlainRecord(providers.tokenbuddy) ? providers.tokenbuddy : {};
-    const existingModels = Array.isArray(existingProvider.models) ? existingProvider.models : [];
-    const nextModels = [
-        ...existingModels.filter((entry) => {
-            return !(isPlainRecord(entry) && entry.id === model);
-        }),
-        {
-            id: model,
-            name: model,
-            api: "openai-completions",
-            input: ["text", "image"],
-        },
-    ];
+    const nextModels = configuredModels.map((modelName) => ({
+        id: modelName,
+        name: modelName,
+        api: "openai-completions",
+        input: ["text", "image"],
+    }));
     providers.tokenbuddy = {
         ...existingProvider,
         baseUrl: openAiBaseUrl(proxyUrl),
@@ -591,29 +801,43 @@ function openclawConfig(home, proxyUrl, config) {
     current.models = models;
     const agents = isPlainRecord(current.agents) ? current.agents : {};
     const defaults = isPlainRecord(agents.defaults) ? agents.defaults : {};
-    defaults.model = `tokenbuddy/${model}`;
+    defaults.model = `tokenbuddy/${defaultModel}`;
     agents.defaults = defaults;
     current.agents = agents;
     return [makeChange("openclaw", configPath, "configure OpenClaw proxy settings", jsonContent(current))];
 }
+function isOpenclawTokenBuddyModelRef(value) {
+    if (typeof value !== "string") {
+        return false;
+    }
+    return isTokenBuddyProviderIdentifier(value.split("/", 1)[0]);
+}
 function isOpenclawTokenBuddyConfigured(filePath) {
     const current = readJsonObject(filePath);
-    const tokenbuddy = readObjectField(readObjectField(readObjectField(current, "models"), "providers"), "tokenbuddy");
+    const providers = readObjectField(readObjectField(current, "models"), "providers");
     const defaults = readObjectField(readObjectField(current, "agents"), "defaults");
-    if (!tokenbuddy || !defaults) {
-        return false;
+    if (providers) {
+        for (const providerId of OPENCLAW_TOKENBUDDY_PROVIDER_IDS) {
+            if (Object.prototype.hasOwnProperty.call(providers, providerId)) {
+                return true;
+            }
+        }
+    }
+    if (defaults && isOpenclawTokenBuddyModelRef(defaults.model)) {
+        return true;
     }
-    const defaultModel = defaults.model;
-    return tokenbuddy.apiKey === PROXY_ACCESS_TOKEN_PLACEHOLDER &&
-        typeof tokenbuddy.baseUrl === "string" &&
-        tokenbuddy.baseUrl.includes("127.0.0.1") &&
-        tokenbuddy.baseUrl.endsWith("/v1") &&
-        typeof defaultModel === "string" &&
-        defaultModel.startsWith("tokenbuddy/");
+    const defaultModels = readObjectField(defaults, "models");
+    if (defaultModels && Object.keys(defaultModels).some((modelRef) => isOpenclawTokenBuddyModelRef(modelRef))) {
+        return true;
+    }
+    const agentsList = readObjectField(current, "agents")?.list;
+    return Array.isArray(agentsList) && agentsList.some((agent) => {
+        return isPlainRecord(agent) && isOpenclawTokenBuddyModelRef(agent.model);
+    });
 }
 function cleanupOpenclawConfig(home) {
     const configPath = path.join(home, ".openclaw", "openclaw.json");
-    if (!fs.existsSync(configPath) || !isOpenclawTokenBuddyConfigured(configPath)) {
+    if (!fs.existsSync(configPath)) {
         return [];
     }
     const current = readJsonObject(configPath);
@@ -623,15 +847,35 @@ function cleanupOpenclawConfig(home) {
     const defaults = readObjectField(agents, "defaults");
     let changed = false;
     if (providers) {
-        changed = removeObjectKey(providers, "tokenbuddy") || changed;
+        for (const providerId of OPENCLAW_TOKENBUDDY_PROVIDER_IDS) {
+            changed = removeObjectKey(providers, providerId) || changed;
+        }
         if (models && Object.keys(providers).length === 0) {
             delete models.providers;
         }
     }
-    if (defaults && typeof defaults.model === "string" && defaults.model.startsWith("tokenbuddy/")) {
+    if (defaults && isOpenclawTokenBuddyModelRef(defaults.model)) {
         delete defaults.model;
         changed = true;
     }
+    const defaultModels = readObjectField(defaults, "models");
+    if (defaultModels) {
+        for (const modelRef of Object.keys(defaultModels)) {
+            changed = (isOpenclawTokenBuddyModelRef(modelRef) && removeObjectKey(defaultModels, modelRef)) || changed;
+        }
+        if (Object.keys(defaultModels).length === 0 && defaults) {
+            delete defaults.models;
+        }
+    }
+    const agentsList = agents?.list;
+    if (Array.isArray(agentsList)) {
+        for (const agent of agentsList) {
+            if (isPlainRecord(agent) && isOpenclawTokenBuddyModelRef(agent.model)) {
+                delete agent.model;
+                changed = true;
+            }
+        }
+    }
     if (!changed) {
         return [];
     }
@@ -642,6 +886,77 @@ function openAiBaseUrl(proxyUrl) {
     const normalized = proxyUrl.replace(/\/+$/, "");
     return normalized.endsWith("/v1") ? normalized : `${normalized}/v1`;
 }
+function anthropicBaseUrl(proxyUrl) {
+    const normalized = proxyUrl.replace(/\/+$/, "");
+    return normalized.endsWith("/v1") ? normalized.slice(0, -3) : normalized;
+}
+const OPENCODE_TOKENBUDDY_PROVIDERS = [
+    {
+        providerId: "tokenbuddy",
+        protocol: "chat_completions",
+        name: "TokenBuddy",
+        npm: "@ai-sdk/openai-compatible",
+        baseUrl: openAiBaseUrl,
+    },
+    {
+        providerId: "tokenbuddy-responses",
+        protocol: "responses",
+        name: "TokenBuddy Responses",
+        npm: "@ai-sdk/openai",
+        baseUrl: openAiBaseUrl,
+    },
+    {
+        providerId: "tokenbuddy-messages",
+        protocol: "messages",
+        name: "TokenBuddy Messages",
+        npm: "@ai-sdk/anthropic",
+        baseUrl: anthropicBaseUrl,
+    },
+];
+function uniqueModelIds(models) {
+    const seen = new Set();
+    const output = [];
+    for (const model of models ?? []) {
+        const trimmed = model.trim();
+        if (!trimmed || seen.has(trimmed)) {
+            continue;
+        }
+        seen.add(trimmed);
+        output.push(trimmed);
+    }
+    return output;
+}
+function opencodeModelsForProtocol(config, protocol, defaultModel) {
+    if (config.selectionKind === "single-model" && config.availableModelsByProtocol) {
+        return uniqueModelIds(config.availableModelsByProtocol[protocol]);
+    }
+    return protocol === "chat_completions" ? uniqueModelIds([defaultModel]) : [];
+}
+function opencodeModelConfig(model) {
+    return {
+        name: model,
+        attachment: true,
+        tool_call: true,
+    };
+}
+function opencodeDefaultModelRef(defaultModel, modelsByProvider) {
+    for (const provider of OPENCODE_TOKENBUDDY_PROVIDERS) {
+        if (modelsByProvider.get(provider.providerId)?.includes(defaultModel)) {
+            return `${provider.providerId}/${defaultModel}`;
+        }
+    }
+    for (const provider of OPENCODE_TOKENBUDDY_PROVIDERS) {
+        const firstModel = modelsByProvider.get(provider.providerId)?.[0];
+        if (firstModel) {
+            return `${provider.providerId}/${firstModel}`;
+        }
+    }
+    return `tokenbuddy/${defaultModel}`;
+}
+function isOpencodeTokenBuddyModelRef(value) {
+    return typeof value === "string" &&
+        OPENCODE_TOKENBUDDY_PROVIDERS.some((provider) => value.startsWith(`${provider.providerId}/`));
+}
 function opencodeConfig(home, proxyUrl, config) {
     const model = pickConfiguredModel(config);
     const configPath = path.join(home, ".config", "opencode", "opencode.json");
@@ -649,63 +964,86 @@ function opencodeConfig(home, proxyUrl, config) {
     const providers = current.provider && typeof current.provider === "object" && !Array.isArray(current.provider)
         ? current.provider
         : {};
-    providers.tokenbuddy = {
-        name: "TokenBuddy",
-        npm: "@ai-sdk/openai-compatible",
-        options: {
-            apiKey: PROXY_ACCESS_TOKEN_PLACEHOLDER,
-            baseURL: openAiBaseUrl(proxyUrl),
-        },
-        models: {
-            [model]: {
-                name: model,
-                attachment: true,
-                tool_call: true,
+    for (const provider of OPENCODE_TOKENBUDDY_PROVIDERS) {
+        delete providers[provider.providerId];
+    }
+    const modelsByProvider = new Map();
+    for (const provider of OPENCODE_TOKENBUDDY_PROVIDERS) {
+        const models = opencodeModelsForProtocol(config, provider.protocol, model);
+        if (models.length === 0) {
+            continue;
+        }
+        modelsByProvider.set(provider.providerId, models);
+        providers[provider.providerId] = {
+            name: provider.name,
+            npm: provider.npm,
+            options: {
+                apiKey: PROXY_ACCESS_TOKEN_PLACEHOLDER,
+                baseURL: provider.baseUrl(proxyUrl),
             },
-        },
-    };
+            models: Object.fromEntries(models.map((modelId) => [modelId, opencodeModelConfig(modelId)])),
+        };
+    }
     current.provider = providers;
     // 写顶层 model / small_model，让 opencode 默认走 tokenbuddy 而不是残留的 openai/qwen-plus 死链
-    current.model = `tokenbuddy/${model}`;
-    current.small_model = `tokenbuddy/${model}`;
+    const defaultModelRef = opencodeDefaultModelRef(model, modelsByProvider);
+    current.model = defaultModelRef;
+    current.small_model = defaultModelRef;
     return [makeChange("opencode", configPath, "configure OpenCode provider for TokenBuddy proxy", jsonContent(current))];
 }
+function isLegacyOpencodeTokenBuddyProvider(providerId, providerConfig) {
+    if (providerId !== "openai" || !isPlainRecord(providerConfig)) {
+        return false;
+    }
+    const options = readObjectField(providerConfig, "options");
+    const apiKey = options?.apiKey;
+    const tokenBuddyKey = apiKey === PROXY_ACCESS_TOKEN_PLACEHOLDER ||
+        (typeof apiKey === "string" && apiKey.toUpperCase().startsWith("TOKENBUDDY_"));
+    return tokenBuddyKey && isTokenBuddyProxyUrl(options?.baseURL);
+}
 function isOpencodeTokenBuddyConfigured(filePath) {
     const current = readJsonObject(filePath);
-    const tokenbuddy = readObjectField(readObjectField(current, "provider"), "tokenbuddy");
-    const options = readObjectField(tokenbuddy, "options");
-    if (!tokenbuddy || !options) {
-        return false;
+    const providers = readObjectField(current, "provider");
+    if (providers) {
+        for (const provider of OPENCODE_TOKENBUDDY_PROVIDERS) {
+            if (Object.prototype.hasOwnProperty.call(providers, provider.providerId)) {
+                return true;
+            }
+        }
+        for (const [providerId, providerConfig] of Object.entries(providers)) {
+            if (isLegacyOpencodeTokenBuddyProvider(providerId, providerConfig)) {
+                return true;
+            }
+        }
     }
-    return tokenbuddy.npm === "@ai-sdk/openai-compatible" &&
-        options.apiKey === PROXY_ACCESS_TOKEN_PLACEHOLDER &&
-        typeof options.baseURL === "string" &&
-        options.baseURL.includes("127.0.0.1") &&
-        options.baseURL.endsWith("/v1") &&
-        typeof current.model === "string" &&
-        current.model.startsWith("tokenbuddy/") &&
-        typeof current.small_model === "string" &&
-        current.small_model.startsWith("tokenbuddy/");
+    return isOpencodeTokenBuddyModelRef(current.model) || isOpencodeTokenBuddyModelRef(current.small_model);
 }
 function cleanupOpencodeConfig(home) {
     const configPath = path.join(home, ".config", "opencode", "opencode.json");
-    if (!fs.existsSync(configPath) || !isOpencodeTokenBuddyConfigured(configPath)) {
+    if (!fs.existsSync(configPath)) {
         return [];
     }
     const current = readJsonObject(configPath);
     const providers = readObjectField(current, "provider");
     let changed = false;
     if (providers) {
-        changed = removeObjectKey(providers, "tokenbuddy") || changed;
+        for (const provider of OPENCODE_TOKENBUDDY_PROVIDERS) {
+            changed = removeObjectKey(providers, provider.providerId) || changed;
+        }
+        for (const [providerId, providerConfig] of Object.entries(providers)) {
+            changed = (isLegacyOpencodeTokenBuddyProvider(providerId, providerConfig) && removeObjectKey(providers, providerId)) || changed;
+        }
         if (Object.keys(providers).length === 0) {
             delete current.provider;
         }
     }
-    if (typeof current.model === "string" && current.model.startsWith("tokenbuddy/")) {
+    const model = current.model;
+    if (isOpencodeTokenBuddyModelRef(model)) {
         delete current.model;
         changed = true;
     }
-    if (typeof current.small_model === "string" && current.small_model.startsWith("tokenbuddy/")) {
+    const smallModel = current.small_model;
+    if (isOpencodeTokenBuddyModelRef(smallModel)) {
         delete current.small_model;
         changed = true;
     }
@@ -725,39 +1063,117 @@ function hermesConfig(home, proxyUrl, config) {
     const existing = readText(configPath) || "";
     const current = parseSimpleYamlObject(existing);
     const modelConfig = isPlainRecord(current.model) ? current.model : {};
+    const baseUrl = openAiBaseUrl(proxyUrl);
     const nextModelConfig = {
         ...modelConfig,
         default: model,
-        provider: "custom",
-        base_url: openAiBaseUrl(proxyUrl),
+        provider: HERMES_PROVIDER_ID,
+        base_url: baseUrl,
         api_key: PROXY_ACCESS_TOKEN_PLACEHOLDER,
         api_mode: "chat_completions",
     };
-    const content = replaceTopLevelYamlSection(existing, "model", yamlContent(nextModelConfig));
+    const withModel = replaceTopLevelYamlSection(existing, "model", yamlContent(nextModelConfig));
+    const content = upsertTopLevelYamlObjectEntry(withModel, "providers", HERMES_PROVIDER_ID, {
+        name: HERMES_PROVIDER_ID,
+        base_url: baseUrl,
+        api_key: PROXY_ACCESS_TOKEN_PLACEHOLDER,
+        transport: "chat_completions",
+        default_model: model,
+    });
     return [makeChange("hermes", configPath, "configure Hermes OpenAI proxy settings", content)];
 }
-function isHermesTokenBuddyConfigured(filePath) {
-    const current = readYamlObject(filePath);
-    const modelConfig = readObjectField(current, "model");
-    if (!modelConfig) {
+function isHermesTokenBuddyBaseUrl(value) {
+    return typeof value === "string" &&
+        value.includes("127.0.0.1") &&
+        value.endsWith("/v1");
+}
+function isHermesTokenBuddyProviderValue(value) {
+    if (typeof value !== "string") {
         return false;
     }
-    return modelConfig.provider === "custom" &&
+    const normalized = value.trim().toLowerCase();
+    return normalized === "custom" ||
+        normalized === HERMES_PROVIDER_ID.toLowerCase() ||
+        normalized === "custom:tokenbuddy";
+}
+function isHermesTokenBuddyProviderEntry(entry) {
+    return entry.api_key === PROXY_ACCESS_TOKEN_PLACEHOLDER &&
+        isHermesTokenBuddyBaseUrl(entry.base_url) &&
+        (entry.transport === "chat_completions" || entry.api_mode === "chat_completions");
+}
+function isHermesTokenBuddyCustomProviderItem(itemLines) {
+    let name = "";
+    let baseUrl = "";
+    let apiKey = "";
+    for (const line of itemLines) {
+        const nameMatch = /^\s*-\s*name:\s*(.+)\s*$/.exec(line) ?? /^\s*name:\s*(.+)\s*$/.exec(line);
+        if (nameMatch) {
+            name = unquoteYamlScalar(nameMatch[1]);
+            continue;
+        }
+        const baseUrlMatch = /^\s*base_url:\s*(.+)\s*$/.exec(line);
+        if (baseUrlMatch) {
+            baseUrl = unquoteYamlScalar(baseUrlMatch[1]);
+            continue;
+        }
+        const apiKeyMatch = /^\s*api_key:\s*(.+)\s*$/.exec(line);
+        if (apiKeyMatch) {
+            apiKey = unquoteYamlScalar(apiKeyMatch[1]);
+        }
+    }
+    const normalizedName = normalizedProviderName(name);
+    return normalizedName === "tokenbuddy" ||
+        normalizedName === "tokensbuddy" ||
+        (isHermesTokenBuddyBaseUrl(baseUrl) && apiKey === PROXY_ACCESS_TOKEN_PLACEHOLDER);
+}
+function hasHermesTokenBuddyCustomProvider(text) {
+    let found = false;
+    removeTopLevelYamlListItems(text, "custom_providers", (itemLines) => {
+        if (isHermesTokenBuddyCustomProviderItem(itemLines)) {
+            found = true;
+        }
+        return false;
+    });
+    return found;
+}
+function isHermesTokenBuddyModelConfig(modelConfig, namedProviderConfigured) {
+    return isHermesTokenBuddyProviderValue(modelConfig.provider) &&
         modelConfig.api_key === PROXY_ACCESS_TOKEN_PLACEHOLDER &&
         modelConfig.api_mode === "chat_completions" &&
-        typeof modelConfig.base_url === "string" &&
-        modelConfig.base_url.includes("127.0.0.1") &&
-        modelConfig.base_url.endsWith("/v1") &&
+        (isHermesTokenBuddyBaseUrl(modelConfig.base_url) || namedProviderConfigured) &&
         typeof modelConfig.default === "string" &&
         modelConfig.default.length > 0;
 }
+function isHermesTokenBuddyConfigured(filePath) {
+    const text = readText(filePath) || "";
+    const current = readYamlObject(filePath);
+    const modelConfig = readObjectField(current, "model");
+    if (!modelConfig) {
+        return hasHermesTokenBuddyCustomProvider(text);
+    }
+    const hasTokenBuddyCustomProvider = hasHermesTokenBuddyCustomProvider(text);
+    const providersConfig = readObjectField(current, "providers");
+    const tokenBuddyProvider = readObjectField(providersConfig, HERMES_PROVIDER_ID);
+    const namedProviderConfigured = Boolean(tokenBuddyProvider && isHermesTokenBuddyProviderEntry(tokenBuddyProvider));
+    const hasTokenBuddyModel = isHermesTokenBuddyModelConfig(modelConfig, namedProviderConfigured);
+    return hasTokenBuddyModel || hasTokenBuddyCustomProvider;
+}
 function cleanupHermesConfig(home) {
     const configPath = path.join(home, ".hermes", "config.yaml");
     if (!fs.existsSync(configPath) || !isHermesTokenBuddyConfigured(configPath)) {
         return [];
     }
     const existing = readText(configPath) || "";
-    const next = removeTopLevelYamlSection(existing, "model");
+    const current = parseSimpleYamlObject(existing);
+    const modelConfig = readObjectField(current, "model");
+    const providersConfig = readObjectField(current, "providers");
+    const tokenBuddyProvider = readObjectField(providersConfig, HERMES_PROVIDER_ID);
+    const namedProviderConfigured = Boolean(tokenBuddyProvider && isHermesTokenBuddyProviderEntry(tokenBuddyProvider));
+    const withoutModel = modelConfig && isHermesTokenBuddyModelConfig(modelConfig, namedProviderConfigured)
+        ? removeTopLevelYamlSection(existing, "model")
+        : existing;
+    const withoutProvider = removeTopLevelYamlObjectEntry(withoutModel, "providers", HERMES_PROVIDER_ID, isHermesTokenBuddyProviderEntry);
+    const next = removeTopLevelYamlListItems(withoutProvider, "custom_providers", isHermesTokenBuddyCustomProviderItem);
     if (next.trim()) {
         fs.writeFileSync(configPath, next, "utf8");
         return [{ providerId: "hermes", path: configPath, action: "cleaned" }];
@@ -771,7 +1187,9 @@ const PROVIDERS = [
         name: "Codex CLI",
         commandName: "codex",
         configPath: (home) => path.join(home, ".codex", "config.toml"),
+        isConfigured: isCodexTokenBuddyConfigured,
         changes: codexConfig,
+        cleanup: cleanupCodexConfig,
         modelSelectionKind: "single-model",
         protocolPreference: "responses",
     },
@@ -982,6 +1400,8 @@ export function applyProviderInstall(options, store) {
 /**
  * 回滚 provider 安装。
  * 从 `store` 读取安装前的快照，恢复原文件（如果快照里有原始内容）。
+ * 恢复后仍会执行 provider cleanup，确保 repeated apply 或旧 TokenBuddy
+ * 配置升级后的 disconnect 语义是移除 TokenBuddy，而不是恢复旧 TokenBuddy。
  * 没有快照的 provider 标记为 `missing_snapshot`。
  *
  * @param options 回滚选项
@@ -1020,6 +1440,7 @@ export function rollbackProviderInstall(options, store) {
                 results.push({ providerId, path: file.path, action: "removed" });
             }
         }
+        results.push(...(provider.cleanup?.(home) ?? []));
         store.removeProviderInstallSnapshot(providerId);
         store.removeProviderRuntimeConfig(providerId);
     }