localpi 0.5.0 → 0.6.0

package/dist/src/llm/openai.js

@@ -16,6 +16,22 @@ export async function listModels(baseUrl, timeoutMs = 3000, fetcher = fetch) {
         .map((entry) => modelInfo(asObject(entry, "model entry")))
         .filter((model) => model !== undefined);
 }
+export async function fetchServerProps(baseUrl, timeoutMs = 3000, fetcher = fetch) {
+    const response = await fetcher(`${serverRootUrl(baseUrl)}/props`, {
+        signal: AbortSignal.timeout(timeoutMs)
+    });
+    if (!response.ok) {
+        throw new Error(`server props failed with HTTP ${String(response.status)}`);
+    }
+    const payload = await response.json();
+    const root = asObject(payload, "server props response");
+    const role = optionalString(root["role"]);
+    const modelsAutoload = optionalBoolean(root["models_autoload"]);
+    return {
+        ...(role === undefined ? {} : { role }),
+        ...(modelsAutoload === undefined ? {} : { modelsAutoload })
+    };
+}
 export async function resolveLocalModel(baseUrl, requestedModel, timeoutMs = 3000, fetcher = fetch) {
     const modelInfos = await listModels(baseUrl, timeoutMs, fetcher);
     const availableModels = modelInfos.map((model) => model.id);
@@ -36,7 +52,47 @@ function modelInfo(entry) {
     if (id === undefined) {
         return undefined;
     }
-    return withOptionalContextWindow({ id }, findContextWindow(entry));
+    const contextWindow = findContextWindow(entry);
+    const inputModalities = findInputModalities(entry);
+    return {
+        id,
+        ...optionalModelStatus(modelStatus(entry["status"])),
+        ...(contextWindow === undefined ? {} : { contextWindow }),
+        ...(inputModalities === undefined ? {} : { inputModalities })
+    };
+}
+// llama.cpp reports the model architecture in /v1/models, and a model that accepts images says so
+// in input_modalities. Anything else stays unknown instead of guessed.
+function findInputModalities(entry) {
+    const architecture = entry["architecture"];
+    if (architecture === null || typeof architecture !== "object" || Array.isArray(architecture)) {
+        return undefined;
+    }
+    const value = architecture["input_modalities"];
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const modalities = value.filter((item) => typeof item === "string");
+    return modalities.length === 0 ? undefined : modalities;
+}
+function optionalModelStatus(status) {
+    return status === undefined ? {} : { status };
+}
+function modelStatus(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return undefined;
+    }
+    const status = optionalString(value["value"]);
+    return status === "loaded" || status === "unloaded" ? status : undefined;
+}
+function optionalBoolean(value) {
+    return typeof value === "boolean" ? value : undefined;
+}
+// llama.cpp serves /props at the server root, while the OpenAI-compatible API
+// lives under /v1. Strip that one trailing segment when building the props URL.
+function serverRootUrl(baseUrl) {
+    const normalized = normalizeBaseUrl(baseUrl);
+    return normalized.endsWith("/v1") ? normalized.slice(0, -3) : normalized;
 }
 function withOptionalContextWindow(value, contextWindow) {
     if (contextWindow === undefined) {
@@ -61,9 +117,14 @@ function findContextWindow(entry) {
             return value;
         }
     }
-    const metadata = entry["metadata"];
-    if (metadata !== null && typeof metadata === "object" && !Array.isArray(metadata)) {
-        return findContextWindow(metadata);
+    for (const key of ["metadata", "meta"]) {
+        const nested = entry[key];
+        if (nested !== null && typeof nested === "object" && !Array.isArray(nested)) {
+            const found = findContextWindow(nested);
+            if (found !== undefined) {
+                return found;
+            }
+        }
     }
     return undefined;
 }

package/dist/src/localpi/acp.js

@@ -0,0 +1,118 @@
+import { spawn } from "node:child_process";
+import { chmod, mkdir, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { createPiLaunchPlan, writePiRuntimeConfig } from "@osolmaz/pi-factory";
+const adapterPackage = "pi-acp";
+const adapterEntry = path.join("dist", "index.js");
+const localpiPiCommandError = "ACP mode cannot start localpi as its Pi command; pass a Pi command with --pi-command or LOCALPI_PI_CMD";
+/** The pinned adapter entrypoint inside the installed pi-acp package. */
+export function acpAdapterEntrypoint(env = process.env) {
+    const override = env["LOCALPI_ACP_ADAPTER"];
+    if (override !== undefined && override !== "") {
+        return path.resolve(override);
+    }
+    const require = createRequire(import.meta.url);
+    const packagePath = require.resolve(`${adapterPackage}/package.json`);
+    return path.join(path.dirname(packagePath), adapterEntry);
+}
+export async function createAcpSession(app) {
+    const adapterEntrypoint = acpAdapterEntrypoint();
+    const runtimeConfig = await writePiRuntimeConfig(app);
+    await mkdir(app.sessionDir, { recursive: true });
+    const plan = await createPiLaunchPlan(app, runtimeConfig);
+    assertPiCommandIsNotLocalpi(plan);
+    const launcherPath = await writePiLauncher(app.stateDir, plan);
+    return {
+        command: process.execPath,
+        args: [adapterEntrypoint],
+        env: { ...plan.env, PI_ACP_PI_COMMAND: launcherPath, LOCALPI_ACP: "0" },
+        cwd: plan.cwd,
+        launcherPath,
+        warnings: plan.warnings
+    };
+}
+/**
+ * Runs the ACP adapter on the current terminal. The adapter owns stdout, because ACP messages are
+ * the only bytes an ACP client accepts there. localpi writes its own diagnostics to stderr.
+ */
+export async function runAcpApp(app, options = {}) {
+    const session = await createAcpSession(app);
+    writeDiagnostics(options.diagnostics ?? []);
+    const spawnProcess = options.spawnProcess ?? defaultSpawn;
+    return await new Promise((resolve, reject) => {
+        spawnProcess(session.command, session.args, {
+            stdio: "inherit",
+            cwd: session.cwd,
+            env: { ...process.env, ...session.env }
+        }, {
+            onError: reject,
+            onExit: (code, signal) => {
+                if (signal !== null) {
+                    process.kill(process.pid, signal);
+                    return;
+                }
+                resolve(code ?? 0);
+            }
+        });
+    });
+}
+function defaultSpawn(command, args, options, handlers) {
+    const child = spawn(command, [...args], options);
+    child.on("error", handlers.onError);
+    child.on("exit", handlers.onExit);
+}
+function writeDiagnostics(lines) {
+    for (const line of lines) {
+        process.stderr.write(`${line}\n`);
+    }
+}
+async function writePiLauncher(stateDir, plan) {
+    const directory = path.join(stateDir, "acp");
+    await mkdir(directory, { recursive: true });
+    const launcherPath = path.join(directory, launcherFileName(process.platform));
+    await writeFile(launcherPath, launcherContents(plan, process.platform));
+    await chmod(launcherPath, 0o755);
+    return launcherPath;
+}
+function launcherFileName(platform) {
+    return platform === "win32" ? "pi-launcher.cmd" : "pi-launcher.sh";
+}
+/**
+ * The launcher forwards the adapter's own Pi arguments after localpi's launch line. Both branches
+ * quote every token, so a Pi program or argument that contains a space survives the shell.
+ */
+export function launcherContents(plan, platform) {
+    if (platform === "win32") {
+        const command = [plan.command, ...plan.args].map(quoteWindowsToken).join(" ");
+        return `@echo off\r\n${command} %*\r\n`;
+    }
+    const command = [plan.command, ...plan.args].map(quotePosixToken).join(" ");
+    return `#!/bin/sh\nexec ${command} "$@"\n`;
+}
+function quotePosixToken(token) {
+    return `'${token.replaceAll("'", "'\\''")}'`;
+}
+function quoteWindowsToken(token) {
+    return `"${token.replace(/"/gu, '""')}"`;
+}
+/**
+ * A Pi command that points back at localpi would re-enter ACP mode inside the adapter. Refuse that
+ * before the adapter starts.
+ */
+function assertPiCommandIsNotLocalpi(plan) {
+    if (isLocalpiCommand(plan.command) || plan.args.some(isLocalpiCliPath)) {
+        throw new Error(localpiPiCommandError);
+    }
+}
+function isLocalpiCommand(program) {
+    const name = path
+        .basename(program)
+        .toLowerCase()
+        .replace(/\.(js|cjs|mjs|cmd|bat|exe)$/u, "");
+    return name === "localpi";
+}
+function isLocalpiCliPath(token) {
+    const normalized = token.replaceAll("\\", "/").toLowerCase();
+    return /(^|\/)localpi\/(dist\/)?src\/cli\/main\.(js|ts)$/u.test(normalized);
+}

package/dist/src/localpi/catalog.js

@@ -1,4 +1,4 @@
-import { listModels } from "../llm/openai.js";
+import { fetchServerProps, listModels } from "../llm/openai.js";
 import { getManagedLlamaServerMetadata, getLlamaServerModels, llamaBaseUrl, managedLlamaServerUnavailableMessage } from "./llama-server.js";
 import { listModelAliases, resolveLlamaModel } from "./models.js";
 import { loadLocalModelProfile, profileMatchesBaseUrl, profileMatchesModel } from "./model-profile.js";
@@ -16,6 +16,8 @@ async function discoverProvider(config, options, profile) {
     switch (config.type) {
         case "openai-compatible":
             return discoverOpenAiCompatibleProvider(config, options, profile);
+        case "llama-cpp":
+            return discoverLlamaCppProvider(config, options, profile);
         case "managed-llama-server":
             return discoverManagedLlamaProvider(config, options);
     }
@@ -52,7 +54,7 @@ async function discoverOpenAiCompatibleProvider(config, options, profile) {
         };
     }
 }
-function openAiCatalogModel(config, model, options, profile) {
+function openAiCatalogModel(config, model, options, profile, availability = "loaded") {
     const baseUrl = config.baseUrl ?? "";
     const profileConfig = profileCapabilityConfig(profile, baseUrl, model.id);
     const aliases = profileAliases(profile, baseUrl, model.id);
@@ -67,11 +69,76 @@ function openAiCatalogModel(config, model, options, profile) {
         displayName: `${config.name} / ${model.id}`,
         maxTokens: profileConfig.maxTokens ?? options.maxTokens,
         ...externalCapabilityConfig(config.id, model.id, profileConfig, options),
-        capabilities: ["text"],
-        availability: "loaded",
+        capabilities: modelCapabilities(model, profileConfig),
+        availability,
         ...(contextWindow === undefined ? {} : { contextWindow })
     };
 }
+async function discoverLlamaCppProvider(config, options, profile) {
+    const baseUrl = config.baseUrl;
+    if (baseUrl === undefined) {
+        return { models: [], warnings: [] };
+    }
+    if (!config.discover) {
+        const explicitModel = explicitOpenAiCatalogModel(config, [], options, profile);
+        return { models: explicitModel === undefined ? [] : [explicitModel], warnings: [] };
+    }
+    let models;
+    try {
+        models = await listModels(baseUrl, options.timeoutMs);
+    }
+    catch (error) {
+        if (explicitOpenAiProviderSelected(options, config.id)) {
+            throw error;
+        }
+        return {
+            models: [],
+            warnings: [
+                catalogWarning(config.id, config.name, "provider-not-responding", {
+                    message: `not responding at ${baseUrl}`
+                })
+            ]
+        };
+    }
+    const loaded = models.filter((model) => model.status !== "unloaded");
+    const unloaded = models.filter((model) => model.status === "unloaded");
+    const autoload = await llamaCppAutoload(baseUrl, options);
+    const startable = autoload === true ? unloaded : [];
+    return {
+        models: [
+            ...loaded.map((model) => openAiCatalogModel(config, model, options, profile, "loaded")),
+            ...startable.map((model) => openAiCatalogModel(config, model, options, profile, "startable"))
+        ],
+        warnings: llamaCppUnloadedWarnings(config, unloaded, autoload)
+    };
+}
+// Pi passes image input to a model only when the model catalog says the model takes images. A
+// llama.cpp server reports that in the model architecture, and a model profile can state it for a
+// server that reports nothing. No model name is used to guess it.
+function modelCapabilities(model, profileConfig) {
+    const image = profileConfig.image ?? model.inputModalities?.includes("image") === true;
+    return image ? ["text", "image"] : ["text"];
+}
+async function llamaCppAutoload(baseUrl, options) {
+    try {
+        return (await fetchServerProps(baseUrl, options.timeoutMs)).modelsAutoload;
+    }
+    catch {
+        return undefined;
+    }
+}
+function llamaCppUnloadedWarnings(config, unloaded, autoload) {
+    if (unloaded.length === 0 || autoload === true) {
+        return [];
+    }
+    return [
+        catalogWarning(config.id, config.name, "runtime-warning", {
+            message: `${config.name} reported unloaded models: ${unloaded
+                .map((model) => model.id)
+                .join(", ")}; the server does not autoload models`
+        })
+    ];
+}
 function profileAliases(profile, baseUrl, modelId) {
     if (profile === undefined ||
         !profileMatchesBaseUrl(profile, baseUrl) ||
@@ -103,6 +170,7 @@ function explicitOpenAiProviderSelected(options, providerId) {
         (options.provider === undefined &&
             (options.runtime === "lmstudio" ||
                 options.runtime === "vllm" ||
+                options.runtime === "llama-cpp" ||
                 options.runtime === "openai-compatible")));
 }
 async function discoverManagedLlamaProvider(config, options) {
@@ -263,14 +331,18 @@ function isQwenThinkingModel(normalizedModelId) {
         (normalizedModelId.includes("qwen") &&
             (normalizedModelId.includes("reason") || normalizedModelId.includes("thinking"))));
 }
+function profileApplies(profile, baseUrl, modelId) {
+    return (profile !== undefined &&
+        profileMatchesBaseUrl(profile, baseUrl) &&
+        profileMatchesModel(profile, modelId));
+}
 function profileCapabilityConfig(profile, baseUrl, modelId) {
-    if (profile === undefined ||
-        !profileMatchesBaseUrl(profile, baseUrl) ||
-        !profileMatchesModel(profile, modelId)) {
+    if (!profileApplies(profile, baseUrl, modelId)) {
         return {};
     }
     return withoutUndefined({
         reasoning: profile.capabilities?.reasoning,
+        image: profile.capabilities?.image,
         thinkingFormat: profile.capabilities?.thinkingFormat,
         contextWindow: profile.client?.contextWindow,
         maxTokens: profile.client?.maxTokens

package/dist/src/localpi/catppuccin.js

@@ -0,0 +1,64 @@
+// Catppuccin Mocha palette. Source: https://catppuccin.com/palette (MIT).
+//
+// The palette has two consumers: the Pi theme localpi writes for each session, and localpi's own
+// terminal output. Keep both on this palette so the launcher and the session match.
+export const catppuccinMocha = {
+    rosewater: "#f5e0dc",
+    flamingo: "#f2cdcd",
+    pink: "#f5c2e7",
+    mauve: "#cba6f7",
+    red: "#f38ba8",
+    maroon: "#eba0ac",
+    peach: "#fab387",
+    yellow: "#f9e2af",
+    green: "#a6e3a1",
+    teal: "#94e2d5",
+    sky: "#89dceb",
+    sapphire: "#74c7ec",
+    blue: "#89b4fa",
+    lavender: "#b4befe",
+    text: "#cdd6f4",
+    subtext1: "#bac2de",
+    subtext0: "#a6adc8",
+    overlay2: "#9399b2",
+    overlay1: "#7f849c",
+    overlay0: "#6c7086",
+    surface2: "#585b70",
+    surface1: "#45475a",
+    surface0: "#313244",
+    base: "#1e1e2e",
+    mantle: "#181825",
+    crust: "#11111b"
+};
+const ansiReset = "\u001B[0m";
+export function colorsEnabled(stream = "stdout") {
+    if (forcedColor()) {
+        return true;
+    }
+    if (noColor()) {
+        return false;
+    }
+    const target = stream === "stderr" ? process.stderr : process.stdout;
+    // Node types mark isTTY as a boolean, but a pipe leaves it undefined at runtime.
+    return Boolean(target.isTTY);
+}
+export function paint(text, color, stream = "stdout") {
+    if (text === "" || !colorsEnabled(stream)) {
+        return text;
+    }
+    return `${trueColor(catppuccinMocha[color])}${text}${ansiReset}`;
+}
+function forcedColor() {
+    const value = process.env["FORCE_COLOR"];
+    return value !== undefined && value !== "" && value !== "0";
+}
+function noColor() {
+    const value = process.env["NO_COLOR"];
+    return (value !== undefined && value !== "") || process.env["TERM"] === "dumb";
+}
+function trueColor(hex) {
+    const red = Number.parseInt(hex.slice(1, 3), 16);
+    const green = Number.parseInt(hex.slice(3, 5), 16);
+    const blue = Number.parseInt(hex.slice(5, 7), 16);
+    return `\u001B[38;2;${String(red)};${String(green)};${String(blue)}m`;
+}

package/dist/src/localpi/llama-server.js

@@ -85,15 +85,16 @@ export async function stopManagedLlamaServer(options) {
     await rm(metadataPath(options), { force: true });
     return `stopped localpi-owned llama-server pid ${String(info.pid)}`;
 }
+import { paint } from "./catppuccin.js";
 export async function llamaServerStatus(options) {
     const baseUrl = llamaBaseUrl(options);
     const info = await readActiveMetadataFile(options);
     const models = await getLlamaServerModels(options);
     return [
-        `runtime: llama-server`,
-        `base url: ${baseUrl}`,
-        `metadata: ${info === undefined ? "none" : metadataSummary(info)}`,
-        `server: ${models === undefined ? "not responding" : models.map((model) => model.id).join(", ")}`
+        `${paint("runtime:", "overlay1")} llama-server`,
+        `${paint("base url:", "overlay1")} ${baseUrl}`,
+        `${paint("metadata:", "overlay1")} ${info === undefined ? "none" : metadataSummary(info)}`,
+        `${paint("server:", "overlay1")} ${models === undefined ? "not responding" : models.map((model) => model.id).join(", ")}`
     ].join("\n");
 }
 export function llamaBaseUrl(options) {
@@ -213,7 +214,7 @@ function serverArgs(options, model) {
         "--gpu-layers",
         String(options.gpuLayers),
         ...chatTemplateArgs(model.chatTemplate),
-        ...reasoningArgs(options.thinking),
+        ...reasoningArgs(reasoningFor(options)),
         "--reasoning-format",
         "deepseek",
         "--metrics"
@@ -222,11 +223,15 @@ function serverArgs(options, model) {
 function chatTemplateArgs(chatTemplate) {
     return chatTemplate === undefined ? [] : ["--chat-template-file", chatTemplate];
 }
-function reasoningArgs(thinking) {
-    const config = reasoningConfig(thinking);
-    return config.budget === undefined
-        ? ["--reasoning", config.mode]
-        : ["--reasoning", config.mode, "--reasoning-budget", String(config.budget)];
+function reasoningArgs(config) {
+    const args = ["--reasoning", config.mode];
+    if (config.budget !== undefined) {
+        args.push("--reasoning-budget", String(config.budget));
+    }
+    if (config.message) {
+        args.push("--reasoning-budget-message", config.message);
+    }
+    return args;
 }
 async function waitForModels(baseUrl, modelId, timeoutMs) {
     const deadline = Date.now() + timeoutMs;
@@ -273,7 +278,7 @@ function metadata(options, model, pid) {
         port: endpoint.port,
         gpuLayers: options.gpuLayers,
         parallel: options.parallel,
-        ...reasoningMetadata(options.thinking),
+        ...reasoningMetadata(reasoningFor(options)),
         ...optionalChatTemplate(model.chatTemplate)
     };
 }
@@ -376,13 +381,15 @@ export function managedLlamaServerNeedsRestart(options, info, model) {
         info.port !== endpoint.port,
         info.gpuLayers !== options.gpuLayers,
         info.parallel !== options.parallel,
-        reasoningChanged(options.thinking, info)
+        reasoningChanged(options, info)
     ].some(Boolean);
     return fieldsChanged || chatTemplateChanged(options, info) || modelChanged(options, info, model);
 }
-function reasoningChanged(thinking, info) {
-    const expected = reasoningConfig(thinking);
-    return info.reasoningMode !== expected.mode || info.reasoningBudget !== expected.budget;
+function reasoningChanged(options, info) {
+    const expected = reasoningFor(options);
+    return (info.reasoningMode !== expected.mode ||
+        info.reasoningBudget !== expected.budget ||
+        info.reasoningMessage !== expected.message);
 }
 function chatTemplateChanged(options, info) {
     return options.chatTemplate !== undefined && info.chatTemplate !== options.chatTemplate;
@@ -480,33 +487,59 @@ function commandMatchesMetadata(command, info) {
     return (command.includes(info.modelPath) &&
         commandMarkers(info.serverCommand).some((marker) => command.includes(marker)));
 }
-function reasoningConfig(thinking) {
-    switch (thinking) {
-        case "off":
-            return { mode: "off" };
-        case "minimal":
-            return { mode: "on", budget: 32 };
-        case "low":
-            return { mode: "on", budget: 128 };
-        case "medium":
-            return { mode: "on", budget: 512 };
-        case "high":
-            return { mode: "on", budget: 2048 };
-        case "xhigh":
-            return { mode: "on", budget: 8192 };
-    }
-}
-function reasoningMetadata(thinking) {
-    const config = reasoningConfig(thinking);
-    return config.budget === undefined
-        ? { reasoningMode: config.mode }
-        : { reasoningMode: config.mode, reasoningBudget: config.budget };
+/** Thinking token budgets per level, in tokens. */
+const thinkingBudgets = {
+    minimal: 32,
+    low: 128,
+    medium: 512,
+    high: 2048,
+    xhigh: 16384
+};
+/**
+ * Injected before the end-of-thinking tag when the budget runs out. Without it the model is cut off
+ * mid-thought, and a model that loops in its thinking never reaches an answer. Set
+ * `--thinking-budget-message` or `LOCALPI_THINKING_BUDGET_MESSAGE` to reword it, or to an empty
+ * string to pass no message at all.
+ */
+export const reasoningBudgetMessage = "Reasoning budget reached. Stop thinking and answer now.";
+/**
+ * The reasoning flags of one thinking level. A budget override replaces the budget of the level,
+ * where -1 leaves thinking unrestricted. Thinking stays off when the level is off, and the message
+ * is set only for a finite budget, because an unrestricted budget has nothing to cut short. A
+ * message override rewords the default, and an empty override passes no message flag.
+ */
+export function reasoningConfig(thinking, budgetOverride, messageOverride) {
+    if (thinking === "off") {
+        return { mode: "off" };
+    }
+    const budget = budgetOverride ?? thinkingBudgets[thinking];
+    if (budget < 0) {
+        return { mode: "on", budget };
+    }
+    const message = messageOverride ?? reasoningBudgetMessage;
+    return message === "" ? { mode: "on", budget } : { mode: "on", budget, message };
+}
+function reasoningFor(options) {
+    return reasoningConfig(options.thinking, options.thinkingBudget, options.thinkingBudgetMessage);
+}
+function reasoningMetadata(config) {
+    return {
+        reasoningMode: config.mode,
+        ...(config.budget === undefined ? {} : { reasoningBudget: config.budget }),
+        ...(config.message ? { reasoningMessage: config.message } : {})
+    };
 }
 function parseReasoningMetadata(value) {
     const mode = value.reasoningMode === "on" ? "on" : "off";
-    return value.reasoningBudget === undefined
-        ? { reasoningMode: mode }
-        : { reasoningMode: mode, reasoningBudget: metadataNumber(value.reasoningBudget) };
+    return {
+        reasoningMode: mode,
+        ...(value.reasoningBudget === undefined
+            ? {}
+            : { reasoningBudget: metadataNumber(value.reasoningBudget) }),
+        ...(value.reasoningMessage === undefined || value.reasoningMessage === ""
+            ? {}
+            : { reasoningMessage: value.reasoningMessage })
+    };
 }
 function reasoningSummary(info) {
     return info.reasoningBudget === undefined

package/dist/src/localpi/model-profile.js

@@ -32,6 +32,9 @@ function parseLocalModelProfile(value, source) {
     const thinkingFormat = capabilities === undefined
         ? undefined
         : optionalThinkingFormat(optionalProfileString(capabilities["thinking_format"], `model profile ${source} capabilities.thinking_format`), `model profile ${source} capabilities.thinking_format`);
+    const image = capabilities === undefined
+        ? undefined
+        : optionalBoolean(capabilities["image"], `model profile ${source} capabilities.image`);
     return withoutUndefined({
         id: requiredString(root["id"], `model profile ${source} id`),
         model: requiredString(root["model"], `model profile ${source} model`),
@@ -46,6 +49,7 @@ function parseLocalModelProfile(value, source) {
             ? undefined
             : withoutUndefined({
                 reasoning,
+                image,
                 thinkingFormat
             })
     });