@intent-systems/nexus 2026.1.5-3

package/dist/commands/models/list.js

@@ -0,0 +1,347 @@
+import { discoverAuthStorage, discoverModels, } from "@mariozechner/pi-coding-agent";
+import chalk from "chalk";
+import { resolveNexusAgentDir } from "../../agents/agent-paths.js";
+import { ensureAuthProfileStore, listProfilesForProvider, } from "../../agents/auth-profiles.js";
+import { getCustomProviderApiKey, resolveEnvApiKey, } from "../../agents/model-auth.js";
+import { buildModelAliasIndex, parseModelRef, resolveConfiguredModelRef, resolveModelRefFromString, } from "../../agents/model-selection.js";
+import { ensureNexusModelsJson } from "../../agents/models-config.js";
+import { CONFIG_PATH_NEXUS, loadConfig } from "../../config/config.js";
+import { info } from "../../globals.js";
+import { DEFAULT_MODEL, DEFAULT_PROVIDER, ensureFlagCompatibility, formatTokenK, modelKey, } from "./shared.js";
+const MODEL_PAD = 42;
+const INPUT_PAD = 10;
+const CTX_PAD = 8;
+const LOCAL_PAD = 5;
+const AUTH_PAD = 5;
+const isRich = (opts) => Boolean(process.stdout.isTTY && chalk.level > 0 && !opts?.json && !opts?.plain);
+const pad = (value, size) => value.padEnd(size);
+const truncate = (value, max) => {
+    if (value.length <= max)
+        return value;
+    if (max <= 3)
+        return value.slice(0, max);
+    return `${value.slice(0, max - 3)}...`;
+};
+const isLocalBaseUrl = (baseUrl) => {
+    try {
+        const url = new URL(baseUrl);
+        const host = url.hostname.toLowerCase();
+        return (host === "localhost" ||
+            host === "127.0.0.1" ||
+            host === "0.0.0.0" ||
+            host === "::1" ||
+            host.endsWith(".local"));
+    }
+    catch {
+        return false;
+    }
+};
+const hasAuthForProvider = (provider, cfg, authStore) => {
+    if (listProfilesForProvider(authStore, provider).length > 0)
+        return true;
+    if (resolveEnvApiKey(provider))
+        return true;
+    if (getCustomProviderApiKey(cfg, provider))
+        return true;
+    return false;
+};
+const resolveConfiguredEntries = (cfg) => {
+    const resolvedDefault = resolveConfiguredModelRef({
+        cfg,
+        defaultProvider: DEFAULT_PROVIDER,
+        defaultModel: DEFAULT_MODEL,
+    });
+    const aliasIndex = buildModelAliasIndex({
+        cfg,
+        defaultProvider: DEFAULT_PROVIDER,
+    });
+    const order = [];
+    const tagsByKey = new Map();
+    const aliasesByKey = new Map();
+    for (const [key, aliases] of aliasIndex.byKey.entries()) {
+        aliasesByKey.set(key, aliases);
+    }
+    const addEntry = (ref, tag) => {
+        const key = modelKey(ref.provider, ref.model);
+        if (!tagsByKey.has(key)) {
+            tagsByKey.set(key, new Set());
+            order.push(key);
+        }
+        tagsByKey.get(key)?.add(tag);
+    };
+    addEntry(resolvedDefault, "default");
+    const modelConfig = cfg.agent?.model;
+    const imageModelConfig = cfg.agent?.imageModel;
+    const modelFallbacks = typeof modelConfig === "object" ? (modelConfig?.fallbacks ?? []) : [];
+    const imageFallbacks = typeof imageModelConfig === "object"
+        ? (imageModelConfig?.fallbacks ?? [])
+        : [];
+    const imagePrimary = imageModelConfig?.primary?.trim() ?? "";
+    modelFallbacks.forEach((raw, idx) => {
+        const resolved = resolveModelRefFromString({
+            raw: String(raw ?? ""),
+            defaultProvider: DEFAULT_PROVIDER,
+            aliasIndex,
+        });
+        if (!resolved)
+            return;
+        addEntry(resolved.ref, `fallback#${idx + 1}`);
+    });
+    if (imagePrimary) {
+        const resolved = resolveModelRefFromString({
+            raw: imagePrimary,
+            defaultProvider: DEFAULT_PROVIDER,
+            aliasIndex,
+        });
+        if (resolved)
+            addEntry(resolved.ref, "image");
+    }
+    imageFallbacks.forEach((raw, idx) => {
+        const resolved = resolveModelRefFromString({
+            raw: String(raw ?? ""),
+            defaultProvider: DEFAULT_PROVIDER,
+            aliasIndex,
+        });
+        if (!resolved)
+            return;
+        addEntry(resolved.ref, `img-fallback#${idx + 1}`);
+    });
+    for (const key of Object.keys(cfg.agent?.models ?? {})) {
+        const parsed = parseModelRef(String(key ?? ""), DEFAULT_PROVIDER);
+        if (!parsed)
+            continue;
+        addEntry(parsed, "configured");
+    }
+    const entries = order.map((key) => {
+        const slash = key.indexOf("/");
+        const provider = slash === -1 ? key : key.slice(0, slash);
+        const model = slash === -1 ? "" : key.slice(slash + 1);
+        return {
+            key,
+            ref: { provider, model },
+            tags: tagsByKey.get(key) ?? new Set(),
+            aliases: aliasesByKey.get(key) ?? [],
+        };
+    });
+    return { entries };
+};
+async function loadModelRegistry(cfg) {
+    await ensureNexusModelsJson(cfg);
+    const agentDir = resolveNexusAgentDir();
+    const authStorage = discoverAuthStorage(agentDir);
+    const registry = discoverModels(authStorage, agentDir);
+    const models = registry.getAll();
+    const availableModels = registry.getAvailable();
+    const availableKeys = new Set(availableModels.map((model) => modelKey(model.provider, model.id)));
+    return { registry, models, availableKeys };
+}
+function toModelRow(params) {
+    const { model, key, tags, aliases = [], availableKeys, cfg, authStore, } = params;
+    if (!model) {
+        return {
+            key,
+            name: key,
+            input: "-",
+            contextWindow: null,
+            local: null,
+            available: null,
+            tags: [...tags, "missing"],
+            missing: true,
+        };
+    }
+    const input = model.input.join("+") || "text";
+    const local = isLocalBaseUrl(model.baseUrl);
+    const available = availableKeys?.has(modelKey(model.provider, model.id)) ||
+        (cfg && authStore
+            ? hasAuthForProvider(model.provider, cfg, authStore)
+            : false);
+    const aliasTags = aliases.length > 0 ? [`alias:${aliases.join(",")}`] : [];
+    const mergedTags = new Set(tags);
+    if (aliasTags.length > 0) {
+        for (const tag of mergedTags) {
+            if (tag === "alias" || tag.startsWith("alias:"))
+                mergedTags.delete(tag);
+        }
+        for (const tag of aliasTags)
+            mergedTags.add(tag);
+    }
+    return {
+        key,
+        name: model.name || model.id,
+        input,
+        contextWindow: model.contextWindow ?? null,
+        local,
+        available,
+        tags: Array.from(mergedTags),
+        missing: false,
+    };
+}
+function printModelTable(rows, runtime, opts = {}) {
+    if (opts.json) {
+        runtime.log(JSON.stringify({
+            count: rows.length,
+            models: rows,
+        }, null, 2));
+        return;
+    }
+    if (opts.plain) {
+        for (const row of rows)
+            runtime.log(row.key);
+        return;
+    }
+    const rich = isRich(opts);
+    const header = [
+        pad("Model", MODEL_PAD),
+        pad("Input", INPUT_PAD),
+        pad("Ctx", CTX_PAD),
+        pad("Local", LOCAL_PAD),
+        pad("Auth", AUTH_PAD),
+        "Tags",
+    ].join(" ");
+    runtime.log(rich ? chalk.bold(header) : header);
+    for (const row of rows) {
+        const keyLabel = pad(truncate(row.key, MODEL_PAD), MODEL_PAD);
+        const inputLabel = pad(row.input || "-", INPUT_PAD);
+        const ctxLabel = pad(formatTokenK(row.contextWindow), CTX_PAD);
+        const localLabel = pad(row.local === null ? "-" : row.local ? "yes" : "no", LOCAL_PAD);
+        const authLabel = pad(row.available === null ? "-" : row.available ? "yes" : "no", AUTH_PAD);
+        const tagsLabel = row.tags.length > 0 ? row.tags.join(",") : "";
+        const line = [
+            rich ? chalk.cyan(keyLabel) : keyLabel,
+            inputLabel,
+            ctxLabel,
+            localLabel,
+            authLabel,
+            rich ? chalk.gray(tagsLabel) : tagsLabel,
+        ].join(" ");
+        runtime.log(line);
+    }
+}
+export async function modelsListCommand(opts, runtime) {
+    ensureFlagCompatibility(opts);
+    const cfg = loadConfig();
+    const authStore = ensureAuthProfileStore();
+    const providerFilter = opts.provider?.trim().toLowerCase();
+    let models = [];
+    let availableKeys;
+    try {
+        const loaded = await loadModelRegistry(cfg);
+        models = loaded.models;
+        availableKeys = loaded.availableKeys;
+    }
+    catch (err) {
+        runtime.error(`Model registry unavailable: ${String(err)}`);
+    }
+    const modelByKey = new Map(models.map((model) => [modelKey(model.provider, model.id), model]));
+    const { entries } = resolveConfiguredEntries(cfg);
+    const configuredByKey = new Map(entries.map((entry) => [entry.key, entry]));
+    const rows = [];
+    if (opts.all) {
+        const sorted = [...models].sort((a, b) => {
+            const p = a.provider.localeCompare(b.provider);
+            if (p !== 0)
+                return p;
+            return a.id.localeCompare(b.id);
+        });
+        for (const model of sorted) {
+            if (providerFilter && model.provider.toLowerCase() !== providerFilter) {
+                continue;
+            }
+            if (opts.local && !isLocalBaseUrl(model.baseUrl))
+                continue;
+            const key = modelKey(model.provider, model.id);
+            const configured = configuredByKey.get(key);
+            rows.push(toModelRow({
+                model,
+                key,
+                tags: configured ? Array.from(configured.tags) : [],
+                aliases: configured?.aliases ?? [],
+                availableKeys,
+                cfg,
+                authStore,
+            }));
+        }
+    }
+    else {
+        for (const entry of entries) {
+            if (providerFilter &&
+                entry.ref.provider.toLowerCase() !== providerFilter) {
+                continue;
+            }
+            const model = modelByKey.get(entry.key);
+            if (opts.local && model && !isLocalBaseUrl(model.baseUrl))
+                continue;
+            if (opts.local && !model)
+                continue;
+            rows.push(toModelRow({
+                model,
+                key: entry.key,
+                tags: Array.from(entry.tags),
+                aliases: entry.aliases,
+                availableKeys,
+                cfg,
+                authStore,
+            }));
+        }
+    }
+    if (rows.length === 0) {
+        runtime.log("No models found.");
+        return;
+    }
+    printModelTable(rows, runtime, opts);
+}
+export async function modelsStatusCommand(opts, runtime) {
+    ensureFlagCompatibility(opts);
+    const cfg = loadConfig();
+    const resolved = resolveConfiguredModelRef({
+        cfg,
+        defaultProvider: DEFAULT_PROVIDER,
+        defaultModel: DEFAULT_MODEL,
+    });
+    const modelConfig = cfg.agent?.model;
+    const imageConfig = cfg.agent?.imageModel;
+    const rawModel = typeof modelConfig === "string"
+        ? modelConfig.trim()
+        : (modelConfig?.primary?.trim() ?? "");
+    const defaultLabel = rawModel || `${resolved.provider}/${resolved.model}`;
+    const fallbacks = typeof modelConfig === "object" ? (modelConfig?.fallbacks ?? []) : [];
+    const imageModel = typeof imageConfig === "string"
+        ? imageConfig.trim()
+        : (imageConfig?.primary?.trim() ?? "");
+    const imageFallbacks = typeof imageConfig === "object" ? (imageConfig?.fallbacks ?? []) : [];
+    const aliases = Object.entries(cfg.agent?.models ?? {}).reduce((acc, [key, entry]) => {
+        const alias = entry?.alias?.trim();
+        if (alias)
+            acc[alias] = key;
+        return acc;
+    }, {});
+    const allowed = Object.keys(cfg.agent?.models ?? {});
+    if (opts.json) {
+        runtime.log(JSON.stringify({
+            configPath: CONFIG_PATH_NEXUS,
+            defaultModel: defaultLabel,
+            resolvedDefault: `${resolved.provider}/${resolved.model}`,
+            fallbacks,
+            imageModel: imageModel || null,
+            imageFallbacks,
+            aliases,
+            allowed,
+        }, null, 2));
+        return;
+    }
+    if (opts.plain) {
+        runtime.log(defaultLabel);
+        return;
+    }
+    runtime.log(info(`Config: ${CONFIG_PATH_NEXUS}`));
+    runtime.log(`Default: ${defaultLabel}`);
+    runtime.log(`Fallbacks (${fallbacks.length || 0}): ${fallbacks.join(", ") || "-"}`);
+    runtime.log(`Image model: ${imageModel || "-"}`);
+    runtime.log(`Image fallbacks (${imageFallbacks.length || 0}): ${imageFallbacks.length ? imageFallbacks.join(", ") : "-"}`);
+    runtime.log(`Aliases (${Object.keys(aliases).length || 0}): ${Object.keys(aliases).length
+        ? Object.entries(aliases)
+            .map(([alias, target]) => `${alias} -> ${target}`)
+            .join(", ")
+        : "-"}`);
+    runtime.log(`Configured models (${allowed.length || 0}): ${allowed.length ? allowed.join(", ") : "all"}`);
+}

