localpi 0.2.0 → 0.4.0

package/README.md

@@ -38,7 +38,7 @@ Target default:
 localpi --model gemma-12b
 ```
 
-This uses the default `auto` runtime. If exactly one model is loaded locally, Localpi selects it. If multiple models are loaded in an interactive terminal, Localpi boots Pi with a temporary default and opens Pi's native model selector. If no external model is loaded and `llama-server` is installed, Localpi can fall back to the managed `llama-server` default. Thinking starts as `off` unless `--thinking` or `LOCALPI_THINKING` sets another startup level.
+This uses the default `auto` runtime. If exactly one model is loaded locally, Localpi selects it. If multiple models are loaded in an interactive terminal, Localpi boots Pi with a temporary default and opens Pi's native model selector. If no external model is loaded and `llama-server` is installed, Localpi can fall back to the managed `llama-server` default. Thinking starts from `--thinking`, `LOCALPI_THINKING`, the last saved Pi thinking level, or `medium`.
 
 LM Studio is explicit:
 
@@ -109,6 +109,20 @@ Run a non-interactive Pi prompt:
 localpi -p "summarize this repo"
 ```
 
+Run an endless TUI demo:
+
+```bash
+localpi --demo --model gemma-e4b
+```
+
+Demo mode requires an explicit model, opens the normal Pi TUI, and keeps one live Pi session so followup prompts continue from the first prompt while Pi owns streaming, tok/s status, slash commands, and exit behavior.
+
+Override the demo prompts:
+
+```bash
+localpi --demo --model gemma-e4b --demo-initial-prompt-file ./prompts/story.txt --demo-followup-prompt "Continue. Try to write as long as possible."
+```
+
 Pin a model alias:
 
 ```bash
@@ -121,7 +135,7 @@ Use a bounded reasoning budget with managed `llama-server`:
 localpi --model gemma-12b --thinking low -p "classify this item"
 ```
 
-In an interactive session, use `/thinking` to pick a level or `/thinking high` to set one directly. This changes Pi's active thinking level for later turns. For managed `llama-server`, the server-side reasoning budget is still chosen at startup because changing it requires restarting the local server process.
+In an interactive session, use `/thinking` to pick a level or `/thinking high` to set one directly. This changes Pi's active thinking level for later turns and saves it for the next localpi launch. For managed `llama-server`, the server-side reasoning budget is still chosen at startup because changing it requires restarting the local server process.
 
 For managed `llama-server`, thinking levels map to server-side reasoning:
 
@@ -134,7 +148,7 @@ For managed `llama-server`, thinking levels map to server-side reasoning:
 | `high`    | `--reasoning on --reasoning-budget 2048` |
 | `xhigh`   | `--reasoning on --reasoning-budget 8192` |
 
-The default is `off`.
+The fallback default is `medium`.
 
 Point at vLLM:
 
@@ -179,8 +193,16 @@ localpi --stop
 - `--session-dir <path>`: Pi session directory. Default: `<state-dir>/sessions`
 - `--pi-command <command>`: Pi launch command
 - `--providers-file <path>`: provider registry JSON
+- `--model-profile <path>`: local model capability profile JSON
+- `--model-reasoning <bool>`: override generated Pi reasoning capability
+- `--model-thinking-format <deepseek|qwen-chat-template>`: override generated Pi thinking format
 - `--tools <list>`: Pi tools allow list. Default: `read,bash,edit,write,grep,find,ls`
-- `--thinking <off|minimal|low|medium|high|xhigh>`: Pi thinking level and managed `llama-server` reasoning budget. Default: `off`
+- `--thinking <off|minimal|low|medium|high|xhigh>`: Pi thinking level and managed `llama-server` reasoning budget. Default: last saved level, then `medium`
+- `--demo`: endlessly run Pi prompts inside the normal Pi TUI until interrupted or Pi exits; requires an explicit non-`auto` model
+- `--demo-initial-prompt <text>`: first demo prompt
+- `--demo-followup-prompt <text>`: repeated demo prompt after the first run
+- `--demo-initial-prompt-file <path>`: UTF-8 file for the first demo prompt
+- `--demo-followup-prompt-file <path>`: UTF-8 file for repeated demo prompts
 - `--no-approval`: disable the tool approval gate
 - `--no-token-status`: disable the token status extension
 - `--status`: print runtime, model, and Pi config status
