theclawbay 0.3.31 → 0.3.33

package/README.md

@@ -18,6 +18,7 @@ theclawbay setup --api-key <apiKey>
 
 In an interactive terminal, setup shows one picker for Codex, Continue, Cline, OpenClaw, OpenCode, Kilo, Roo Code, Aider, and Windows Trae.
 Each row includes a terminal-friendly icon plus the tool's official site, and you can toggle items with arrow keys plus `Enter` or by pressing their number.
+Re-running setup also migrates legacy OpenCode and Kilo patches to the current reasoning-capable provider path and refreshes OpenClaw model metadata.
 
 ## Optional
 

package/dist/commands/logout.js

@@ -13,6 +13,7 @@ const codex_auth_seeding_1 = require("../lib/codex-auth-seeding");
 const codex_history_migration_1 = require("../lib/codex-history-migration");
 const codex_model_cache_migration_1 = require("../lib/codex-model-cache-migration");
 const paths_1 = require("../lib/config/paths");
+const supported_models_1 = require("../lib/supported-models");
 const OPENAI_PROVIDER_ID = "openai";
 const DEFAULT_PROVIDER_ID = "theclawbay";
 const WAN_PROVIDER_ID = "theclawbay-wan";
@@ -29,6 +30,8 @@ const CLINE_GLOBAL_STATE_PATH = node_path_1.default.join(node_os_1.default.homed
 const CLINE_SECRETS_PATH = node_path_1.default.join(node_os_1.default.homedir(), ".cline", "data", "secrets.json");
 const AIDER_CONFIG_PATH = node_path_1.default.join(node_os_1.default.homedir(), ".aider.conf.yml");
 const CLINE_RESTORE_STATE_PATH = node_path_1.default.join(paths_1.theclawbayStateDir, "cline.restore.json");
+const OPENCODE_RESTORE_STATE_PATH = node_path_1.default.join(paths_1.theclawbayStateDir, "opencode.restore.json");
+const KILO_RESTORE_STATE_PATH = node_path_1.default.join(paths_1.theclawbayStateDir, "kilo.restore.json");
 const ROO_SETTINGS_STATE_PATH = node_path_1.default.join(paths_1.theclawbayStateDir, "roo-settings.restore.json");
 const ROO_IMPORT_FILE = node_path_1.default.join(paths_1.theclawbayConfigDir, "roo-code-settings.json");
 const MIGRATION_STATE_FILE = node_path_1.default.join(paths_1.codexDir, "theclawbay.migration.json");
@@ -39,6 +42,7 @@ const HISTORY_PROVIDER_NEUTRALIZE_SOURCES = new Set([
 ]);
 const HISTORY_PROVIDER_DB_MIGRATE_SOURCES = [DEFAULT_PROVIDER_ID, WAN_PROVIDER_ID];
 const THECLAWBAY_OPENAI_PROXY_SUFFIX = "/api/codex-auth/v1/proxy/v1";
+const SUPPORTED_MODEL_IDS = new Set((0, supported_models_1.getSupportedModelIds)());
 const CONTINUE_MODEL_NAME = "The Claw Bay";
 const TRAE_PATCH_MARKER = "theclawbay-trae-patch";
 const TRAE_BUNDLE_BACKUP_SUFFIX = ".theclawbay-managed-backup";
@@ -179,6 +183,18 @@ async function writeJsonFile(filePath, value, mode) {
     if (mode !== undefined)
         await promises_1.default.chmod(filePath, mode);
 }
+function isManagedOpenCodeModel(value) {
+    if (typeof value !== "string")
+        return false;
+    if (!value.startsWith(`${OPENAI_PROVIDER_ID}/`))
+        return false;
+    return SUPPORTED_MODEL_IDS.has(value.slice(`${OPENAI_PROVIDER_ID}/`.length));
+}
+function isManagedOpenCodeProvider(value) {
+    const provider = objectRecordOr(value, {});
+    const options = objectRecordOr(provider.options, {});
+    return isTheClawBayOpenAiCompatibleBaseUrl(options.baseURL);
+}
 function roamingAppDataDir() {
     if (process.env.APPDATA?.trim())
         return process.env.APPDATA;
@@ -433,11 +449,11 @@ async function cleanupOpenClawConfig() {
     await promises_1.default.writeFile(configPath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
     return true;
 }
-async function cleanupOpenCodeConfig() {
-    const configPath = node_path_1.default.join(node_os_1.default.homedir(), ".config", "opencode", "opencode.json");
-    const existingRaw = await readFileIfExists(configPath);
-    if (existingRaw === null || !existingRaw.trim())
-        return false;
+async function cleanupOpenCodeFamilyConfig(params) {
+    const existingRaw = await readFileIfExists(params.configPath);
+    if (existingRaw === null || !existingRaw.trim()) {
+        return removeFileIfExists(params.restoreStatePath);
+    }
     let doc;
     try {
         doc = objectRecordOr(JSON.parse(existingRaw), {});
@@ -445,56 +461,76 @@ async function cleanupOpenCodeConfig() {
     catch {
         return false;
     }
+    const snapshotRaw = await readFileIfExists(params.restoreStatePath);
     let changed = false;
     const providerRoot = objectRecordOr(doc.provider, {});
-    for (const id of [DEFAULT_PROVIDER_ID]) {
-        if (id in providerRoot) {
-            delete providerRoot[id];
-            changed = true;
-        }
-    }
-    doc.provider = providerRoot;
-    const model = doc.model;
-    if (typeof model === "string" && model.startsWith(`${DEFAULT_PROVIDER_ID}/`)) {
-        delete doc.model;
+    if (DEFAULT_PROVIDER_ID in providerRoot) {
+        delete providerRoot[DEFAULT_PROVIDER_ID];
         changed = true;
     }
-    if (!changed)
-        return false;
-    await promises_1.default.writeFile(configPath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
-    return true;
-}
-async function cleanupKiloConfig() {
-    const configPath = node_path_1.default.join(node_os_1.default.homedir(), ".config", "kilo", "opencode.json");
-    const existingRaw = await readFileIfExists(configPath);
-    if (existingRaw === null || !existingRaw.trim())
-        return false;
-    let doc;
-    try {
-        doc = objectRecordOr(JSON.parse(existingRaw), {});
-    }
-    catch {
-        return false;
-    }
-    let changed = false;
-    const providerRoot = objectRecordOr(doc.provider, {});
-    for (const id of [DEFAULT_PROVIDER_ID]) {
-        if (id in providerRoot) {
-            delete providerRoot[id];
+    if (snapshotRaw?.trim()) {
+        try {
+            const snapshot = JSON.parse(snapshotRaw);
+            if (snapshot.openAiProvider) {
+                providerRoot[OPENAI_PROVIDER_ID] = snapshot.openAiProvider;
+            }
+            else if (OPENAI_PROVIDER_ID in providerRoot) {
+                delete providerRoot[OPENAI_PROVIDER_ID];
+            }
+            doc.provider = providerRoot;
+            if (snapshot.model === null) {
+                if (isManagedOpenCodeModel(doc.model) || typeof doc.model === "string" && doc.model.startsWith(`${DEFAULT_PROVIDER_ID}/`)) {
+                    delete doc.model;
+                }
+            }
+            else {
+                doc.model = snapshot.model;
+            }
+            if (snapshot.schema === null) {
+                if (typeof doc.$schema === "string")
+                    delete doc.$schema;
+            }
+            else {
+                doc.$schema = snapshot.schema;
+            }
             changed = true;
+            await promises_1.default.writeFile(params.configPath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
+            await removeFileIfExists(params.restoreStatePath);
+            return changed;
+        }
+        catch {
+            // Fall through to best-effort cleanup below.
         }
     }
     doc.provider = providerRoot;
     const model = doc.model;
-    if (typeof model === "string" && model.startsWith(`${DEFAULT_PROVIDER_ID}/`)) {
+    if (typeof model === "string" && (model.startsWith(`${DEFAULT_PROVIDER_ID}/`) || isManagedOpenCodeModel(model))) {
         delete doc.model;
         changed = true;
     }
+    if (isManagedOpenCodeProvider(providerRoot[OPENAI_PROVIDER_ID])) {
+        delete providerRoot[OPENAI_PROVIDER_ID];
+        doc.provider = providerRoot;
+        changed = true;
+    }
     if (!changed)
         return false;
-    await promises_1.default.writeFile(configPath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
+    await promises_1.default.writeFile(params.configPath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
+    await removeFileIfExists(params.restoreStatePath);
     return true;
 }
+async function cleanupOpenCodeConfig() {
+    return cleanupOpenCodeFamilyConfig({
+        configPath: node_path_1.default.join(node_os_1.default.homedir(), ".config", "opencode", "opencode.json"),
+        restoreStatePath: OPENCODE_RESTORE_STATE_PATH,
+    });
+}
+async function cleanupKiloConfig() {
+    return cleanupOpenCodeFamilyConfig({
+        configPath: node_path_1.default.join(node_os_1.default.homedir(), ".config", "kilo", "opencode.json"),
+        restoreStatePath: KILO_RESTORE_STATE_PATH,
+    });
+}
 async function cleanupTraeBundle() {
     const bundlePath = traeBundlePath();
     if (!bundlePath)
@@ -678,10 +714,10 @@ class LogoutCommand extends base_command_1.BaseCommand {
                 this.log("- Codex login state: no cleanup needed.");
             }
             if (modelCacheCleanup.action === "removed") {
-                this.log("- Codex model cache: removed the Claw Bay GPT-5.4 seed.");
+                this.log("- Codex model cache: removed the Claw Bay GPT-5.4 / GPT-5.4 Mini seed.");
             }
             else if (modelCacheCleanup.action === "preserved") {
-                this.log("- Codex model cache: preserved an existing GPT-5.4 entry.");
+                this.log("- Codex model cache: preserved an existing GPT-5.4 / GPT-5.4 Mini entry.");
             }
             else if (modelCacheCleanup.warning) {
                 this.log(`- Codex model cache: ${modelCacheCleanup.warning}`);

package/dist/commands/setup.js

@@ -42,6 +42,8 @@ const CLINE_GLOBAL_STATE_PATH = node_path_1.default.join(node_os_1.default.homed
 const CLINE_SECRETS_PATH = node_path_1.default.join(node_os_1.default.homedir(), ".cline", "data", "secrets.json");
 const AIDER_CONFIG_PATH = node_path_1.default.join(node_os_1.default.homedir(), ".aider.conf.yml");
 const CLINE_RESTORE_STATE_PATH = node_path_1.default.join(paths_1.theclawbayStateDir, "cline.restore.json");
+const OPENCODE_RESTORE_STATE_PATH = node_path_1.default.join(paths_1.theclawbayStateDir, "opencode.restore.json");
+const KILO_RESTORE_STATE_PATH = node_path_1.default.join(paths_1.theclawbayStateDir, "kilo.restore.json");
 const ROO_SETTINGS_STATE_PATH = node_path_1.default.join(paths_1.theclawbayStateDir, "roo-settings.restore.json");
 const ROO_IMPORT_FILE = node_path_1.default.join(paths_1.theclawbayConfigDir, "roo-code-settings.json");
 const MIGRATION_STATE_FILE = node_path_1.default.join(paths_1.codexDir, "theclawbay.migration.json");
@@ -56,6 +58,9 @@ const HISTORY_PROVIDER_NEUTRALIZE_SOURCES = new Set(["openai", "theclawbay-wan",
 const HISTORY_PROVIDER_DB_MIGRATE_SOURCES = ["openai", "theclawbay-wan"];
 const SETUP_CLIENT_IDS = ["codex", "continue", "cline", "openclaw", "opencode", "kilo", "roo", "trae", "aider"];
 const THECLAWBAY_OPENAI_PROXY_SUFFIX = "/api/codex-auth/v1/proxy/v1";
+const OPENAI_PROVIDER_ID = "openai";
+const OPENCODE_CONFIG_SCHEMA_URL = "https://opencode.ai/config.json";
+const KILO_CONFIG_SCHEMA_URL = "https://kilo.ai/config.json";
 const CONTINUE_MODEL_NAME = "The Claw Bay";
 const ROO_PROFILE_NAME = "The Claw Bay";
 const ROO_PROFILE_ID = "theclawbay-openai-compatible";
@@ -460,25 +465,51 @@ async function promptForSetupClients(clients) {
         const wasRaw = stdin.isRaw;
         const applyIndex = options.length;
         const hyperlinksEnabled = supportsTerminalHyperlinks();
+        const ansi = {
+            reset: "\x1b[0m",
+            bold: "\x1b[1m",
+            dim: "\x1b[2m",
+            inverse: "\x1b[7m",
+            red: "\x1b[31m",
+            green: "\x1b[32m",
+            yellow: "\x1b[33m",
+            gray: "\x1b[90m",
+        };
+        const paint = (text, ...codes) => `${codes.join("")}${text}${ansi.reset}`;
         const clearScreen = () => {
             stdout.write("\x1b[2J\x1b[H");
         };
         const selectedCount = () => options.filter((option) => option.checked).length;
         const render = () => {
             clearScreen();
-            stdout.write("Choose local clients to configure\n");
-            stdout.write(`Use ↑/↓ to move, Enter to toggle the highlighted integration, or press 1-${options.length} to toggle directly.\n`);
-            stdout.write("Each tool name links to its official site when your terminal supports it.\n");
-            stdout.write("Move to Apply setup and press Enter when you're ready.\n\n");
+            stdout.write(`${paint("Choose local clients to configure", ansi.bold)}\n`);
+            stdout.write(`${paint(`Use ↑/↓ to move, Enter to toggle the highlighted integration, or press 1-${options.length} to toggle directly.`, ansi.dim, ansi.gray)}\n`);
+            stdout.write(`${paint("Each tool name links to its official site when your terminal supports it.", ansi.dim, ansi.gray)}\n`);
+            stdout.write(`${paint("Move to Apply setup and press Enter when you're ready.", ansi.dim, ansi.gray)}\n\n`);
             for (const [index, option] of options.entries()) {
-                const pointer = index === cursor ? ">" : " ";
-                const mark = option.detected ? (option.checked ? "[x]" : "[ ]") : "[-]";
-                const badge = option.detected ? (option.recommended ? "recommended" : "optional") : "not detected";
-                stdout.write(`${pointer} ${index + 1}. ${mark} ${formatSetupClientLabel(option, hyperlinksEnabled)}  ${badge}\n`);
+                const pointer = index === cursor ? paint(">", ansi.bold) : " ";
+                const mark = option.detected
+                    ? option.checked
+                        ? paint("[x]", ansi.green, ansi.bold)
+                        : paint("[ ]", ansi.gray)
+                    : paint("[-]", ansi.red, ansi.bold);
+                const badge = option.detected
+                    ? option.recommended
+                        ? paint("recommended", ansi.green)
+                        : paint("optional", ansi.yellow)
+                    : paint("not detected", ansi.red);
+                const label = option.detected
+                    ? formatSetupClientLabel(option, hyperlinksEnabled)
+                    : paint(formatSetupClientLabel(option, hyperlinksEnabled), ansi.dim, ansi.gray);
+                stdout.write(`${pointer} ${index + 1}. ${mark} ${label}  ${badge}\n`);
             }
             const applyPointer = cursor === applyIndex ? ">" : " ";
-            stdout.write(`${applyPointer} Apply setup with ${selectedCount()} selected integration${selectedCount() === 1 ? "" : "s"}\n`);
-            stdout.write(`\n${hint}\n`);
+            const applyLabel = `Apply setup (${selectedCount()} selected)`;
+            const applyStyled = cursor === applyIndex
+                ? paint(` ${applyLabel} `, ansi.inverse, ansi.bold, ansi.green)
+                : paint(applyLabel, ansi.bold, ansi.green);
+            stdout.write(`\n${applyPointer} ${applyStyled}\n`);
+            stdout.write(`\n${paint(hint, ansi.dim, ansi.gray)}\n`);
         };
         const finish = () => {
             if (settled)
@@ -992,7 +1023,7 @@ async function patchOpenClawConfigFile(params) {
         baseUrl: `${trimTrailingSlash(params.backendUrl)}/api/codex-auth/v1/proxy/v1`,
         apiKey: params.apiKey,
         api: "openai-responses",
-        models: params.models,
+        models: buildOpenClawModels(params.models),
     };
     const configPath = node_path_1.default.join(node_os_1.default.homedir(), ".openclaw", "openclaw.json");
     await promises_1.default.mkdir(node_path_1.default.dirname(configPath), { recursive: true });
@@ -1024,6 +1055,9 @@ async function patchOpenClawConfigFile(params) {
     const defaultsRoot = objectRecordOr(agentsRoot.defaults, {});
     const modelRoot = objectRecordOr(defaultsRoot.model, {});
     modelRoot.primary = resolveOpenClawPrimaryModel(params);
+    if (typeof defaultsRoot.thinkingDefault !== "string") {
+        defaultsRoot.thinkingDefault = "medium";
+    }
     defaultsRoot.model = modelRoot;
     agentsRoot.defaults = defaultsRoot;
     doc.agents = agentsRoot;
@@ -1040,21 +1074,57 @@ function objectRecordOr(value, fallback) {
     }
     return fallback;
 }
-function openCodeModelsObject(models) {
+function modelContextLimit(modelId) {
+    if (modelId === "gpt-5.4")
+        return 1050000;
+    return 272000;
+}
+function modelOutputLimit(modelId) {
+    if (modelId === "gpt-5.4")
+        return 128000;
+    return 65536;
+}
+function buildOpenCodeModelConfig(model) {
+    return {
+        name: model.name || model.id,
+        reasoning: true,
+        tool_call: true,
+        attachment: true,
+        modalities: {
+            input: ["text", "image"],
+            output: ["text"],
+        },
+        limit: {
+            context: modelContextLimit(model.id),
+            output: modelOutputLimit(model.id),
+        },
+    };
+}
+function buildOpenCodeModelsObject(models) {
     const result = {};
     for (const model of models) {
         if (!model.id)
             continue;
-        result[model.id] = { name: model.name || model.id };
+        result[model.id] = buildOpenCodeModelConfig(model);
     }
     return result;
 }
-async function writeOpenCodeConfig(params) {
-    const configPath = node_path_1.default.join(node_os_1.default.homedir(), ".config", "opencode", "opencode.json");
-    await promises_1.default.mkdir(node_path_1.default.dirname(configPath), { recursive: true });
+function isManagedOpenCodeProvider(provider) {
+    const options = objectRecordOr(provider.options, {});
+    return isTheClawBayOpenAiCompatibleBaseUrl(options.baseURL);
+}
+function isManagedOpenCodeModel(value, supportedModelIds) {
+    if (typeof value !== "string")
+        return false;
+    if (!value.startsWith(`${OPENAI_PROVIDER_ID}/`))
+        return false;
+    return supportedModelIds.has(value.slice(`${OPENAI_PROVIDER_ID}/`.length));
+}
+async function writeOpenCodeFamilyConfig(params) {
+    await promises_1.default.mkdir(node_path_1.default.dirname(params.configPath), { recursive: true });
     let existingRaw = "";
     try {
-        existingRaw = await promises_1.default.readFile(configPath, "utf8");
+        existingRaw = await promises_1.default.readFile(params.configPath, "utf8");
     }
     catch (error) {
         const err = error;
@@ -1067,60 +1137,81 @@ async function writeOpenCodeConfig(params) {
             doc = objectRecordOr(JSON.parse(existingRaw), {});
         }
         catch {
-            throw new Error(`invalid JSON in OpenCode config: ${configPath}`);
+            throw new Error(`invalid JSON in config: ${params.configPath}`);
         }
     }
     const providerRoot = objectRecordOr(doc.provider, {});
-    providerRoot[DEFAULT_PROVIDER_ID] = {
-        npm: "@ai-sdk/openai-compatible",
-        name: DEFAULT_PROVIDER_ID,
-        options: {
-            baseURL: `${trimTrailingSlash(params.backendUrl)}/api/codex-auth/v1/proxy/v1`,
-            apiKey: params.apiKey,
-        },
-        models: openCodeModelsObject(params.models),
-    };
+    const openAiProvider = objectRecordOr(providerRoot[OPENAI_PROVIDER_ID], {});
+    const supportedModelIds = new Set(params.models.map((entry) => entry.id).filter(Boolean));
+    const alreadyManaged = isManagedOpenCodeProvider(openAiProvider) && isManagedOpenCodeModel(doc.model, supportedModelIds);
+    if (!alreadyManaged) {
+        const snapshot = {
+            openAiProvider: Object.keys(openAiProvider).length > 0 ? openAiProvider : null,
+            model: typeof doc.model === "string" && !doc.model.startsWith(`${DEFAULT_PROVIDER_ID}/`)
+                ? doc.model
+                : null,
+            schema: typeof doc.$schema === "string" ? doc.$schema : null,
+        };
+        await writeJsonObjectFile(params.restoreStatePath, snapshot, 0o600);
+    }
+    const managedOpenAiProvider = objectRecordOr(providerRoot[OPENAI_PROVIDER_ID], {});
+    const optionsRoot = objectRecordOr(managedOpenAiProvider.options, {});
+    optionsRoot.baseURL = `${trimTrailingSlash(params.backendUrl)}/api/codex-auth/v1/proxy/v1`;
+    optionsRoot.apiKey = params.apiKey;
+    managedOpenAiProvider.options = optionsRoot;
+    managedOpenAiProvider.models = buildOpenCodeModelsObject(params.models);
+    managedOpenAiProvider.whitelist = params.models.map((entry) => entry.id).filter(Boolean);
+    if ("blacklist" in managedOpenAiProvider) {
+        delete managedOpenAiProvider.blacklist;
+    }
+    providerRoot[OPENAI_PROVIDER_ID] = managedOpenAiProvider;
+    if (DEFAULT_PROVIDER_ID in providerRoot) {
+        delete providerRoot[DEFAULT_PROVIDER_ID];
+    }
+    doc.$schema = params.schemaUrl;
     doc.provider = providerRoot;
-    doc.model = `${DEFAULT_PROVIDER_ID}/${params.model}`;
-    await promises_1.default.writeFile(configPath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
-    return configPath;
+    doc.model = `${OPENAI_PROVIDER_ID}/${params.model}`;
+    await promises_1.default.writeFile(params.configPath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
+    return params.configPath;
+}
+function buildOpenClawModels(models) {
+    const supportedModelMap = new Map((0, supported_models_1.getSupportedModels)().map((model) => [model.id, model]));
+    return models
+        .filter((model) => Boolean(model.id))
+        .map((model) => {
+        const pricing = supportedModelMap.get(model.id);
+        return {
+            id: model.id,
+            name: model.name || model.id,
+            api: "openai-responses",
+            reasoning: true,
+            input: ["text", "image"],
+            cost: {
+                input: pricing?.inputPer1M ?? 0,
+                output: pricing?.outputPer1M ?? 0,
+                cacheRead: pricing?.cachedInputPer1M ?? 0,
+                cacheWrite: pricing?.inputPer1M ?? 0,
+            },
+            contextWindow: modelContextLimit(model.id),
+            maxTokens: modelOutputLimit(model.id),
+        };
+    });
+}
+async function writeOpenCodeConfig(params) {
+    return writeOpenCodeFamilyConfig({
+        configPath: node_path_1.default.join(node_os_1.default.homedir(), ".config", "opencode", "opencode.json"),
+        restoreStatePath: OPENCODE_RESTORE_STATE_PATH,
+        schemaUrl: OPENCODE_CONFIG_SCHEMA_URL,
+        ...params,
+    });
 }
 async function writeKiloConfig(params) {
-    const configPath = node_path_1.default.join(node_os_1.default.homedir(), ".config", "kilo", "opencode.json");
-    await promises_1.default.mkdir(node_path_1.default.dirname(configPath), { recursive: true });
-    let existingRaw = "";
-    try {
-        existingRaw = await promises_1.default.readFile(configPath, "utf8");
-    }
-    catch (error) {
-        const err = error;
-        if (err.code !== "ENOENT")
-            throw error;
-    }
-    let doc = {};
-    if (existingRaw.trim()) {
-        try {
-            doc = objectRecordOr(JSON.parse(existingRaw), {});
-        }
-        catch {
-            throw new Error(`invalid JSON in Kilo config: ${configPath}`);
-        }
-    }
-    const providerRoot = objectRecordOr(doc.provider, {});
-    providerRoot[DEFAULT_PROVIDER_ID] = {
-        npm: "@ai-sdk/openai-compatible",
-        name: DEFAULT_PROVIDER_ID,
-        options: {
-            baseURL: `${trimTrailingSlash(params.backendUrl)}/api/codex-auth/v1/proxy/v1`,
-            apiKey: params.apiKey,
-        },
-        models: openCodeModelsObject(params.models),
-    };
-    doc.$schema = "https://kilo.ai/config.json";
-    doc.provider = providerRoot;
-    doc.model = `${DEFAULT_PROVIDER_ID}/${params.model || DEFAULT_KILO_MODEL}`;
-    await promises_1.default.writeFile(configPath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
-    return configPath;
+    return writeOpenCodeFamilyConfig({
+        configPath: node_path_1.default.join(node_os_1.default.homedir(), ".config", "kilo", "opencode.json"),
+        restoreStatePath: KILO_RESTORE_STATE_PATH,
+        schemaUrl: KILO_CONFIG_SCHEMA_URL,
+        ...params,
+    });
 }
 function traePatchSnippet(params) {
     const patchedModels = params.models.length
@@ -1467,19 +1558,19 @@ class SetupCommand extends base_command_1.BaseCommand {
                     this.log(`- Conversation cache: could not update local Codex history DB.${detail}`);
                 }
                 if (modelCacheMigration?.action === "seeded") {
-                    this.log("- Codex model cache: added GPT-5.4 to the local picker cache.");
+                    this.log("- Codex model cache: added GPT-5.4 / GPT-5.4 Mini to the local picker cache.");
                 }
                 else if (modelCacheMigration?.action === "created") {
-                    this.log("- Codex model cache: created a local picker cache with GPT-5.4.");
+                    this.log("- Codex model cache: created a local picker cache with GPT-5.4 / GPT-5.4 Mini.");
                 }
                 else if (modelCacheMigration?.action === "refreshed") {
-                    this.log("- Codex model cache: refreshed the local picker cache for GPT-5.4.");
+                    this.log("- Codex model cache: refreshed the local picker cache for GPT-5.4 / GPT-5.4 Mini.");
                 }
                 else if (modelCacheMigration?.action === "already_seeded") {
-                    this.log("- Codex model cache: GPT-5.4 was already seeded locally.");
+                    this.log("- Codex model cache: GPT-5.4 / GPT-5.4 Mini were already seeded locally.");
                 }
                 else if (modelCacheMigration?.action === "already_present") {
-                    this.log("- Codex model cache: GPT-5.4 already existed locally.");
+                    this.log("- Codex model cache: GPT-5.4 / GPT-5.4 Mini already existed locally.");
                 }
                 else if (modelCacheMigration?.warning) {
                     this.log(`- Codex model cache: ${modelCacheMigration.warning}`);

package/dist/lib/codex-model-cache-migration.js

@@ -14,10 +14,13 @@ const supported_models_1 = require("./supported-models");
 const MODELS_CACHE_FILE = "models_cache.json";
 const MODELS_CACHE_STATE_FILE = "theclawbay.models-cache.json";
 const STATE_DB_FILE_PATTERN = /^state_\d+\.sqlite$/;
-const TARGET_MODEL_ID = "gpt-5.4";
+const TARGET_MODEL_IDS = ["gpt-5.4", "gpt-5.4-mini"];
+const TARGET_MODEL_ID_SET = new Set(TARGET_MODEL_IDS);
 const SEED_MARKER_KEY = "_theclawbay_seeded";
-const SEED_MARKER_VALUE = "gpt-5.4";
-const TEMPLATE_MODEL_IDS = (0, supported_models_1.getSupportedModelIds)().filter((id) => id !== TARGET_MODEL_ID);
+// Older releases stored the model id as the marker value; accept those so cleanup still works.
+const SEED_MARKER_VALUE = "theclawbay";
+const LEGACY_SEED_MARKER_VALUES = new Set(["gpt-5.4", SEED_MARKER_VALUE, true]);
+const TEMPLATE_MODEL_IDS = (0, supported_models_1.getSupportedModelIds)().filter((id) => !TARGET_MODEL_ID_SET.has(id));
 const DEFAULT_REASONING_LEVELS = [
     { effort: "low", description: "Fast responses with lighter reasoning" },
     { effort: "medium", description: "Balances speed and reasoning depth for everyday tasks" },
@@ -88,29 +91,66 @@ async function removeFileIfExists(filePath) {
             throw error;
     }
 }
+function normalizePatchFingerprintMap(state) {
+    if (!state)
+        return {};
+    if (state.version === 1) {
+        if (!TARGET_MODEL_ID_SET.has(state.modelId))
+            return {};
+        return state.fingerprint ? { [state.modelId]: state.fingerprint } : {};
+    }
+    const output = {};
+    for (const entry of state.models) {
+        if (!TARGET_MODEL_ID_SET.has(entry.modelId))
+            continue;
+        if (entry.fingerprint)
+            output[entry.modelId] = entry.fingerprint;
+    }
+    return output;
+}
 async function readPatchState(statePath) {
     const parsed = await readJsonIfExists(statePath);
     const obj = objectRecordOr(parsed);
     if (!obj)
-        return null;
-    if (obj.version !== 1)
-        return null;
-    if (obj.modelId !== TARGET_MODEL_ID)
-        return null;
-    if (typeof obj.fingerprint !== "string" || !obj.fingerprint)
-        return null;
-    return {
-        version: 1,
-        modelId: TARGET_MODEL_ID,
-        fingerprint: obj.fingerprint,
-    };
+        return {};
+    const version = obj.version;
+    if (version === 1) {
+        const modelId = typeof obj.modelId === "string" ? obj.modelId : "";
+        const fingerprint = typeof obj.fingerprint === "string" ? obj.fingerprint : "";
+        if (!modelId || !fingerprint)
+            return {};
+        return normalizePatchFingerprintMap({ version: 1, modelId, fingerprint });
+    }
+    if (version === 2) {
+        const modelsRaw = obj.models;
+        if (!Array.isArray(modelsRaw))
+            return {};
+        const models = [];
+        for (const entry of modelsRaw) {
+            const record = objectRecordOr(entry);
+            if (!record)
+                continue;
+            const modelId = typeof record.modelId === "string" ? record.modelId : "";
+            const fingerprint = typeof record.fingerprint === "string" ? record.fingerprint : "";
+            if (!modelId || !fingerprint)
+                continue;
+            models.push({ modelId, fingerprint });
+        }
+        return normalizePatchFingerprintMap({ version: 2, models });
+    }
+    return {};
 }
-async function writePatchState(statePath, fingerprint) {
+async function writePatchState(statePath, fingerprints) {
     await promises_1.default.mkdir(node_path_1.default.dirname(statePath), { recursive: true });
+    const models = TARGET_MODEL_IDS.flatMap((modelId) => {
+        const fingerprint = fingerprints[modelId];
+        if (!fingerprint)
+            return [];
+        return [{ modelId, fingerprint }];
+    });
     const contents = JSON.stringify({
-        version: 1,
-        modelId: TARGET_MODEL_ID,
-        fingerprint,
+        version: 2,
+        models,
     }, null, 2);
     await promises_1.default.writeFile(statePath, `${contents}\n`, "utf8");
 }
@@ -118,18 +158,23 @@ function findModel(models, slug) {
     return models.find((entry) => entry.slug === slug) ?? null;
 }
 function hasSeedMarker(model) {
-    return model[SEED_MARKER_KEY] === SEED_MARKER_VALUE;
+    return LEGACY_SEED_MARKER_VALUES.has(model[SEED_MARKER_KEY]);
 }
 function applySeedMarker(model) {
     const next = cloneJson(model);
     next[SEED_MARKER_KEY] = SEED_MARKER_VALUE;
     return next;
 }
-function normalizeSeedModel(template) {
+function seedDescription(modelId) {
+    if (modelId === "gpt-5.4-mini")
+        return "Smaller GPT-5.4 variant for quick iterations.";
+    return "Latest frontier agentic coding model.";
+}
+function normalizeSeedModel(template, modelId) {
     const seed = applySeedMarker(template ?? {});
-    seed.slug = TARGET_MODEL_ID;
-    seed.display_name = TARGET_MODEL_ID;
-    seed.description = "Latest frontier agentic coding model.";
+    seed.slug = modelId;
+    seed.display_name = modelId;
+    seed.description = seedDescription(modelId);
     if (typeof seed.default_reasoning_level !== "string") {
         seed.default_reasoning_level = "medium";
     }
@@ -182,13 +227,13 @@ function normalizeSeedModel(template) {
     }
     return seed;
 }
-function buildSeedModel(models) {
+function buildSeedModel(models, modelId) {
     for (const candidate of TEMPLATE_MODEL_IDS) {
         const template = findModel(models, candidate);
         if (template)
-            return normalizeSeedModel(template);
+            return normalizeSeedModel(template, modelId);
     }
-    return normalizeSeedModel(null);
+    return normalizeSeedModel(null, modelId);
 }
 function setCacheFreshnessMetadata(doc, clientVersion) {
     let changed = false;
@@ -342,70 +387,115 @@ async function ensureCodexModelCacheHasGpt54(params) {
                 await removeFileIfExists(statePath);
                 return {
                     action: "skipped",
-                    warning: "Codex models cache was not found, and Codex version could not be inferred for a safe GPT-5.4 seed.",
+                    warning: "Codex models cache was not found, and Codex version could not be inferred for a safe GPT-5.4 / GPT-5.4 Mini seed.",
                 };
             }
-            const seed = buildSeedModel([]);
+            const docModels = [];
+            const nextState = {};
+            for (const modelId of TARGET_MODEL_IDS) {
+                const seed = buildSeedModel(docModels, modelId);
+                docModels.push(seed);
+                nextState[modelId] = fingerprintModel(seed);
+            }
             const doc = {
                 fetched_at: new Date().toISOString(),
                 client_version: clientVersion,
-                models: [seed],
+                models: docModels,
             };
             await promises_1.default.mkdir(params.codexHome, { recursive: true });
             await promises_1.default.writeFile(cachePath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
-            await writePatchState(statePath, fingerprintModel(seed));
+            await writePatchState(statePath, nextState);
             return { action: "created" };
         }
         const doc = normalizeCacheDocument(parsed);
         if (!doc) {
             return {
                 action: "skipped",
-                warning: "Codex models cache exists but is not valid JSON in the expected format; skipped GPT-5.4 seed.",
+                warning: "Codex models cache exists but is not valid JSON in the expected format; skipped GPT-5.4 / GPT-5.4 Mini seed.",
             };
         }
         const clientVersion = (await inferCodexClientVersion(params.codexHome)) ??
             (typeof doc.client_version === "string" && doc.client_version ? doc.client_version : null);
-        const existingModel = findModel(doc.models, TARGET_MODEL_ID);
-        if (existingModel) {
-            const currentFingerprint = fingerprintModel(existingModel);
-            if (existingState && existingState.fingerprint === currentFingerprint && !hasSeedMarker(existingModel)) {
-                const seededModel = applySeedMarker(existingModel);
-                doc.models = doc.models.map((entry) => (entry.slug === TARGET_MODEL_ID ? seededModel : entry));
-                setCacheFreshnessMetadata(doc, clientVersion);
-                await promises_1.default.writeFile(cachePath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
-                await writePatchState(statePath, fingerprintModel(seededModel));
-                return { action: "seeded" };
-            }
-            if (hasSeedMarker(existingModel)) {
-                const docChanged = setCacheFreshnessMetadata(doc, clientVersion);
-                if (!existingState || existingState.fingerprint !== currentFingerprint) {
-                    await writePatchState(statePath, currentFingerprint);
-                    await promises_1.default.writeFile(cachePath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
-                    return { action: "refreshed" };
+        let changed = false;
+        let seeded = false;
+        let stateChanged = false;
+        const nextState = { ...existingState };
+        for (const modelId of TARGET_MODEL_IDS) {
+            const existingModel = findModel(doc.models, modelId);
+            const trackedFingerprint = existingState[modelId];
+            if (existingModel) {
+                const currentFingerprint = fingerprintModel(existingModel);
+                if (hasSeedMarker(existingModel)) {
+                    if (!trackedFingerprint || trackedFingerprint !== currentFingerprint) {
+                        nextState[modelId] = currentFingerprint;
+                        stateChanged = true;
+                    }
+                    continue;
                 }
-                if (docChanged) {
-                    await promises_1.default.writeFile(cachePath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
-                    return { action: "refreshed" };
+                if (trackedFingerprint && trackedFingerprint === currentFingerprint) {
+                    const seededModel = applySeedMarker(existingModel);
+                    doc.models = doc.models.map((entry) => (entry.slug === modelId ? seededModel : entry));
+                    nextState[modelId] = fingerprintModel(seededModel);
+                    seeded = true;
+                    changed = true;
+                    stateChanged = true;
+                    continue;
                 }
-                return { action: "already_seeded" };
+                if (trackedFingerprint && trackedFingerprint !== currentFingerprint) {
+                    delete nextState[modelId];
+                    stateChanged = true;
+                }
+                continue;
             }
-            if (existingState && existingState.fingerprint !== currentFingerprint) {
-                await removeFileIfExists(statePath);
+            const seed = buildSeedModel(doc.models, modelId);
+            doc.models = [seed, ...doc.models];
+            nextState[modelId] = fingerprintModel(seed);
+            seeded = true;
+            changed = true;
+            stateChanged = true;
+        }
+        // Keep The Claw Bay seeds grouped at the top for easy discovery in the picker.
+        const bySlug = new Map();
+        const rest = [];
+        for (const entry of doc.models) {
+            const slug = typeof entry.slug === "string" ? entry.slug : "";
+            if (slug && TARGET_MODEL_ID_SET.has(slug) && !bySlug.has(slug)) {
+                bySlug.set(slug, entry);
+                continue;
             }
-            if (setCacheFreshnessMetadata(doc, clientVersion)) {
-                await promises_1.default.writeFile(cachePath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
-                return { action: "refreshed" };
+            rest.push(entry);
+        }
+        const orderedTargets = [];
+        for (const id of TARGET_MODEL_IDS) {
+            const entry = bySlug.get(id);
+            if (entry)
+                orderedTargets.push(entry);
+        }
+        doc.models = [...orderedTargets, ...rest];
+        if (setCacheFreshnessMetadata(doc, clientVersion)) {
+            changed = true;
+        }
+        if (changed) {
+            await promises_1.default.writeFile(cachePath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
+        }
+        const hasAnyTracked = TARGET_MODEL_IDS.some((id) => Boolean(nextState[id]));
+        if (!hasAnyTracked) {
+            if (Object.keys(existingState).length > 0) {
+                await removeFileIfExists(statePath);
             }
-            return {
-                action: existingState && existingState.fingerprint === currentFingerprint ? "already_seeded" : "already_present",
-            };
         }
-        const seed = buildSeedModel(doc.models);
-        doc.models = [seed, ...doc.models];
-        setCacheFreshnessMetadata(doc, clientVersion);
-        await promises_1.default.writeFile(cachePath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
-        await writePatchState(statePath, fingerprintModel(seed));
-        return { action: "seeded" };
+        else if (stateChanged || seeded) {
+            await writePatchState(statePath, nextState);
+        }
+        if (seeded)
+            return { action: "seeded" };
+        if (changed || stateChanged)
+            return { action: "refreshed" };
+        const allSeeded = TARGET_MODEL_IDS.every((id) => {
+            const model = findModel(doc.models, id);
+            return Boolean(model && hasSeedMarker(model));
+        });
+        return { action: allSeeded ? "already_seeded" : "already_present" };
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -420,7 +510,7 @@ async function cleanupSeededCodexModelCache(params) {
     const statePath = node_path_1.default.join(params.codexHome, MODELS_CACHE_STATE_FILE);
     try {
         const state = await readPatchState(statePath);
-        if (!state) {
+        if (Object.keys(state).length === 0) {
             return { action: "none" };
         }
         const parsed = await readJsonIfExists(cachePath);
@@ -432,27 +522,26 @@ async function cleanupSeededCodexModelCache(params) {
         if (!doc) {
             return {
                 action: "none",
-                warning: "Codex models cache exists but is not valid JSON in the expected format; left GPT-5.4 cache patch state untouched.",
+                warning: "Codex models cache exists but is not valid JSON in the expected format; left GPT-5.4 / GPT-5.4 Mini cache patch state untouched.",
             };
         }
-        const existingModel = findModel(doc.models, TARGET_MODEL_ID);
-        if (!existingModel) {
-            await removeFileIfExists(statePath);
-            return { action: "none" };
-        }
-        const currentFingerprint = fingerprintModel(existingModel);
-        if (!hasSeedMarker(existingModel)) {
-            await removeFileIfExists(statePath);
-            return { action: "preserved" };
-        }
-        if (currentFingerprint !== state.fingerprint) {
-            await writePatchState(statePath, currentFingerprint);
-            doc.models = doc.models.filter((entry) => entry.slug !== TARGET_MODEL_ID);
-            await promises_1.default.writeFile(cachePath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
+        let removed = 0;
+        let preserved = 0;
+        doc.models = doc.models.filter((entry) => {
+            const slug = typeof entry.slug === "string" ? entry.slug : "";
+            if (!slug || !TARGET_MODEL_ID_SET.has(slug))
+                return true;
+            if (!hasSeedMarker(entry)) {
+                preserved += 1;
+                return true;
+            }
+            removed += 1;
+            return false;
+        });
+        if (removed === 0) {
             await removeFileIfExists(statePath);
-            return { action: "removed" };
+            return { action: preserved > 0 ? "preserved" : "none" };
         }
-        doc.models = doc.models.filter((entry) => entry.slug !== TARGET_MODEL_ID);
         await promises_1.default.writeFile(cachePath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
         await removeFileIfExists(statePath);
         return { action: "removed" };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "theclawbay",
-  "version": "0.3.31",
+  "version": "0.3.33",
   "description": "CLI for connecting Codex, Continue, Cline, OpenClaw, OpenCode, Kilo, Roo Code, Aider, and experimental Trae to The Claw Bay.",
   "license": "MIT",
   "bin": {

package/theclawbay-supported-models.json

@@ -8,6 +8,15 @@
     "cachedInputPer1M": 0.25,
     "outputPer1M": 15.0
   },
+  {
+    "id": "gpt-5.4-mini",
+    "label": "GPT-5.4 Mini",
+    "note": "Smaller GPT-5.4 variant for quick iterations.",
+    "tone": "sea",
+    "inputPer1M": 1.25,
+    "cachedInputPer1M": 0.125,
+    "outputPer1M": 10.0
+  },
   {
     "id": "gpt-5.3-codex",
     "label": "GPT-5.3 Codex",