package/dist/commands/models/scan.js

@@ -0,0 +1,271 @@
+import { cancel, isCancel, multiselect } from "@clack/prompts";
+import { resolveApiKeyForProvider } from "../../agents/model-auth.js";
+import { scanOpenRouterModels } from "../../agents/model-scan.js";
+import { CONFIG_PATH_NEXUS, loadConfig } from "../../config/config.js";
+import { formatMs, formatTokenK, updateConfig } from "./shared.js";
+const MODEL_PAD = 42;
+const CTX_PAD = 8;
+const pad = (value, size) => value.padEnd(size);
+const truncate = (value, max) => {
+    if (value.length <= max)
+        return value;
+    if (max <= 3)
+        return value.slice(0, max);
+    return `${value.slice(0, max - 3)}...`;
+};
+function sortScanResults(results) {
+    return results.slice().sort((a, b) => {
+        const aImage = a.image.ok ? 1 : 0;
+        const bImage = b.image.ok ? 1 : 0;
+        if (aImage !== bImage)
+            return bImage - aImage;
+        const aToolLatency = a.tool.latencyMs ?? Number.POSITIVE_INFINITY;
+        const bToolLatency = b.tool.latencyMs ?? Number.POSITIVE_INFINITY;
+        if (aToolLatency !== bToolLatency)
+            return aToolLatency - bToolLatency;
+        const aCtx = a.contextLength ?? 0;
+        const bCtx = b.contextLength ?? 0;
+        if (aCtx !== bCtx)
+            return bCtx - aCtx;
+        const aParams = a.inferredParamB ?? 0;
+        const bParams = b.inferredParamB ?? 0;
+        if (aParams !== bParams)
+            return bParams - aParams;
+        return a.modelRef.localeCompare(b.modelRef);
+    });
+}
+function sortImageResults(results) {
+    return results.slice().sort((a, b) => {
+        const aLatency = a.image.latencyMs ?? Number.POSITIVE_INFINITY;
+        const bLatency = b.image.latencyMs ?? Number.POSITIVE_INFINITY;
+        if (aLatency !== bLatency)
+            return aLatency - bLatency;
+        const aCtx = a.contextLength ?? 0;
+        const bCtx = b.contextLength ?? 0;
+        if (aCtx !== bCtx)
+            return bCtx - aCtx;
+        const aParams = a.inferredParamB ?? 0;
+        const bParams = b.inferredParamB ?? 0;
+        if (aParams !== bParams)
+            return bParams - aParams;
+        return a.modelRef.localeCompare(b.modelRef);
+    });
+}
+function buildScanHint(result) {
+    const toolLabel = result.tool.ok
+        ? `tool ${formatMs(result.tool.latencyMs)}`
+        : "tool fail";
+    const imageLabel = result.image.skipped
+        ? "img skip"
+        : result.image.ok
+            ? `img ${formatMs(result.image.latencyMs)}`
+            : "img fail";
+    const ctxLabel = result.contextLength
+        ? `ctx ${formatTokenK(result.contextLength)}`
+        : "ctx ?";
+    const paramLabel = result.inferredParamB ? `${result.inferredParamB}b` : null;
+    return [toolLabel, imageLabel, ctxLabel, paramLabel]
+        .filter(Boolean)
+        .join(" | ");
+}
+function printScanSummary(results, runtime) {
+    const toolOk = results.filter((r) => r.tool.ok);
+    const imageOk = results.filter((r) => r.image.ok);
+    const toolImageOk = results.filter((r) => r.tool.ok && r.image.ok);
+    const imageOnly = imageOk.filter((r) => !r.tool.ok);
+    runtime.log(`Scan results: tested ${results.length}, tool ok ${toolOk.length}, image ok ${imageOk.length}, tool+image ok ${toolImageOk.length}, image only ${imageOnly.length}`);
+}
+function printScanTable(results, runtime) {
+    const header = [
+        pad("Model", MODEL_PAD),
+        pad("Tool", 10),
+        pad("Image", 10),
+        pad("Ctx", CTX_PAD),
+        pad("Params", 8),
+        "Notes",
+    ].join(" ");
+    runtime.log(header);
+    for (const entry of results) {
+        const modelLabel = pad(truncate(entry.modelRef, MODEL_PAD), MODEL_PAD);
+        const toolLabel = pad(entry.tool.ok ? formatMs(entry.tool.latencyMs) : "fail", 10);
+        const imageLabel = pad(entry.image.ok
+            ? formatMs(entry.image.latencyMs)
+            : entry.image.skipped
+                ? "skip"
+                : "fail", 10);
+        const ctxLabel = pad(formatTokenK(entry.contextLength), CTX_PAD);
+        const paramsLabel = pad(entry.inferredParamB ? `${entry.inferredParamB}b` : "-", 8);
+        const notes = entry.modality ? `modality:${entry.modality}` : "";
+        runtime.log([modelLabel, toolLabel, imageLabel, ctxLabel, paramsLabel, notes].join(" "));
+    }
+}
+export async function modelsScanCommand(opts, runtime) {
+    const minParams = opts.minParams ? Number(opts.minParams) : undefined;
+    if (minParams !== undefined &&
+        (!Number.isFinite(minParams) || minParams < 0)) {
+        throw new Error("--min-params must be >= 0");
+    }
+    const maxAgeDays = opts.maxAgeDays ? Number(opts.maxAgeDays) : undefined;
+    if (maxAgeDays !== undefined &&
+        (!Number.isFinite(maxAgeDays) || maxAgeDays < 0)) {
+        throw new Error("--max-age-days must be >= 0");
+    }
+    const maxCandidates = opts.maxCandidates ? Number(opts.maxCandidates) : 6;
+    if (!Number.isFinite(maxCandidates) || maxCandidates <= 0) {
+        throw new Error("--max-candidates must be > 0");
+    }
+    const timeout = opts.timeout ? Number(opts.timeout) : undefined;
+    if (timeout !== undefined && (!Number.isFinite(timeout) || timeout <= 0)) {
+        throw new Error("--timeout must be > 0");
+    }
+    const concurrency = opts.concurrency ? Number(opts.concurrency) : undefined;
+    if (concurrency !== undefined &&
+        (!Number.isFinite(concurrency) || concurrency <= 0)) {
+        throw new Error("--concurrency must be > 0");
+    }
+    const cfg = loadConfig();
+    let storedKey;
+    try {
+        const resolved = await resolveApiKeyForProvider({
+            provider: "openrouter",
+            cfg,
+        });
+        storedKey = resolved.apiKey;
+    }
+    catch {
+        storedKey = undefined;
+    }
+    const results = await scanOpenRouterModels({
+        apiKey: storedKey ?? undefined,
+        minParamB: minParams,
+        maxAgeDays,
+        providerFilter: opts.provider,
+        timeoutMs: timeout,
+        concurrency,
+    });
+    const toolOk = results.filter((entry) => entry.tool.ok);
+    if (toolOk.length === 0) {
+        throw new Error("No tool-capable OpenRouter free models found.");
+    }
+    const sorted = sortScanResults(results);
+    const toolSorted = sortScanResults(toolOk);
+    const imageOk = results.filter((entry) => entry.image.ok);
+    const imageSorted = sortImageResults(imageOk);
+    const imagePreferred = toolSorted.filter((entry) => entry.image.ok);
+    const preselectPool = imagePreferred.length > 0 ? imagePreferred : toolSorted;
+    const preselected = preselectPool
+        .slice(0, Math.floor(maxCandidates))
+        .map((entry) => entry.modelRef);
+    const imagePreselected = imageSorted
+        .slice(0, Math.floor(maxCandidates))
+        .map((entry) => entry.modelRef);
+    if (!opts.json) {
+        printScanSummary(results, runtime);
+        printScanTable(sorted, runtime);
+    }
+    const noInput = opts.input === false;
+    const canPrompt = process.stdin.isTTY && !opts.yes && !noInput && !opts.json;
+    let selected = preselected;
+    let selectedImages = imagePreselected;
+    if (canPrompt) {
+        const selection = await multiselect({
+            message: "Select fallback models (ordered)",
+            options: toolSorted.map((entry) => ({
+                value: entry.modelRef,
+                label: entry.modelRef,
+                hint: buildScanHint(entry),
+            })),
+            initialValues: preselected,
+        });
+        if (isCancel(selection)) {
+            cancel("Model scan cancelled.");
+            runtime.exit(0);
+        }
+        selected = selection;
+        if (imageSorted.length > 0) {
+            const imageSelection = await multiselect({
+                message: "Select image fallback models (ordered)",
+                options: imageSorted.map((entry) => ({
+                    value: entry.modelRef,
+                    label: entry.modelRef,
+                    hint: buildScanHint(entry),
+                })),
+                initialValues: imagePreselected,
+            });
+            if (isCancel(imageSelection)) {
+                cancel("Model scan cancelled.");
+                runtime.exit(0);
+            }
+            selectedImages = imageSelection;
+        }
+    }
+    else if (!process.stdin.isTTY && !opts.yes && !noInput && !opts.json) {
+        throw new Error("Non-interactive scan: pass --yes to apply defaults.");
+    }
+    if (selected.length === 0) {
+        throw new Error("No models selected for fallbacks.");
+    }
+    if (opts.setImage && selectedImages.length === 0) {
+        throw new Error("No image-capable models selected for image model.");
+    }
+    const _updated = await updateConfig((cfg) => {
+        const nextModels = { ...cfg.agent?.models };
+        for (const entry of selected) {
+            if (!nextModels[entry])
+                nextModels[entry] = {};
+        }
+        for (const entry of selectedImages) {
+            if (!nextModels[entry])
+                nextModels[entry] = {};
+        }
+        const existingImageModel = cfg.agent?.imageModel;
+        const nextImageModel = selectedImages.length > 0
+            ? {
+                ...(existingImageModel?.primary
+                    ? { primary: existingImageModel.primary }
+                    : undefined),
+                fallbacks: selectedImages,
+                ...(opts.setImage ? { primary: selectedImages[0] } : {}),
+            }
+            : cfg.agent?.imageModel;
+        const existingModel = cfg.agent?.model;
+        const agent = {
+            ...cfg.agent,
+            model: {
+                ...(existingModel?.primary
+                    ? { primary: existingModel.primary }
+                    : undefined),
+                fallbacks: selected,
+                ...(opts.setDefault ? { primary: selected[0] } : {}),
+            },
+            ...(nextImageModel ? { imageModel: nextImageModel } : {}),
+            models: nextModels,
+        };
+        return {
+            ...cfg,
+            agent,
+        };
+    });
+    if (opts.json) {
+        runtime.log(JSON.stringify({
+            selected,
+            selectedImages,
+            setDefault: Boolean(opts.setDefault),
+            setImage: Boolean(opts.setImage),
+            results,
+            warnings: [],
+        }, null, 2));
+        return;
+    }
+    runtime.log(`Updated ${CONFIG_PATH_NEXUS}`);
+    runtime.log(`Fallbacks: ${selected.join(", ")}`);
+    if (selectedImages.length > 0) {
+        runtime.log(`Image fallbacks: ${selectedImages.join(", ")}`);
+    }
+    if (opts.setDefault) {
+        runtime.log(`Default model: ${selected[0]}`);
+    }
+    if (opts.setImage && selectedImages.length > 0) {
+        runtime.log(`Image model: ${selectedImages[0]}`);
+    }
+}