@@ -194,6 +216,9 @@ localpi --stop
 - `LOCALPI_PROVIDER`
 - `LOCALPI_BASE_URL`
 - `LOCALPI_PROVIDERS_FILE`
+- `LOCALPI_MODEL_PROFILE`
+- `LOCALPI_MODEL_REASONING`
+- `LOCALPI_MODEL_THINKING_FORMAT`
 - `LOCALPI_STATE_DIR`
 - `LOCALPI_SESSION_DIR`
 - `LOCALPI_PI_CMD`
@@ -207,7 +232,15 @@ localpi --stop
 - `LOCALPI_CHAT_TEMPLATE`
 - `LOCALPI_TOOLS`
 - `LOCALPI_THINKING`
+- `LOCALPI_DEMO`
+- `LOCALPI_DEMO_INITIAL_PROMPT`
+- `LOCALPI_DEMO_FOLLOWUP_PROMPT`
+- `LOCALPI_DEMO_INITIAL_PROMPT_FILE`
+- `LOCALPI_DEMO_FOLLOWUP_PROMPT_FILE`
 - `LOCALPI_MODELS_FILE`
+- `LOCALPAGER_AGENT_PROFILE`
+- `LOCALPAGER_AGENT_REASONING`
+- `LOCALPAGER_AGENT_THINKING_FORMAT`
 
 `LOCALPI_MODELS_FILE` may point at a JSON file with this shape:
 
@@ -241,6 +274,26 @@ Provider registries use the same file or `LOCALPI_PROVIDERS_FILE`:
 
 Use `discover: false` for endpoints that should not be probed during startup. They can still be selected explicitly with `--provider vllm-qwen --model <id>`.
 
