localpi 0.1.1 → 0.3.0

package/README.md

@@ -4,7 +4,7 @@ Localpi is a local Pi launcher for open-weight models.
 
 By default, Localpi discovers available local providers, lets you choose when more than one model is loaded, points Pi at the selected model, and writes Pi config for the other discovered models so `/model` can switch among them during the session.
 
-Localpi supports LM Studio, vLLM, custom OpenAI-compatible servers, and a managed `llama-server` fallback.
+Localpi supports LM Studio, vLLM, custom OpenAI-compatible servers, and an optional managed `llama-server` fallback.
 
 Localpi is intentionally generic. It does not contain classifier prompts, dataset workflows, GitHub routing logic, or final-schema output machinery. Structured classifier runs belong in caller tools such as `localpager-agent`.
 
@@ -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, 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 { 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 { applyRememberedSettings } from "../localpi/settings-state.js";
 import { writeRuntimeConfig } from "../pi/config.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));
+        return await launchResolvedRuntime(options, runtimeConfig, connection, extensions);
     }
     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(options, runtimeConfig, connection, extensions) {
+    const code = await execLaunchPlan(await createLaunchPlan(options, runtimeConfig, connection, extensions));
+    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 } from "./llama-server.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: []
         };
@@ -40,27 +42,45 @@ async function discoverOpenAiCompatibleProvider(config, options) {
         if (explicitOpenAiProviderSelected(options, config.id)) {
             throw error;
         }
-        return { models: [], warnings: [`${config.name} is not responding at ${config.baseUrl}`] };
+        return {
+            models: [],
+            warnings: [
+                catalogWarning(config.id, config.name, "provider-not-responding", {
+                    message: `not responding at ${config.baseUrl}`
+                })
+            ]
+        };
     }
 }
-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;
@@ -68,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 ||
@@ -81,10 +109,18 @@ async function discoverManagedLlamaProvider(config, options) {
     const baseUrl = llamaBaseUrl(options);
     const aliases = await listModelAliases();
     const loaded = await loadedLlamaModels(config, options, baseUrl, aliases);
+    const unavailableMessage = await managedLlamaServerUnavailableMessage(options);
     const startable = await startableLlamaModels(config, options, baseUrl, loaded.models, aliases);
     return {
         models: [...loaded.models, ...startable],
-        warnings: loaded.warnings
+        warnings: unavailableMessage === undefined
+            ? loaded.warnings
+            : [
+                ...loaded.warnings,
+                catalogWarning(config.id, config.name, "managed-command-unavailable", {
+                    message: unavailableMessage
+                })
+            ]
     };
 }
 async function loadedLlamaModels(config, options, baseUrl, aliases) {
@@ -105,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 })
@@ -131,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 })
@@ -143,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" };
@@ -151,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) {
@@ -160,7 +211,33 @@ 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 });
+}
+export function formatCatalogWarning(warning) {
+    switch (warning.code) {
+        case "provider-not-responding":
+            return `${warning.providerName} is ${warning.message}`;
+        case "managed-command-unavailable":
+        case "runtime-warning":
+            return warning.message;
+    }
+}
+function catalogWarning(providerId, providerName, code, options) {
+    return {
+        providerId,
+        providerName,
+        code,
+        message: options.message
+    };
 }
 function isDeepSeekThinkingModel(normalizedModelId) {
     return (normalizedModelId.includes("deepseek") &&
@@ -186,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));
+}