theclawbay 0.3.78 → 0.3.79

package/dist/commands/setup.d.ts

@@ -7,6 +7,7 @@ export default class SetupCommand extends BaseCommand {
         "device-name": import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         clients: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         model: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        models: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         "claude-models": import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         "list-models": import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         backup: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;

package/dist/commands/setup.js

@@ -673,7 +673,66 @@ function powerShellQuote(value) {
     return `'${value.replace(/'/g, "''")}'`;
 }
 function modelDisplayName(modelId) {
-    return MODEL_DISPLAY_NAMES[modelId] ?? modelId;
+    return MODEL_DISPLAY_NAMES[modelId] ?? prettyModelId(modelId);
+}
+function supportedModelProviderMap() {
+    return new Map((0, supported_models_1.getSupportedModels)().map((model) => [model.id, model.provider]));
+}
+function groupForModelId(modelId) {
+    const knownProvider = supportedModelProviderMap().get(modelId);
+    if (knownProvider === "openai") {
+        return { id: "openai", label: "OpenAI / Codex", icon: "◎", order: 0 };
+    }
+    if (knownProvider === "google") {
+        return { id: "google", label: "Google Gemini", icon: "◈", order: 1 };
+    }
+    if (knownProvider === "deepseek") {
+        return { id: "deepseek", label: "DeepSeek", icon: "◉", order: 2 };
+    }
+    if (modelId.startsWith("claude-")) {
+        return { id: "anthropic", label: "Anthropic Claude", icon: "✳", order: 3 };
+    }
+    if (modelId.startsWith("gemini-")) {
+        return { id: "google", label: "Google Gemini", icon: "◈", order: 1 };
+    }
+    if (modelId.startsWith("deepseek-")) {
+        return { id: "deepseek", label: "DeepSeek", icon: "◉", order: 2 };
+    }
+    if (modelId.startsWith("gpt-") || modelId.startsWith("codex-")) {
+        return { id: "openai", label: "OpenAI / Codex", icon: "◎", order: 0 };
+    }
+    return { id: "other", label: "Other models", icon: "•", order: 9 };
+}
+function groupModelOptions(models) {
+    return models.map((model) => ({
+        ...model,
+        provider: groupForModelId(model.id),
+    }));
+}
+function groupModelSections(models) {
+    const sections = new Map();
+    for (const model of groupModelOptions(models)) {
+        const existing = sections.get(model.provider.id);
+        if (existing) {
+            existing.models.push(model);
+            continue;
+        }
+        sections.set(model.provider.id, { provider: model.provider, models: [model] });
+    }
+    return [...sections.values()]
+        .sort((left, right) => left.provider.order - right.provider.order || left.provider.label.localeCompare(right.provider.label))
+        .map((section) => ({
+        provider: section.provider,
+        models: [...section.models].sort((left, right) => left.name.localeCompare(right.name)),
+    }));
+}
+function prettyModelId(modelId) {
+    return modelId
+        .replace(/^claude-/, "Claude ")
+        .replace(/^gemini-/, "Gemini ")
+        .replace(/^deepseek-/, "DeepSeek ")
+        .replace(/-/g, " ")
+        .replace(/\b\w/g, (match) => match.toUpperCase());
 }
 function publicApiOriginForBackendUrl(backendUrl) {
     const trimmed = trimTrailingSlash(backendUrl);
@@ -691,6 +750,39 @@ function publicApiOriginForBackendUrl(backendUrl) {
         return trimmed;
     }
 }
+function isPrivateHostname(hostname) {
+    const normalized = hostname.trim().toLowerCase();
+    if (!normalized)
+        return false;
+    if (normalized === "localhost" ||
+        normalized === "127.0.0.1" ||
+        normalized === "::1" ||
+        normalized === "[::1]" ||
+        normalized === "0.0.0.0") {
+        return true;
+    }
+    if (normalized.startsWith("10.") || normalized.startsWith("192.168.") || normalized.startsWith("127.")) {
+        return true;
+    }
+    const match = normalized.match(/^172\.(\d{1,3})\./);
+    if (!match)
+        return false;
+    const secondOctet = Number.parseInt(match[1] ?? "", 10);
+    return Number.isInteger(secondOctet) && secondOctet >= 16 && secondOctet <= 31;
+}
+function shouldPreferPublicSetupBackend(backendUrl) {
+    const trimmed = backendUrl?.trim();
+    if (!trimmed)
+        return false;
+    try {
+        const parsed = new URL(trimmed);
+        const hostname = parsed.hostname.toLowerCase();
+        return hostname !== THECLAWBAY_CANONICAL_API_HOST && !THECLAWBAY_WEBSITE_HOSTS.has(hostname) && isPrivateHostname(hostname);
+    }
+    catch {
+        return false;
+    }
+}
 function isTheClawBayChatgptBaseUrl(value) {
     const trimmed = trimTrailingSlash(value.trim());
     if (!trimmed)
@@ -1229,60 +1321,317 @@ async function resolveDeviceLabel(params) {
         rl.close();
     }
 }
+async function promptForGroupedModelSelection(params) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY || params.models.length <= 1) {
+        return uniqueStrings(params.defaultSelectedIds);
+    }
+    const sections = groupModelSections(params.models);
+    const knownIds = new Set(params.models.map((model) => model.id));
+    const selected = new Set(uniqueStrings(params.defaultSelectedIds).filter((modelId) => knownIds.has(modelId)));
+    const rows = [];
+    for (const [sectionIndex, section] of sections.entries()) {
+        rows.push({ kind: "group", sectionIndex });
+        for (const [modelIndex] of section.models.entries()) {
+            rows.push({ kind: "model", sectionIndex, modelIndex });
+        }
+    }
+    rows.push({ kind: "apply" });
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+    const wasRaw = stdin.isRaw;
+    const ansi = {
+        reset: "\x1b[0m",
+        bold: "\x1b[1m",
+        dim: "\x1b[2m",
+        inverse: "\x1b[7m",
+        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 rowForModel = (sectionIndex, modelIndex) => rows.findIndex((row) => row.kind === "model" && row.sectionIndex === sectionIndex && row.modelIndex === modelIndex);
+    let settled = false;
+    let hint = "Use ↑/↓ to move. Press Enter or Space to toggle a model or a provider header.";
+    let cursor = Math.max(0, rows.findIndex((row) => {
+        if (row.kind !== "model")
+            return false;
+        const model = sections[row.sectionIndex]?.models[row.modelIndex];
+        return model?.id === params.defaultSelectedIds[0];
+    }));
+    const groupState = (sectionIndex) => {
+        const models = sections[sectionIndex]?.models ?? [];
+        const selectedCount = models.filter((model) => selected.has(model.id)).length;
+        if (selectedCount === 0)
+            return "[ ]";
+        if (selectedCount === models.length)
+            return "[x]";
+        return "[-]";
+    };
+    const setGroupSelection = (sectionIndex, nextValue) => {
+        for (const model of sections[sectionIndex]?.models ?? []) {
+            if (nextValue)
+                selected.add(model.id);
+            else
+                selected.delete(model.id);
+        }
+    };
+    const toggleCurrent = () => {
+        const current = rows[cursor];
+        if (!current)
+            return;
+        if (current.kind === "apply") {
+            finish();
+            return;
+        }
+        if (current.kind === "group") {
+            const state = groupState(current.sectionIndex);
+            const nextValue = state !== "[x]";
+            setGroupSelection(current.sectionIndex, nextValue);
+            hint = `${sections[current.sectionIndex]?.provider.label ?? "Group"} ${nextValue ? "selected" : "cleared"}.`;
+            render();
+            return;
+        }
+        const model = sections[current.sectionIndex]?.models[current.modelIndex];
+        if (!model)
+            return;
+        if (selected.has(model.id))
+            selected.delete(model.id);
+        else
+            selected.add(model.id);
+        hint = `${model.name} ${selected.has(model.id) ? "selected" : "cleared"}.`;
+        render();
+    };
+    const finish = () => {
+        if (settled)
+            return;
+        settled = true;
+        stdin.off("keypress", onKeypress);
+        if (stdin.isTTY)
+            stdin.setRawMode(Boolean(wasRaw));
+        stdout.write("\x1b[?25h");
+        clearScreen();
+        resolvePromise([...selected].filter((modelId) => knownIds.has(modelId)));
+    };
+    const render = () => {
+        clearScreen();
+        stdout.write(`${paint(params.title, ansi.bold)}\n`);
+        stdout.write(`${paint("Each provider header toggles that provider on or off. Press A to toggle all models.", ansi.dim, ansi.gray)}\n`);
+        stdout.write(`${paint("Move to Apply and press Enter when you're ready.", ansi.dim, ansi.gray)}\n\n`);
+        for (const [sectionIndex, section] of sections.entries()) {
+            const currentRow = rows[cursor];
+            const groupCursor = currentRow?.kind === "group" && currentRow.sectionIndex === sectionIndex;
+            const groupPointer = groupCursor ? paint("→", ansi.bold, ansi.yellow) : " ";
+            const groupMark = groupState(sectionIndex);
+            stdout.write(`${groupPointer} ${paint(groupMark, groupMark === "[x]" ? ansi.green : ansi.gray)} ${section.provider.icon} ${paint(`${section.provider.label} — Select all`, ansi.bold)}\n`);
+            for (const [modelIndex, model] of section.models.entries()) {
+                const activeRow = rows[cursor];
+                const isActive = activeRow?.kind === "model" &&
+                    activeRow.sectionIndex === sectionIndex &&
+                    activeRow.modelIndex === modelIndex;
+                const pointer = isActive ? paint("→", ansi.bold, ansi.yellow) : " ";
+                const mark = selected.has(model.id) ? paint("[x]", ansi.green) : paint("[ ]", ansi.gray);
+                stdout.write(`${pointer}   ${mark} ${model.name} ${paint(`(${model.id})`, ansi.dim, ansi.gray)}\n`);
+            }
+            stdout.write("\n");
+        }
+        const applyActive = rows[cursor]?.kind === "apply";
+        const applyStyled = applyActive
+            ? paint(` ${params.applyLabel} (${selected.size} selected) `, ansi.inverse, ansi.bold, ansi.green)
+            : paint(`${params.applyLabel} (${selected.size} selected)`, ansi.bold, ansi.green);
+        stdout.write(`${applyActive ? "→" : " "} ${applyStyled}\n`);
+        stdout.write(`\n${paint(hint, ansi.dim, ansi.gray)}\n`);
+    };
+    const onKeypress = (_str, key) => {
+        if (key.ctrl && key.name === "c") {
+            stdout.write("\x1b[?25h");
+            process.exit(130);
+        }
+        if (key.name === "up" || key.name === "k") {
+            cursor = (cursor - 1 + rows.length) % rows.length;
+            render();
+            return;
+        }
+        if (key.name === "down" || key.name === "j") {
+            cursor = (cursor + 1) % rows.length;
+            render();
+            return;
+        }
+        if (key.name === "space" || key.name === "return" || key.name === "enter") {
+            toggleCurrent();
+            return;
+        }
+        if (key.name === "a") {
+            const nextValue = sections.some((section) => section.models.some((model) => !selected.has(model.id)));
+            for (const [sectionIndex] of sections.entries())
+                setGroupSelection(sectionIndex, nextValue);
+            hint = `${nextValue ? "Selected" : "Cleared"} all available models.`;
+            render();
+            return;
+        }
+        if (key.name === "c") {
+            finish();
+        }
+    };
+    let resolvePromise = () => { };
+    const result = new Promise((resolve) => {
+        resolvePromise = resolve;
+    });
+    (0, node_readline_1.emitKeypressEvents)(stdin);
+    if (stdin.isTTY)
+        stdin.setRawMode(true);
+    stdout.write("\x1b[?25l");
+    stdin.on("keypress", onKeypress);
+    render();
+    return result;
+}
 async function promptForPrimaryModel(models, defaultModel) {
     if (!process.stdin.isTTY || !process.stdout.isTTY || models.length <= 1) {
         return defaultModel;
     }
-    const rl = (0, promises_2.createInterface)({
-        input: process.stdin,
-        output: process.stdout,
+    const sections = groupModelSections(models);
+    const flattened = sections.flatMap((section) => section.models);
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+    const wasRaw = stdin.isRaw;
+    const ansi = {
+        reset: "\x1b[0m",
+        bold: "\x1b[1m",
+        dim: "\x1b[2m",
+        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");
+    };
+    let cursor = Math.max(0, flattened.findIndex((model) => model.id === defaultModel));
+    let settled = false;
+    let resolvePromise = () => { };
+    const finish = (modelId) => {
+        if (settled)
+            return;
+        settled = true;
+        stdin.off("keypress", onKeypress);
+        if (stdin.isTTY)
+            stdin.setRawMode(Boolean(wasRaw));
+        stdout.write("\x1b[?25h");
+        clearScreen();
+        resolvePromise(modelId);
+    };
+    const render = () => {
+        clearScreen();
+        stdout.write(`${paint("Choose the default model for local setup", ansi.bold)}\n`);
+        stdout.write(`${paint("Use ↑/↓ to move and Enter to select the default model.", ansi.dim, ansi.gray)}\n\n`);
+        let index = 0;
+        for (const section of sections) {
+            stdout.write(`${paint(`${section.provider.icon} ${section.provider.label}`, ansi.bold)}\n`);
+            for (const model of section.models) {
+                const active = index === cursor;
+                const pointer = active ? paint("→", ansi.bold, ansi.yellow) : " ";
+                const defaultSuffix = model.id === defaultModel ? paint(" default", ansi.dim, ansi.gray) : "";
+                stdout.write(`${pointer} ${model.name} ${paint(`(${model.id})`, ansi.dim, ansi.gray)}${defaultSuffix}\n`);
+                index += 1;
+            }
+            stdout.write("\n");
+        }
+    };
+    const onKeypress = (_str, key) => {
+        if (key.ctrl && key.name === "c") {
+            stdout.write("\x1b[?25h");
+            process.exit(130);
+        }
+        if (key.name === "up" || key.name === "k") {
+            cursor = (cursor - 1 + flattened.length) % flattened.length;
+            render();
+            return;
+        }
+        if (key.name === "down" || key.name === "j") {
+            cursor = (cursor + 1) % flattened.length;
+            render();
+            return;
+        }
+        if (key.name === "return" || key.name === "enter" || key.name === "space") {
+            finish(flattened[cursor]?.id ?? defaultModel);
+        }
+    };
+    const result = new Promise((resolve) => {
+        resolvePromise = resolve;
     });
-    try {
-        const lines = models.map((model, index) => {
-            const defaultSuffix = model.id === defaultModel ? " (default)" : "";
-            return `  ${index + 1}. ${model.name} — ${model.id}${defaultSuffix}`;
-        });
-        const answer = await rl.question(`\nChoose the default OpenAI-compatible model for local setup:\n${lines.join("\n")}\nSelect a number or press Enter for ${defaultModel}: `);
-        const trimmed = answer.trim();
-        if (!trimmed)
-            return defaultModel;
-        const asNumber = Number.parseInt(trimmed, 10);
-        if (Number.isInteger(asNumber) && asNumber >= 1 && asNumber <= models.length) {
-            return models[asNumber - 1]?.id ?? defaultModel;
-        }
-        const directMatch = models.find((model) => model.id === trimmed);
-        if (directMatch)
-            return directMatch.id;
-        throw new Error(`Unknown model selection "${trimmed}".`);
-    }
-    finally {
-        rl.close();
-    }
+    (0, node_readline_1.emitKeypressEvents)(stdin);
+    if (stdin.isTTY)
+        stdin.setRawMode(true);
+    stdout.write("\x1b[?25l");
+    stdin.on("keypress", onKeypress);
+    render();
+    return result;
 }
 async function resolveConfiguredModelSelection(params) {
     const requestedModel = params.requestedModel?.trim();
+    const requestedModels = params.requestedModels
+        ?.split(",")
+        .map((entry) => entry.trim())
+        .filter(Boolean);
     const availableIds = new Set(params.resolved.models.map((entry) => entry.id));
-    if (requestedModel) {
-        if (availableIds.size === 0 || availableIds.has(requestedModel)) {
-            return {
-                model: requestedModel,
-                note: availableIds.size === 0 && params.resolved.failure
-                    ? `Could not verify requested model ${requestedModel} against the live backend (${params.resolved.failure}).`
-                    : undefined,
-            };
-        }
+    if (requestedModel && availableIds.size > 0 && !availableIds.has(requestedModel)) {
         throw new Error(`Requested model "${requestedModel}" is not advertised by the live backend.`);
     }
-    if (params.skipPrompt || !process.stdin.isTTY || !process.stdout.isTTY) {
-        return { model: params.resolved.model };
+    if (requestedModels?.length) {
+        for (const modelId of requestedModels) {
+            if (availableIds.size > 0 && !availableIds.has(modelId)) {
+                throw new Error(`Requested model "${modelId}" is not advertised by the live backend.`);
+            }
+        }
+    }
+    let selectedModels;
+    if (requestedModels?.length) {
+        selectedModels = params.resolved.models.filter((entry) => requestedModels.includes(entry.id));
     }
-    const selected = await promptForPrimaryModel(params.resolved.models, params.resolved.model);
-    if (selected === params.resolved.model) {
-        return { model: selected };
+    else if (params.skipPrompt || !process.stdin.isTTY || !process.stdout.isTTY) {
+        selectedModels = params.resolved.models;
+    }
+    else if (params.resolved.models.length > 1) {
+        const selectedIds = new Set(await promptForGroupedModelSelection({
+            title: "Choose the OpenAI-compatible models to save into local tools",
+            models: params.resolved.models,
+            defaultSelectedIds: params.resolved.models.map((entry) => entry.id),
+            applyLabel: "Apply model selection",
+        }));
+        selectedModels = params.resolved.models.filter((entry) => selectedIds.has(entry.id));
+    }
+    else {
+        selectedModels = params.resolved.models;
+    }
+    const fallbackModels = selectedModels.length > 0 ? selectedModels : params.resolved.models;
+    const selectedModelId = requestedModel && fallbackModels.some((entry) => entry.id === requestedModel)
+        ? requestedModel
+        : params.skipPrompt || !process.stdin.isTTY || !process.stdout.isTTY
+            ? fallbackModels.some((entry) => entry.id === params.resolved.model)
+                ? params.resolved.model
+                : fallbackModels[0]?.id ?? params.resolved.model
+            : await promptForPrimaryModel(fallbackModels, fallbackModels.some((entry) => entry.id === params.resolved.model)
+                ? params.resolved.model
+                : (fallbackModels[0]?.id ?? params.resolved.model));
+    const noteParts = [];
+    if (requestedModels?.length) {
+        noteParts.push(`Configured ${requestedModels.length} OpenAI-compatible models.`);
+    }
+    else if (selectedModels.length > 0 && selectedModels.length < params.resolved.models.length) {
+        noteParts.push(`Configured ${selectedModels.length} OpenAI-compatible models for local tools.`);
+    }
+    if (selectedModelId !== params.resolved.model) {
+        noteParts.push(`Using ${selectedModelId} as the default configured model for local tools.`);
+    }
+    if (availableIds.size === 0 && requestedModel && params.resolved.failure) {
+        noteParts.push(`Could not verify requested model ${requestedModel} against the live backend (${params.resolved.failure}).`);
     }
     return {
-        model: selected,
-        note: `Using ${selected} as the default configured model for local tools.`,
+        model: selectedModelId,
+        models: fallbackModels,
+        note: noteParts.join(" ").trim() || undefined,
     };
 }
 function summarizeModelFetchFailure(detail) {
@@ -1597,6 +1946,12 @@ async function detectHermesClient() {
     }
     return false;
 }
+function isOpenAiCompatibleSetupModelId(modelId) {
+    const trimmed = modelId.trim();
+    if (!trimmed)
+        return false;
+    return !trimmed.startsWith("claude-");
+}
 function formatDotEnvValue(value) {
     return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
 }
@@ -1678,7 +2033,8 @@ async function writeHermesConfig(params) {
 }
 async function resolveModels(backendUrl, apiKey) {
     const { ids, failure } = await fetchBackendModelIds(backendUrl, apiKey);
-    const available = new Set(ids ?? []);
+    const filteredIds = (ids ?? []).filter(isOpenAiCompatibleSetupModelId);
+    const available = new Set(filteredIds);
     let selected = DEFAULT_CODEX_MODEL;
     let note;
     const authRejected = isCredentialRejectedFailure(failure);
@@ -1688,29 +2044,29 @@ async function resolveModels(backendUrl, apiKey) {
             break;
         }
     }
-    if (ids?.length && !available.has(selected)) {
-        selected = ids[0] ?? DEFAULT_CODEX_MODEL;
+    if (filteredIds.length && !available.has(selected)) {
+        selected = filteredIds[0] ?? DEFAULT_CODEX_MODEL;
         note = "No preferred Codex model advertised by backend; selected first available model.";
     }
-    else if (!ids) {
+    else if (!filteredIds.length) {
         note = failure
             ? `Unable to query backend model list (${failure}); defaulted to ${DEFAULT_CODEX_MODEL}.`
             : `Unable to query backend model list; defaulted to ${DEFAULT_CODEX_MODEL}.`;
     }
     const unique = [];
     const pushUnique = (modelId) => {
-        if (!modelId || unique.includes(modelId))
+        if (!modelId || !isOpenAiCompatibleSetupModelId(modelId) || unique.includes(modelId))
             return;
         unique.push(modelId);
     };
     pushUnique(selected);
     for (const modelId of DEFAULT_MODELS)
         pushUnique(modelId);
-    for (const modelId of ids ?? [])
+    for (const modelId of filteredIds)
         pushUnique(modelId);
     return {
         model: selected,
-        models: unique.map((modelId) => ({ id: modelId, name: modelDisplayName(modelId) })),
+        models: unique.map((modelId) => ({ id: modelId, name: modelDisplayName(modelId) || prettyModelId(modelId) })),
         note,
         failure,
         authRejected,
@@ -1735,15 +2091,31 @@ async function resolveClaudeAccess(backendUrl, apiKey) {
         authRejected,
     };
 }
-function resolveConfiguredClaudeModels(params) {
+async function resolveConfiguredClaudeModels(params) {
     const requestedModels = params.requestedModels
         ?.split(",")
         .map((entry) => entry.trim())
         .filter(Boolean);
     if (!requestedModels?.length || !params.access.enabled) {
+        const selectedModels = !requestedModels?.length &&
+            params.access.enabled &&
+            !params.skipPrompt &&
+            process.stdin.isTTY &&
+            process.stdout.isTTY &&
+            params.access.models.length > 1
+            ? await promptForGroupedModelSelection({
+                title: "Choose the Claude models to save into Claude-compatible tools",
+                models: params.access.models.map((modelId) => ({
+                    id: modelId,
+                    name: prettyModelId(modelId),
+                })),
+                defaultSelectedIds: params.access.models,
+                applyLabel: "Apply Claude selection",
+            })
+            : params.access.models;
         return {
             ...params.access,
-            selectedModels: params.access.models,
+            selectedModels,
         };
     }
     const available = new Set(params.access.models);
@@ -3073,13 +3445,25 @@ class SetupCommand extends base_command_1.BaseCommand {
             let deviceLabel = managedAuthType === "device-session"
                 ? managed?.deviceLabel ?? null
                 : null;
+            const inferredBackend = explicitApiKey || managedAuthType === "api-key"
+                ? (0, api_key_1.tryInferBackendUrlFromApiKey)(explicitApiKey || managedCredential)
+                : null;
+            const managedBackendUrl = managed?.backendUrl ?? null;
             const backendRaw = flags.backend ??
-                (explicitApiKey || managedAuthType === "api-key"
-                    ? (0, api_key_1.tryInferBackendUrlFromApiKey)(explicitApiKey || managedCredential)
-                    : null) ??
-                managed?.backendUrl ??
+                inferredBackend ??
+                (shouldPreferPublicSetupBackend(managedBackendUrl) ? DEFAULT_BACKEND_URL : managedBackendUrl) ??
                 DEFAULT_BACKEND_URL;
             const backendUrl = normalizeUrl(backendRaw, "--backend");
+            const reusingLocalManagedCredential = !explicitApiKey &&
+                !flags.backend &&
+                shouldPreferPublicSetupBackend(managedBackendUrl) &&
+                authCredential.length > 0;
+            if (reusingLocalManagedCredential) {
+                authType = "device-session";
+                authCredential = "";
+                deviceSessionId = null;
+                deviceLabel = null;
+            }
             const [codexDetected, claudeDetected, continueDetected, clineDetected, gsdDetected, openCodeDetected, kiloDetected, rooDetected, traeDetected, aiderDetected, zoDetected, hermesDetected] = await Promise.all([
                 detectCodexClient(),
                 detectClaudeClient(),
@@ -3289,14 +3673,17 @@ class SetupCommand extends base_command_1.BaseCommand {
                     if (resolved.authRejected) {
                         throw new Error(describeCredentialRejection(authType, resolved.failure));
                     }
+                    progress.stop();
                     const configuredModel = await resolveConfiguredModelSelection({
                         resolved,
                         requestedModel: flags.model,
+                        requestedModels: flags.models,
                         skipPrompt: flags.yes,
                     });
                     resolved = {
                         ...resolved,
                         model: configuredModel.model,
+                        models: configuredModel.models,
                         note: [resolved.note, configuredModel.note].filter(Boolean).join(" ").trim() || undefined,
                     };
                 }
@@ -3305,23 +3692,28 @@ class SetupCommand extends base_command_1.BaseCommand {
                 if (!resolved?.authRejected && claudeAccess.authRejected) {
                     throw new Error(describeCredentialRejection(authType, claudeAccess.failure));
                 }
-                claudeAccess = resolveConfiguredClaudeModels({
+                progress.stop();
+                claudeAccess = await resolveConfiguredClaudeModels({
                     access: claudeAccess,
                     requestedModels: flags["claude-models"],
+                    skipPrompt: flags.yes,
                 });
                 if (flags["list-models"]) {
                     if (resolved) {
                         this.log("\nOpenAI-compatible models:");
-                        for (const model of resolved.models) {
-                            const marker = model.id === resolved.model ? " (default)" : "";
-                            this.log(`- ${model.id}${marker}`);
+                        for (const section of groupModelSections(resolved.models)) {
+                            this.log(`${section.provider.icon} ${section.provider.label}`);
+                            for (const model of section.models) {
+                                const marker = model.id === resolved.model ? " (default)" : "";
+                                this.log(`  - ${model.id}${marker}`);
+                            }
                         }
                     }
                     if (claudeAccess.models.length > 0) {
                         this.log("\nClaude models:");
                         for (const modelId of claudeAccess.models) {
                             const marker = claudeAccess.selectedModels?.includes(modelId) ? " (selected)" : "";
-                            this.log(`- ${modelId}${marker}`);
+                            this.log(`  - ${modelId}${marker}`);
                         }
                     }
                 }
@@ -3849,6 +4241,10 @@ SetupCommand.flags = {
         required: false,
         description: "Default OpenAI-compatible model to configure for local tools",
     }),
+    models: core_1.Flags.string({
+        required: false,
+        description: "Comma-separated OpenAI-compatible model ids to save into local tools",
+    }),
     "claude-models": core_1.Flags.string({
         required: false,
         description: "Comma-separated Claude model ids to configure for Claude-compatible tools",

package/dist/lib/supported-models.d.ts

@@ -1,9 +1,11 @@
 export type SupportedModelTone = "coral" | "sea" | "ink";
+export type SupportedModelProvider = "openai" | "google" | "deepseek";
 export type SupportedModelConfig = {
     id: string;
     label: string;
     note: string;
     tone: SupportedModelTone;
+    provider: SupportedModelProvider;
     inputPer1M: number;
     cachedInputPer1M: number;
     outputPer1M: number;

package/dist/lib/supported-models.js

@@ -25,6 +25,7 @@ function parseSupportedModels(raw) {
         const label = typeof record.label === "string" ? record.label.trim() : "";
         const note = typeof record.note === "string" ? record.note.trim() : "";
         const tone = record.tone;
+        const provider = record.provider;
         const inputPer1M = typeof record.inputPer1M === "number" ? record.inputPer1M : NaN;
         const cachedInputPer1M = typeof record.cachedInputPer1M === "number" ? record.cachedInputPer1M : NaN;
         const outputPer1M = typeof record.outputPer1M === "number" ? record.outputPer1M : NaN;
@@ -37,6 +38,9 @@ function parseSupportedModels(raw) {
         if (tone !== "coral" && tone !== "sea" && tone !== "ink") {
             throw new Error(`unsupported tone for model ${id}`);
         }
+        if (provider !== "openai" && provider !== "google" && provider !== "deepseek") {
+            throw new Error(`unsupported provider for model ${id}`);
+        }
         if (!Number.isFinite(inputPer1M) || !Number.isFinite(cachedInputPer1M) || !Number.isFinite(outputPer1M)) {
             throw new Error(`unsupported pricing fields for model ${id}`);
         }
@@ -45,6 +49,7 @@ function parseSupportedModels(raw) {
             label,
             note,
             tone,
+            provider,
             inputPer1M,
             cachedInputPer1M,
             outputPer1M,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "theclawbay",
-  "version": "0.3.78",
+  "version": "0.3.79",
   "description": "CLI for connecting Codex, Hermes Agent, Gemini-compatible apps, Continue, Cline, GSD, OpenClaw, OpenCode, Kilo, Roo Code, Aider, experimental Trae, and experimental Zo to The Claw Bay.",
   "license": "MIT",
   "repository": {

package/theclawbay-supported-models.json

@@ -4,6 +4,7 @@
     "label": "GPT-5.5",
     "note": "Frontier model for complex coding, research, and real-world work.",
     "tone": "coral",
+    "provider": "openai",
     "inputPer1M": 5.0,
     "cachedInputPer1M": 0.5,
     "outputPer1M": 30.0
@@ -13,6 +14,7 @@
     "label": "GPT-5.4",
     "note": "Frontier coding model with the widest headroom.",
     "tone": "coral",
+    "provider": "openai",
     "inputPer1M": 2.5,
     "cachedInputPer1M": 0.25,
     "outputPer1M": 15.0
@@ -22,6 +24,7 @@
     "label": "GPT-5.4 Mini",
     "note": "Smaller GPT-5.4 variant for quick iterations.",
     "tone": "sea",
+    "provider": "openai",
     "inputPer1M": 1.25,
     "cachedInputPer1M": 0.125,
     "outputPer1M": 10.0
@@ -31,42 +34,17 @@
     "label": "GPT Image 2",
     "note": "OpenAI-compatible image generation endpoint backed by codex-lb.",
     "tone": "coral",
+    "provider": "openai",
     "inputPer1M": 5.0,
     "cachedInputPer1M": 2.0,
     "outputPer1M": 30.0
   },
-  {
-    "id": "gpt-image-1.5",
-    "label": "GPT Image 1.5",
-    "note": "Native image generation model for direct image outputs.",
-    "tone": "coral",
-    "inputPer1M": 8.0,
-    "cachedInputPer1M": 2.0,
-    "outputPer1M": 32.0
-  },
-  {
-    "id": "gpt-5.1-codex-max",
-    "label": "GPT-5.1 Codex Max",
-    "note": "Higher-throughput option for longer coding sessions.",
-    "tone": "coral",
-    "inputPer1M": 1.25,
-    "cachedInputPer1M": 0.125,
-    "outputPer1M": 10.0
-  },
-  {
-    "id": "gpt-5.1-codex-mini",
-    "label": "GPT-5.1 Codex Mini",
-    "note": "Lower-cost Codex path for quick iterations.",
-    "tone": "sea",
-    "inputPer1M": 0.25,
-    "cachedInputPer1M": 0.025,
-    "outputPer1M": 2.0
-  },
   {
     "id": "gemini-2.5-pro",
     "label": "Gemini 2.5 Pro",
     "note": "Google's flagship coding and reasoning model through CliRelay.",
     "tone": "coral",
+    "provider": "google",
     "inputPer1M": 1.25,
     "cachedInputPer1M": 0.125,
     "outputPer1M": 10.0
@@ -76,6 +54,7 @@
     "label": "Gemini 2.5 Flash",
     "note": "Balanced Gemini path for fast multimodal and agentic work.",
     "tone": "ink",
+    "provider": "google",
     "inputPer1M": 0.3,
     "cachedInputPer1M": 0.03,
     "outputPer1M": 2.5
@@ -85,6 +64,7 @@
     "label": "Gemini 2.5 Flash Lite",
     "note": "Lowest-cost Gemini path for lightweight coding and tooling loops.",
     "tone": "sea",
+    "provider": "google",
     "inputPer1M": 0.1,
     "cachedInputPer1M": 0.01,
     "outputPer1M": 0.4
@@ -94,6 +74,7 @@
     "label": "Gemini 3 Pro Preview",
     "note": "Preview Gemini model for heavier multimodal and coding sessions.",
     "tone": "coral",
+    "provider": "google",
     "inputPer1M": 2.0,
     "cachedInputPer1M": 0.2,
     "outputPer1M": 12.0
@@ -103,6 +84,7 @@
     "label": "Gemini 3.1 Pro Preview",
     "note": "Newest Gemini Pro preview with stronger agentic and coding behavior.",
     "tone": "coral",
+    "provider": "google",
     "inputPer1M": 2.0,
     "cachedInputPer1M": 0.2,
     "outputPer1M": 12.0
@@ -112,6 +94,7 @@
     "label": "Gemini 3 Flash Preview",
     "note": "Faster Gemini preview tuned for responsive high-volume tasks.",
     "tone": "ink",
+    "provider": "google",
     "inputPer1M": 0.5,
     "cachedInputPer1M": 0.05,
     "outputPer1M": 3.0
@@ -121,6 +104,7 @@
     "label": "DeepSeek V4 Flash",
     "note": "Lowest-cost DeepSeek path with 1M context through CliRelay.",
     "tone": "sea",
+    "provider": "deepseek",
     "inputPer1M": 0.14,
     "cachedInputPer1M": 0.0028,
     "outputPer1M": 0.28,
@@ -131,6 +115,7 @@
     "label": "DeepSeek V4 Pro",
     "note": "Flagship DeepSeek reasoning path with 1M context through CliRelay.",
     "tone": "coral",
+    "provider": "deepseek",
     "inputPer1M": 0.435,
     "cachedInputPer1M": 0.003625,
     "outputPer1M": 0.87,