+Model capability profiles can fill in metadata that OpenAI-compatible servers do not expose through `/v1/models`, such as vLLM reasoning support:
+
+```json
+{
+  "id": "gemma4-26b-a4b-nvfp4",
+  "model": "nvidia/Gemma-4-26B-A4B-NVFP4",
+  "base_url": "http://127.0.0.1:8000/v1",
+  "client": {
+    "context_window": 32768,
+    "max_tokens": 4096
+  },
+  "capabilities": {
+    "reasoning": true,
+    "thinking_format": "qwen-chat-template"
+  }
+}
+```
+
+`LOCALPAGER_AGENT_PROFILE`, `LOCALPAGER_AGENT_REASONING`, and `LOCALPAGER_AGENT_THINKING_FORMAT` are accepted as aliases so LocalPager Agent can pass the same profile metadata through to localpi.
+
 ## Development
 
 ```bash

package/dist/src/cli/cli.js

@@ -1,35 +1,250 @@
+import { runPiApp } from "@dutifuldev/pi-factory";
 import { errorMessage, fail, ok } from "../common/result.js";
 import { parseLocalpiArgs, usage } from "../localpi/options.js";
 import { aliasListOutput, connectionStatus, resolveRuntime, statusOutput, stopRuntime } from "../localpi/runtime.js";
-import { writeRuntimeConfig } from "../pi/config.js";
+import { applyRememberedSettings } from "../localpi/settings-state.js";
+import { createLocalpiAppDefinition } from "../pi/app.js";
 import { writeDefaultExtensions } from "../pi/extensions.js";
-import { createLaunchPlan, execLaunchPlan } from "../pi/launch.js";
 export async function run(args) {
     try {
-        const options = parseLocalpiArgs(args);
+        let options = parseLocalpiArgs(args);
+        const helpResult = helpCommandResult(options);
+        if (helpResult !== undefined) {
+            return helpResult;
+        }
+        validateDemoOptions(options);
         const commandResult = await immediateCommandResult(options);
         if (commandResult !== undefined) {
             return commandResult;
         }
+        options = await applyRememberedSettings(options, {
+            thinking: hasExplicitThinkingOverride(args)
+        });
         const connection = await resolveRuntime(options);
-        const runtimeConfig = await writeRuntimeConfig(options, connection);
         const selectorOptions = startupModelSelectorOptions(options, connection);
         const extensions = await writeDefaultExtensions(options, selectorOptions === undefined ? {} : { startupModelSelector: selectorOptions });
-        const plan = await createLaunchPlan(options, runtimeConfig, connection, extensions);
-        const code = await execLaunchPlan(plan);
-        if (code !== 0) {
-            return { code, stdout: "", stderr: "" };
-        }
-        return ok(connection.warnings.length === 0 ? "" : connectionStatus(connection));
+        const app = createLocalpiAppDefinition(options, connection, extensions);
+        return await launchResolvedRuntime(app, connection);
     }
     catch (error) {
         return fail(`localpi: ${errorMessage(error)}`);
     }
 }
-async function immediateCommandResult(options) {
-    if (options.forwardedArgs.length === 1 && options.forwardedArgs[0] === "--help") {
-        return ok(usage());
+function validateDemoOptions(options) {
+    if (!options.demo) {
+        return;
+    }
+    validateExplicitDemoImmediateOptions(options);
+    if (!options.demoFromCli && hasImmediateCommand(options)) {
+        return;
+    }
+    validateDemoModel(options);
+    validateDemoTty();
+    validateForwardedDemoOptions(options.forwardedArgs);
+}
+function validateForwardedDemoOptions(args) {
+    const incompatibleMode = forwardedIncompatibleMode(args);
+    if (incompatibleMode !== undefined) {
+        throw new Error(`--demo cannot be used with forwarded Pi mode ${incompatibleMode}; demo mode runs inside Pi TUI`);
+    }
+    const metadataFlag = forwardedMetadataFlag(args);
+    if (metadataFlag !== undefined) {
+        throw new Error(`--demo cannot be used with forwarded Pi metadata flag ${metadataFlag}; run it without --demo`);
+    }
+    const extensionDisableFlag = forwardedExtensionDisableFlag(args);
+    if (extensionDisableFlag !== undefined) {
+        throw new Error(`--demo cannot be used with forwarded Pi extension flag ${extensionDisableFlag}; demo mode requires localpi's generated Pi extension`);
+    }
+    const sessionFlag = forwardedSessionFlag(args);
+    if (sessionFlag !== undefined) {
+        throw new Error(`--demo cannot be used with forwarded Pi session flag ${sessionFlag}; demo mode manages its own session`);
+    }
+    const promptInput = forwardedPromptInput(args);
+    if (promptInput !== undefined) {
+        throw new Error(`--demo cannot be used with forwarded Pi prompt input ${promptInput}; use --demo-initial-prompt or --demo-followup-prompt`);
+    }
+}
+function validateDemoModel(options) {
+    if (options.model === undefined || options.model === "auto") {
+        throw new Error("--demo requires an explicit --model <alias|id|path> or LOCALPI_MODEL value; demo mode will not auto-select a model");
+    }
+}
+function validateDemoTty() {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        throw new Error("--demo requires an interactive TTY on stdin and stdout; run it directly in a terminal");
+    }
+}
+function forwardedIncompatibleMode(args) {
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--mode") {
+            return args[index + 1] ?? "--mode";
+        }
+        if (arg?.startsWith("--mode=")) {
+            return arg.slice("--mode=".length);
+        }
+    }
+    return undefined;
+}
+function hasImmediateCommand(options) {
+    return options.status || options.stop || options.list;
+}
+function validateExplicitDemoImmediateOptions(options) {
+    if (!options.demoFromCli) {
+        return;
+    }
+    if (options.status) {
+        throw new Error("--demo cannot be used with --status");
+    }
+    if (options.stop) {
+        throw new Error("--demo cannot be used with --stop");
     }
+    if (options.list) {
+        throw new Error("--demo cannot be used with --list");
+    }
+}
+function forwardedPromptInput(args) {
+    for (let index = 0; index < args.length; index += 1) {
+        const scan = scanForwardedPromptInput(args, index);
+        if (scan.promptInput !== undefined) {
+            return scan.promptInput;
+        }
+        index += scan.consumed - 1;
+    }
+    return undefined;
+}
+function scanForwardedPromptInput(args, index) {
+    const arg = args[index];
+    if (arg === undefined) {
+        return noForwardedPromptInput(1);
+    }
+    if (isForwardedPromptFlag(arg) || arg.startsWith("@")) {
+        return { consumed: 1, promptInput: arg };
+    }
+    if (isPiValueToken(arg, args[index + 1])) {
+        return noForwardedPromptInput(2);
+    }
+    if (isPiIgnoredToken(arg)) {
+        return noForwardedPromptInput(1);
+    }
+    return arg.startsWith("-") ? noForwardedPromptInput(1) : { consumed: 1, promptInput: arg };
+}
+function noForwardedPromptInput(consumed) {
+    return { consumed, promptInput: undefined };
+}
+function isForwardedPromptFlag(arg) {
+    return arg === "-p" || arg === "--print" || arg === "--prompt" || arg.startsWith("--prompt=");
+}
+function forwardedSessionFlag(args) {
+    return args.find((arg) => isForwardedSessionFlag(arg));
+}
+const forwardedSessionFlags = new Set([
+    "--continue",
+    "-c",
+    "--resume",
+    "-r",
+    "--session",
+    "--session-id",
+    "--fork",
+    "--no-session"
+]);
+const forwardedSessionEqualsFlags = [
+    "--continue",
+    "--resume",
+    "--session",
+    "--session-id",
+    "--fork",
+    "--no-session"
+];
+function isForwardedSessionFlag(arg) {
+    return (forwardedSessionFlags.has(arg) ||
+        forwardedSessionEqualsFlags.some((flag) => arg.startsWith(`${flag}=`)));
+}
+function forwardedMetadataFlag(args) {
+    return args.find((arg) => isPiMetadataFlag(arg));
+}
+function forwardedExtensionDisableFlag(args) {
+    return args.find((arg) => arg === "--no-extensions" || arg === "-ne");
+}
+function isPiMetadataFlag(arg) {
+    return (arg === "--help" ||
+        arg === "-h" ||
+        arg === "--version" ||
+        arg === "-v" ||
+        arg === "--list-models" ||
+        arg === "--export");
+}
+function isPiValueToken(arg, next) {
+    return isPiValueFlag(arg) || isPiUnknownLongFlagValue(arg, next);
+}
+function isPiIgnoredToken(arg) {
+    return isPiBooleanFlag(arg) || isPiMetadataFlag(arg) || isForwardedSessionFlag(arg);
+}
+function isPiValueFlag(arg) {
+    return [
+        "--mode",
+        "--provider",
+        "--model",
+        "--api-key",
+        "--system-prompt",
+        "--append-system-prompt",
+        "--name",
+        "-n",
+        "--session",
+        "--session-id",
+        "--fork",
+        "--session-dir",
+        "--models",
+        "--tools",
+        "-t",
+        "--exclude-tools",
+        "-xt",
+        "--thinking",
+        "--export",
+        "--extension",
+        "-e",
+        "--skill",
+        "--prompt-template",
+        "--theme"
+    ].includes(arg);
+}
+function isPiBooleanFlag(arg) {
+    return [
+        "--no-tools",
+        "-nt",
+        "--no-builtin-tools",
+        "-nbt",
+        "--no-extensions",
+        "-ne",
+        "--no-skills",
+        "-ns",
+        "--no-prompt-templates",
+        "-np",
+        "--no-themes",
+        "--no-context-files",
+        "-nc",
+        "--verbose",
+        "--approve",
+        "-a",
+        "--no-approve",
+        "-na",
+        "--offline"
+    ].includes(arg);
+}
+function isPiUnknownLongFlagValue(arg, next) {
+    return arg.startsWith("--") && !arg.includes("=") && isPiUnknownLongFlagNextValue(next);
+}
+function isPiUnknownLongFlagNextValue(arg) {
+    return arg !== undefined && !arg.startsWith("-") && !arg.startsWith("@");
+}
+async function launchResolvedRuntime(app, connection) {
+    const code = await runPiApp(app);
+    if (code !== 0) {
+        return { code, stdout: "", stderr: "" };
+    }
+    return ok(connection.warnings.length === 0 ? "" : connectionStatus(connection));
+}
+async function immediateCommandResult(options) {
     if (options.list) {
         return ok(`${await aliasListOutput()}\n`);
     }
@@ -38,8 +253,27 @@ async function immediateCommandResult(options) {
     }
     return options.status ? ok(`${await statusOutput(options)}\n`) : undefined;
 }