package/dist/commands/models/set-image.js

@@ -0,0 +1,27 @@
+import { CONFIG_PATH_NEXUS } from "../../config/config.js";
+import { resolveModelTarget, updateConfig } from "./shared.js";
+export async function modelsSetImageCommand(modelRaw, runtime) {
+    const updated = await updateConfig((cfg) => {
+        const resolved = resolveModelTarget({ raw: modelRaw, cfg });
+        const key = `${resolved.provider}/${resolved.model}`;
+        const nextModels = { ...cfg.agent?.models };
+        if (!nextModels[key])
+            nextModels[key] = {};
+        const existingModel = cfg.agent?.imageModel;
+        return {
+            ...cfg,
+            agent: {
+                ...cfg.agent,
+                imageModel: {
+                    ...(existingModel?.fallbacks
+                        ? { fallbacks: existingModel.fallbacks }
+                        : undefined),
+                    primary: key,
+                },
+                models: nextModels,
+            },
+        };
+    });
+    runtime.log(`Updated ${CONFIG_PATH_NEXUS}`);
+    runtime.log(`Image model: ${updated.agent?.imageModel?.primary ?? modelRaw}`);
+}

package/dist/commands/models/set.js

@@ -0,0 +1,27 @@
+import { CONFIG_PATH_NEXUS } from "../../config/config.js";
+import { resolveModelTarget, updateConfig } from "./shared.js";
+export async function modelsSetCommand(modelRaw, runtime) {
+    const updated = await updateConfig((cfg) => {
+        const resolved = resolveModelTarget({ raw: modelRaw, cfg });
+        const key = `${resolved.provider}/${resolved.model}`;
+        const nextModels = { ...cfg.agent?.models };
+        if (!nextModels[key])
+            nextModels[key] = {};
+        const existingModel = cfg.agent?.model;
+        return {
+            ...cfg,
+            agent: {
+                ...cfg.agent,
+                model: {
+                    ...(existingModel?.fallbacks
+                        ? { fallbacks: existingModel.fallbacks }
+                        : undefined),
+                    primary: key,
+                },
+                models: nextModels,
+            },
+        };
+    });
+    runtime.log(`Updated ${CONFIG_PATH_NEXUS}`);
+    runtime.log(`Default model: ${updated.agent?.model?.primary ?? modelRaw}`);
+}