+function helpCommandResult(options) {
+    return options.forwardedArgs.length === 1 && options.forwardedArgs[0] === "--help"
+        ? ok(usage())
+        : undefined;
+}
+function hasExplicitThinkingOverride(args) {
+    if (process.env["LOCALPI_THINKING"] !== undefined) {
+        return true;
+    }
+    for (const arg of args) {
+        if (arg === "--") {
+            return false;
+        }
+        if (arg === "--thinking") {
+            return true;
+        }
+    }
+    return false;
+}
 function startupModelSelectorOptions(options, connection) {
-    if (!process.stdin.isTTY || !process.stderr.isTTY) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
         return undefined;
     }
     if (options.model !== undefined && options.model !== "auto") {

package/dist/src/localpi/catalog.js

@@ -1,37 +1,39 @@
 import { 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";
 import { providerConfigs } from "./provider-registry.js";
 export async function discoverModelCatalog(options) {
     const configs = await providerConfigs(options);
-    const discovered = await Promise.all(configs.map((config) => discoverProvider(config, options)));
+    const profile = await loadLocalModelProfile(options);
+    const discovered = await Promise.all(configs.map((config) => discoverProvider(config, options, profile)));
     return {
         models: discovered.flatMap((entry) => entry.models),
         warnings: discovered.flatMap((entry) => entry.warnings)
     };
 }
-async function discoverProvider(config, options) {
+async function discoverProvider(config, options, profile) {
     switch (config.type) {
         case "openai-compatible":
-            return discoverOpenAiCompatibleProvider(config, options);
+            return discoverOpenAiCompatibleProvider(config, options, profile);
         case "managed-llama-server":
             return discoverManagedLlamaProvider(config, options);
     }
 }
-async function discoverOpenAiCompatibleProvider(config, options) {
+async function discoverOpenAiCompatibleProvider(config, options, profile) {
     if (config.baseUrl === undefined) {
         return { models: [], warnings: [] };
     }
     if (!config.discover) {
-        const explicitModel = explicitOpenAiCatalogModel(config, [], options);
+        const explicitModel = explicitOpenAiCatalogModel(config, [], options, profile);
         return { models: explicitModel === undefined ? [] : [explicitModel], warnings: [] };
     }
     try {
         const models = await listModels(config.baseUrl, options.timeoutMs);
-        const explicitModel = explicitOpenAiCatalogModel(config, models, options);
+        const explicitModel = explicitOpenAiCatalogModel(config, models, options, profile);
         return {
             models: explicitModel === undefined
-                ? models.map((model) => openAiCatalogModel(config, model, options))
+                ? models.map((model) => openAiCatalogModel(config, model, options, profile))
                 : [explicitModel],
             warnings: []
         };
@@ -50,24 +52,35 @@ async function discoverOpenAiCompatibleProvider(config, options) {
         };
     }
 }
-function openAiCatalogModel(config, model, options) {
+function openAiCatalogModel(config, model, options, profile) {
     const baseUrl = config.baseUrl ?? "";
+    const profileConfig = profileCapabilityConfig(profile, baseUrl, model.id);
+    const aliases = profileAliases(profile, baseUrl, model.id);
+    const contextWindow = profileConfig.contextWindow ?? model.contextWindow;
     return {
         providerId: config.id,
         providerName: config.name,
         runtime: "openai-compatible",
         baseUrl,
         modelId: model.id,
-        aliases: [],
+        aliases,
         displayName: `${config.name} / ${model.id}`,
-        maxTokens: options.maxTokens,
-        ...externalReasoningConfig(model.id),
+        maxTokens: profileConfig.maxTokens ?? options.maxTokens,
+        ...externalCapabilityConfig(config.id, model.id, profileConfig, options),
         capabilities: ["text"],
         availability: "loaded",
-        ...(model.contextWindow === undefined ? {} : { contextWindow: model.contextWindow })
+        ...(contextWindow === undefined ? {} : { contextWindow })
     };
 }
-function explicitOpenAiCatalogModel(config, models, options) {
+function profileAliases(profile, baseUrl, modelId) {
+    if (profile === undefined ||
+        !profileMatchesBaseUrl(profile, baseUrl) ||
+        !profileMatchesModel(profile, modelId)) {
+        return [];
+    }
+    return [profile.id, profile.model].filter((alias, index, aliases) => alias !== modelId && aliases.indexOf(alias) === index);
+}
+function explicitOpenAiCatalogModel(config, models, options, profile) {
     const requested = options.model;
     if (models.length !== 0 || requested === undefined || requested === "auto") {
         return undefined;
@@ -75,7 +88,15 @@ function explicitOpenAiCatalogModel(config, models, options) {
     if (!explicitOpenAiProviderSelected(options, config.id)) {
         return undefined;
     }
-    return openAiCatalogModel(config, { id: requested }, options);
+    return openAiCatalogModel(config, { id: explicitProfileModelId(profile, config.baseUrl ?? "", requested) }, options, profile);
+}
+function explicitProfileModelId(profile, baseUrl, requested) {
+    if (profile !== undefined &&
+        profileMatchesBaseUrl(profile, baseUrl) &&
+        profileMatchesModel(profile, requested)) {
+        return profile.model;
+    }
+    return requested;
 }
 function explicitOpenAiProviderSelected(options, providerId) {
     return (options.provider === providerId ||
@@ -120,7 +141,7 @@ async function loadedLlamaModels(config, options, baseUrl, aliases) {
                 aliases: aliases.filter((alias) => alias.id === model.id).map((alias) => alias.name),
                 displayName: `${config.name} / ${model.id}`,
                 maxTokens: options.maxTokens,
-                reasoning: managedModelSupportsReasoning(model.id),
+                ...managedCapabilityConfig(model.id, options),
                 capabilities: ["text"],
                 availability: "loaded",
                 ...(contextWindow === undefined ? {} : { contextWindow })
@@ -146,7 +167,7 @@ async function startableLlamaModels(config, options, baseUrl, loaded, aliases) {
                 aliases: [alias.name],
                 displayName: `${config.name} / ${alias.name}`,
                 maxTokens: options.maxTokens,
-                reasoning: managedModelSupportsReasoning(resolved.id),
+                ...managedCapabilityConfig(resolved.id, options),
                 capabilities: ["text"],
                 availability: "startable",
                 ...(resolved.contextWindow === undefined ? {} : { contextWindow: resolved.contextWindow })
@@ -158,7 +179,19 @@ async function startableLlamaModels(config, options, baseUrl, loaded, aliases) {
     }));
     return startable.filter((model) => model !== undefined);
 }
-function externalReasoningConfig(modelId) {
+function externalCapabilityConfig(providerId, modelId, profileConfig, options) {
+    const baseConfig = profileConfig.reasoning !== undefined || profileConfig.thinkingFormat !== undefined
+        ? {
+            reasoning: profileConfig.reasoning,
+            thinkingFormat: profileConfig.thinkingFormat
+        }
+        : externalReasoningConfig(providerId, modelId);
+    return withoutUndefined({
+        reasoning: options.modelReasoning ?? baseConfig.reasoning,
+        thinkingFormat: options.modelThinkingFormat ?? baseConfig.thinkingFormat
+    });
+}
+function externalReasoningConfig(providerId, modelId) {
     const normalized = modelId.toLowerCase();
     if (isDeepSeekThinkingModel(normalized)) {
         return { reasoning: true, thinkingFormat: "deepseek" };
@@ -166,6 +199,9 @@ function externalReasoningConfig(modelId) {
     if (isQwenThinkingModel(normalized)) {
         return { reasoning: true, thinkingFormat: "qwen-chat-template" };
     }
+    if (providerId === "vllm" && isGemmaThinkingModel(normalized)) {
+        return { reasoning: true, thinkingFormat: "qwen-chat-template" };
+    }
     return {};
 }
 export function managedModelSupportsReasoning(modelId) {
@@ -175,7 +211,13 @@ export function managedModelSupportsReasoning(modelId) {
         isDeepSeekThinkingModel(normalized) ||
         isQwenThinkingModel(normalized) ||
         normalized.includes("gpt-oss") ||
-        normalized.includes("gemma-4"));
+        isGemmaThinkingModel(normalized));
+}
+export function managedCapabilityConfig(modelId, options) {
+    return withoutUndefined({
+        reasoning: options.modelReasoning ?? managedModelSupportsReasoning(modelId),
+        thinkingFormat: options.modelThinkingFormat
+    });
 }
 export function runtimeCatalogWarning(providerId, providerName, message) {
     return catalogWarning(providerId, providerName, "runtime-warning", { message });
@@ -221,6 +263,25 @@ function isQwenThinkingModel(normalizedModelId) {
         (normalizedModelId.includes("qwen") &&
             (normalizedModelId.includes("reason") || normalizedModelId.includes("thinking"))));
 }
+function profileCapabilityConfig(profile, baseUrl, modelId) {
+    if (profile === undefined ||
+        !profileMatchesBaseUrl(profile, baseUrl) ||
+        !profileMatchesModel(profile, modelId)) {
+        return {};
+    }
+    return withoutUndefined({
+        reasoning: profile.capabilities?.reasoning,
+        thinkingFormat: profile.capabilities?.thinkingFormat,
+        contextWindow: profile.client?.contextWindow,
+        maxTokens: profile.client?.maxTokens
+    });
+}
+function isGemmaThinkingModel(normalizedModelId) {
+    return normalizedModelId.includes("gemma-4") || normalizedModelId.includes("gemma4");
+}
 function hasModelToken(normalizedModelId, token) {
     return normalizedModelId.split(/[^a-z0-9]+/u).includes(token);
 }
+function withoutUndefined(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, entryValue]) => entryValue !== undefined));
+}

package/dist/src/localpi/managed-runtime.js

@@ -1,5 +1,5 @@
 import { ensureLlamaServer, getManagedLlamaServerMetadata, getLlamaServerModels, llamaBaseUrl, managedLlamaServerNeedsRestart, stopManagedLlamaServer } from "./llama-server.js";
-import { managedModelSupportsReasoning, runtimeCatalogWarning } from "./catalog.js";
+import { managedCapabilityConfig, runtimeCatalogWarning } from "./catalog.js";
 import { catalogModelFromModelInfo, catalogRuntimeConnection, connectionCatalogModels, modelChoiceList, optionalContextWindow, replaceManagedLoadedModels } from "./runtime-connection.js";
 import { defaultLlamaModelName, findModelAlias, resolveLlamaModel } from "./models.js";
 export async function resolveLlamaRuntime(options) {
@@ -56,7 +56,7 @@ export async function customPathCatalogModel(options, provider, requested) {
         aliases: [requested],
         displayName: `llama-server / ${resolved.name}`,
         maxTokens: options.maxTokens,
-        reasoning: managedModelSupportsReasoning(resolved.id),
+        ...managedCapabilityConfig(resolved.id, options),
         capabilities: ["text"],
         availability: "startable",
         ...optionalContextWindow(options.contextWindow ?? resolved.contextWindow)