localpi 0.1.1 → 0.3.0

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

@@ -1,6 +1,6 @@
 import { execFile, spawn } from "node:child_process";
-import { closeSync, openSync } from "node:fs";
-import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { closeSync, constants, openSync } from "node:fs";
+import { access, mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { listModels, normalizeBaseUrl } from "../llm/openai.js";
 export async function ensureLlamaServer(options, model) {
@@ -23,6 +23,12 @@ export async function ensureLlamaServer(options, model) {
         contextWindow: requestedContextWindow(options, model)
     };
 }
+export async function managedLlamaServerUnavailableMessage(options) {
+    if (await executableExists(options.serverCommand)) {
+        return undefined;
+    }
+    return `llama-server command ${options.serverCommand} is not available; managed llama-server fallback disabled`;
+}
 async function handleExistingServer(options, model, baseUrl, warnings) {
     const state = await existingServerState(options, baseUrl);
     if (state.existing === undefined) {
@@ -118,6 +124,7 @@ function rejectExternalModelConflict(baseUrl, existing, requestedModel) {
     throw new Error(`server at ${baseUrl} is already serving ${ids.join(", ")}; stop it or choose that model before starting ${requestedModel}`);
 }
 async function startManagedServer(options, model) {
+    await assertManagedLlamaServerAvailable(options);
     await mkdir(serverDir(options), { recursive: true });
     const logPath = path.join(serverDir(options), "llama-server.log");
     const logFd = openSync(logPath, "a");
@@ -158,6 +165,36 @@ async function startManagedServer(options, model) {
         closeSync(logFd);
     }
 }
+async function assertManagedLlamaServerAvailable(options) {
+    if (await executableExists(options.serverCommand)) {
+        return;
+    }
+    throw new Error(`failed to start llama-server: executable not found: ${options.serverCommand}; install llama-server or pass --server-command`);
+}
+async function executableExists(command) {
+    if (command.length === 0) {
+        return false;
+    }
+    if (command.includes("/") || command.includes("\\")) {
+        return canExecute(command);
+    }
+    const entries = (process.env["PATH"] ?? "").split(path.delimiter).filter((entry) => entry !== "");
+    for (const entry of entries) {
+        if (await canExecute(path.join(entry, command))) {
+            return true;
+        }
+    }
+    return false;
+}
+async function canExecute(filePath) {
+    try {
+        await access(filePath, constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function serverArgs(options, model) {
     const endpoint = managedEndpoint(options);
     return [

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

@@ -1,5 +1,5 @@
 import { ensureLlamaServer, getManagedLlamaServerMetadata, getLlamaServerModels, llamaBaseUrl, managedLlamaServerNeedsRestart, stopManagedLlamaServer } from "./llama-server.js";
-import { managedModelSupportsReasoning } 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) {
@@ -32,7 +32,10 @@ export async function resolveSelectedLlamaRuntime(options, selected, catalog) {
         const selectedModel = managedCatalogModelFromConnection(options, selected, existing);
         return catalogRuntimeConnection(options, selectedModel, {
             models: replaceManagedLoadedModels(catalog.models, selected, existing.catalogModels),
-            warnings: [...catalog.warnings, ...existing.warnings]
+            warnings: [
+                ...catalog.warnings,
+                ...runtimeWarnings("llama-server", "llama-server", existing.warnings)
+            ]
         });
     }
     return startSelectedLlamaRuntime(options, selected, catalog);
@@ -53,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)
@@ -175,7 +178,10 @@ async function startSelectedLlamaRuntime(options, selected, catalog) {
     const loadedSelected = runtimeSelectedCatalogModel(options, selected, runtime);
     return catalogRuntimeConnection(options, loadedSelected, {
         models: replaceManagedLoadedModels(catalog.models, selected, [loadedSelected]),
-        warnings: [...catalog.warnings, ...runtime.warnings]
+        warnings: [
+            ...catalog.warnings,
+            ...runtimeWarnings("llama-server", "llama-server", runtime.warnings)
+        ]
     });
 }
 async function assertDirectLlamaStartIsSafe(options, model) {
@@ -217,6 +223,9 @@ function assertNoLoadedExternalModels(catalog) {
     }
     throw new Error(`external local models are already loaded; choose one or unload them before starting llama-server:\n${modelChoiceList(external)}`);
 }
+function runtimeWarnings(providerId, providerName, warnings) {
+    return warnings.map((warning) => runtimeCatalogWarning(providerId, providerName, warning));
+}
 function isGgufPathRequest(value) {
     return value.endsWith(".gguf") || value.includes("/") || value.includes("\\");
 }

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

@@ -0,0 +1,98 @@
+import { readFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { asObject, requiredString } from "../common/json.js";
+import { normalizeBaseUrl } from "../llm/openai.js";
+export async function loadLocalModelProfile(options) {
+    if (options.modelProfileFile === undefined) {
+        return undefined;
+    }
+    const raw = await readFile(expandHome(options.modelProfileFile), "utf8");
+    return parseLocalModelProfile(JSON.parse(raw), options.modelProfileFile);
+}
+export function profileMatchesModel(profile, modelId) {
+    return modelId === profile.model || modelId === profile.id;
+}
+export function profileMatchesBaseUrl(profile, baseUrl) {
+    return (profile.baseUrl === undefined || normalizeBaseUrl(profile.baseUrl) === normalizeBaseUrl(baseUrl));
+}
+function parseLocalModelProfile(value, source) {
+    const root = asObject(value, `model profile ${source}`);
+    const client = optionalObject(root["client"], `model profile ${source} client`);
+    const capabilities = optionalObject(root["capabilities"], `model profile ${source} capabilities`);
+    const contextWindow = client === undefined
+        ? undefined
+        : optionalPositiveInteger(client["context_window"], `model profile ${source} client.context_window`);
+    const maxTokens = client === undefined
+        ? undefined
+        : optionalPositiveInteger(client["max_tokens"], `model profile ${source} client.max_tokens`);
+    const reasoning = capabilities === undefined
+        ? undefined
+        : optionalBoolean(capabilities["reasoning"], `model profile ${source} capabilities.reasoning`);
+    const thinkingFormat = capabilities === undefined
+        ? undefined
+        : optionalThinkingFormat(optionalProfileString(capabilities["thinking_format"], `model profile ${source} capabilities.thinking_format`), `model profile ${source} capabilities.thinking_format`);
+    return withoutUndefined({
+        id: requiredString(root["id"], `model profile ${source} id`),
+        model: requiredString(root["model"], `model profile ${source} model`),
+        baseUrl: optionalProfileString(root["base_url"], `model profile ${source} base_url`),
+        client: client === undefined
+            ? undefined
+            : withoutUndefined({
+                contextWindow,
+                maxTokens
+            }),
+        capabilities: capabilities === undefined
+            ? undefined
+            : withoutUndefined({
+                reasoning,
+                thinkingFormat
+            })
+    });
+}
+function optionalObject(value, context) {
+    return value === undefined ? undefined : asObject(value, context);
+}
+function optionalProfileString(value, context) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== "string") {
+        throw new Error(`${context} must be a string`);
+    }
+    return value;
+}
+function optionalBoolean(value, context) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== "boolean") {
+        throw new Error(`${context} must be a boolean`);
+    }
+    return value;
+}
+function optionalPositiveInteger(value, context) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+        throw new Error(`${context} must be a positive integer`);
+    }
+    return value;
+}
+function optionalThinkingFormat(value, context) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === "deepseek" || value === "qwen-chat-template") {
+        return value;
+    }
+    throw new Error(`${context} must be deepseek or qwen-chat-template`);
+}
+function expandHome(value) {
+    const home = os.homedir();
+    return value === "~" || value.startsWith("~/") ? path.join(home, value.slice(2)) : value;
+}
+function withoutUndefined(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, entryValue]) => entryValue !== undefined));
+}

package/dist/src/localpi/options.js

@@ -18,10 +18,13 @@ export function defaultOptions() {
         provider: process.env["LOCALPI_PROVIDER"],
         customProviderId: envString("LOCALPI_PROVIDER_ID", "local-openai"),
         providersFile: process.env["LOCALPI_PROVIDERS_FILE"],
+        modelProfileFile: process.env["LOCALPI_MODEL_PROFILE"] ?? process.env["LOCALPAGER_AGENT_PROFILE"],
+        modelReasoning: envOptionalBoolean("LOCALPI_MODEL_REASONING", "LOCALPAGER_AGENT_REASONING"),
+        modelThinkingFormat: envOptionalThinkingFormat("LOCALPI_MODEL_THINKING_FORMAT", "LOCALPAGER_AGENT_THINKING_FORMAT"),
         stateDir,
         sessionDir: defaultSessionDir(stateDir),
         piCommand: envString("LOCALPI_PI_CMD", "npx -y @earendil-works/pi-coding-agent@latest"),
-        thinking: parseThinkingLevel(envString("LOCALPI_THINKING", "off")),
+        thinking: parseThinkingLevel(envString("LOCALPI_THINKING", "medium")),
         contextWindow: envOptionalPositiveInteger("LOCALPI_CONTEXT_WINDOW"),
         maxTokens: envPositiveInteger("LOCALPI_MAX_TOKENS", "8192"),
         timeoutMs: envPositiveInteger("LOCALPI_TIMEOUT_MS", "3000"),
@@ -34,6 +37,12 @@ export function defaultOptions() {
         tools: envString("LOCALPI_TOOLS", "read,bash,edit,write,grep,find,ls"),
         approval: envBoolean("LOCALPI_APPROVAL", true),
         tokenStatus: envBoolean("LOCALPI_TOKEN_STATUS", true),
+        demo: envBoolean("LOCALPI_DEMO", false),
+        demoFromCli: false,
+        demoInitialPrompt: process.env["LOCALPI_DEMO_INITIAL_PROMPT"],
+        demoInitialPromptFile: process.env["LOCALPI_DEMO_INITIAL_PROMPT_FILE"],
+        demoFollowupPrompt: process.env["LOCALPI_DEMO_FOLLOWUP_PROMPT"],
+        demoFollowupPromptFile: process.env["LOCALPI_DEMO_FOLLOWUP_PROMPT_FILE"],
         status: false,
         stop: false,
         list: false,
@@ -43,6 +52,7 @@ export function defaultOptions() {
 export function parseLocalpiArgs(args) {
     let options = defaultOptions();
     const forwardedArgs = [];
+    const demoPromptFlags = demoPromptFlagTracker();
     for (let index = 0; index < args.length; index += 1) {
         const arg = args[index];
         if (arg === undefined) {
@@ -55,6 +65,7 @@ export function parseLocalpiArgs(args) {
         if (arg === "-h" || arg === "--help") {
             return { ...options, forwardedArgs: ["--help"] };
         }
+        trackDemoPromptFlag(demoPromptFlags, arg);
         const parsed = parseLocalpiFlag(options, args, index);
         if (parsed !== undefined) {
             options = parsed.options;
@@ -63,7 +74,7 @@ export function parseLocalpiArgs(args) {
         }
         forwardedArgs.push(arg);
     }
-    return { ...options, forwardedArgs };
+    return normalizeDemoPromptPrecedence({ ...options, forwardedArgs }, demoPromptFlags);
 }
 export function usage() {
     return `${[
@@ -89,8 +100,21 @@ export function usage() {
         "  --chat-template <path>   llama.cpp chat template file",
         "  --tools <list>           Pi tools allow list",
         "  --providers-file <path>  localpi provider registry JSON",
+        "  --model-profile <path>   local model capability profile JSON",
+        "  --model-reasoning <bool> override generated Pi reasoning capability",
+        "  --model-thinking-format <format>",
+        "                          override generated Pi thinking format",
         "  --no-approval           do not ask before tool calls",
         "  --no-token-status       do not install token status extension",
+        "  --demo                  endlessly run Pi prompts for demo mode",
+        "  --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",
         "  --status                print runtime status and exit",
         "  --stop                  stop the localpi-owned llama-server",
         "  --list                  list model aliases",
@@ -132,7 +156,8 @@ const booleanFlagUpdaters = {
     "--stop": (options) => ({ ...options, stop: true }),
     "--list": (options) => ({ ...options, list: true }),
     "--no-approval": (options) => ({ ...options, approval: false }),
-    "--no-token-status": (options) => ({ ...options, tokenStatus: false })
+    "--no-token-status": (options) => ({ ...options, tokenStatus: false }),
+    "--demo": (options) => ({ ...options, demo: true, demoFromCli: true })
 };
 const valueFlagUpdaters = {
     "--runtime": (options, value) => ({ ...options, runtime: parseRuntime(value) }),
@@ -141,6 +166,12 @@ const valueFlagUpdaters = {
     "--provider": (options, value) => ({ ...options, provider: value }),
     "--provider-id": (options, value) => ({ ...options, customProviderId: value }),
     "--providers-file": (options, value) => ({ ...options, providersFile: value }),
+    "--model-profile": (options, value) => ({ ...options, modelProfileFile: value }),
+    "--model-reasoning": (options, value) => ({ ...options, modelReasoning: parseBoolean(value) }),
+    "--model-thinking-format": (options, value) => ({
+        ...options,
+        modelThinkingFormat: parseModelThinkingFormat(value)
+    }),
     "--state-dir": (options, value) => ({ ...options, stateDir: value }),
     "--session-dir": (options, value) => ({ ...options, sessionDir: value }),
     "--pi-command": (options, value) => ({ ...options, piCommand: value }),
@@ -159,7 +190,17 @@ const valueFlagUpdaters = {
     "--gpu-layers": (options, value) => ({ ...options, gpuLayers: parseNonNegativeInteger(value) }),
     "--parallel": (options, value) => ({ ...options, parallel: parsePositiveInteger(value) }),
     "--chat-template": (options, value) => ({ ...options, chatTemplate: value }),
-    "--tools": (options, value) => ({ ...options, tools: value })
+    "--tools": (options, value) => ({ ...options, tools: value }),
+    "--demo-initial-prompt": (options, value) => ({ ...options, demoInitialPrompt: value }),
+    "--demo-followup-prompt": (options, value) => ({ ...options, demoFollowupPrompt: value }),
+    "--demo-initial-prompt-file": (options, value) => ({
+        ...options,
+        demoInitialPromptFile: value
+    }),
+    "--demo-followup-prompt-file": (options, value) => ({
+        ...options,
+        demoFollowupPromptFile: value
+    })
 };
 function parseValueFlag(options, args, index, flag) {
     const updater = valueFlagUpdaters[flag];
@@ -168,6 +209,37 @@ function parseValueFlag(options, args, index, flag) {
     }
     return { options: updater(options, requiredValue(args, index + 1, flag)), advance: 1 };
 }
+function demoPromptFlagTracker() {
+    return {
+        initialText: false,
+        initialFile: false,
+        followupText: false,
+        followupFile: false
+    };
+}
+function trackDemoPromptFlag(tracker, arg) {
+    switch (arg) {
+        case "--demo-initial-prompt":
+            tracker.initialText = true;
+            return;
+        case "--demo-initial-prompt-file":
+            tracker.initialFile = true;
+            return;
+        case "--demo-followup-prompt":
+            tracker.followupText = true;
+            return;
+        case "--demo-followup-prompt-file":
+            tracker.followupFile = true;
+            return;
+    }
+}
+function normalizeDemoPromptPrecedence(options, tracker) {
+    return {
+        ...options,
+        demoInitialPromptFile: tracker.initialText && !tracker.initialFile ? undefined : options.demoInitialPromptFile,
+        demoFollowupPromptFile: tracker.followupText && !tracker.followupFile ? undefined : options.demoFollowupPromptFile
+    };
+}
 function parseRuntime(value) {
     if (value === "auto" ||
         value === "llama-server" ||
@@ -186,6 +258,12 @@ export function parseThinkingLevel(value) {
     }
     throw new Error(`unknown thinking level ${value}; expected off, minimal, low, medium, high, or xhigh`);
 }
+function parseModelThinkingFormat(value) {
+    if (value === "deepseek" || value === "qwen-chat-template") {
+        return value;
+    }
+    throw new Error(`unknown model thinking format ${value}; expected deepseek or qwen-chat-template`);
+}
 function envString(name, fallback) {
     return process.env[name] ?? fallback;
 }
@@ -203,11 +281,22 @@ function envOptionalPositiveInteger(name) {
     const value = process.env[name];
     return value === undefined ? undefined : parsePositiveInteger(value);
 }
+function envOptionalBoolean(primaryName, fallbackName) {
+    const [name, value] = envFirst([primaryName, fallbackName]);
+    return value === undefined ? undefined : parseBoolean(value, name);
+}
+function envOptionalThinkingFormat(primaryName, fallbackName) {
+    const [, value] = envFirst([primaryName, fallbackName]);
+    return value === undefined ? undefined : parseModelThinkingFormat(value);
+}
 function envBoolean(name, fallback) {
     const value = process.env[name];
     if (value === undefined) {
         return fallback;
     }
+    return parseBoolean(value, name);
+}
+function parseBoolean(value, name = "value") {
     if (["1", "true", "yes", "on"].includes(value.toLowerCase())) {
         return true;
     }
@@ -216,6 +305,15 @@ function envBoolean(name, fallback) {
     }
     throw new Error(`${name} must be boolean-like, got ${value}`);
 }
+function envFirst(names) {
+    for (const name of names) {
+        const value = process.env[name];
+        if (value !== undefined) {
+            return [name, value];
+        }
+    }
+    return [names[0] ?? "", undefined];
+}
 function defaultSessionDir(stateDir) {
     return envString("LOCALPI_SESSION_DIR", envString("PI_CODING_AGENT_SESSION_DIR", path.join(stateDir, "sessions")));
 }

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

@@ -1,4 +1,4 @@
-import { managedModelSupportsReasoning } from "./catalog.js";
+import { formatCatalogWarning, managedCapabilityConfig } from "./catalog.js";
 export function connectionStatus(connection) {
     return ([
         `runtime: ${connection.runtime}`,
@@ -25,7 +25,7 @@ export function catalogRuntimeConnection(options, selected, catalog) {
         model: selected.modelId,
         availableModels: providerModels.map((model) => model.modelId),
         catalogModels: catalog.models.filter((model) => model.availability === "loaded"),
-        warnings: catalog.warnings,
+        warnings: catalog.warnings.map(formatCatalogWarning),
         ...optionalContextWindow(options.contextWindow ?? selected.contextWindow)
     };
 }
@@ -39,9 +39,7 @@ export function catalogModelFromModelInfo(providerId, providerName, runtime, bas
         aliases: [],
         displayName: `${providerName} / ${model.id}`,
         maxTokens: options.maxTokens,
-        ...(runtime === "managed-llama-server"
-            ? { reasoning: managedModelSupportsReasoning(model.id) }
-            : {}),
+        ...(runtime === "managed-llama-server" ? managedCapabilityConfig(model.id, options) : {}),
         capabilities: ["text"],
         availability: "loaded",
         ...optionalContextWindow(contextWindow ?? model.contextWindow)

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

@@ -16,7 +16,7 @@ export async function selectCatalogModel(options, catalog) {
     if (selection.model !== "auto") {
         return selectExplicitCatalogModel(options, providerFiltered, selection.provider, selection.model);
     }
-    return selectAutomaticCatalogModel(providerFiltered, catalog.warnings);
+    return selectAutomaticCatalogModel(providerFiltered, warningsForProvider(catalog.warnings, selection.provider));
 }
 async function selectExplicitCatalogModel(options, models, provider, requested) {
     const matches = matchingCatalogModels(models, requested);
@@ -39,11 +39,11 @@ function selectAutomaticCatalogModel(models, warnings) {
     if (onlyLoaded !== undefined) {
         return onlyLoaded;
     }
-    const fallback = startableFallback(models);
+    const fallback = startableFallback(models, warnings);
     if (fallback !== undefined) {
         return fallback;
     }
-    throw new Error(`no loaded models available${warnings.length === 0 ? "" : `; ${warnings.join("; ")}`}`);
+    throw new Error(noLoadedModelsMessage(models, warnings));
 }
 function modelsForProvider(models, provider) {
     return provider === undefined ? models : models.filter((model) => model.providerId === provider);
@@ -69,7 +69,73 @@ function matchingCatalogModels(models, requested) {
 function isGgufFilePathRequest(value) {
     return value.toLowerCase().endsWith(".gguf") || value.includes("\\");
 }
-function startableFallback(models) {
-    const startable = models.filter((model) => model.availability === "startable");
+function startableFallback(models, warnings) {
+    const startable = models.filter((model) => model.availability === "startable" &&
+        (model.runtime !== "managed-llama-server" || managedLlamaFallbackAvailable(warnings)));
     return (startable.find((model) => model.aliases.includes(defaultLlamaModelName()) || model.modelId === defaultLlamaModelName()) ?? startable[0]);
 }
+function managedLlamaFallbackAvailable(warnings) {
+    return !warnings.some((warning) => warning.providerId === "llama-server" && warning.code === "managed-command-unavailable");
+}
+function noLoadedModelsMessage(models, warnings) {
+    const sections = engineSections(models, warnings);
+    if (sections.length === 0) {
+        return "no loaded models available\n\nTried engines:\n\n- none reported usable models";
+    }
+    return [
+        "no loaded models available",
+        "",
+        "Tried engines:",
+        "",
+        sections.map(formatEngineSection).join("\n\n")
+    ].join("\n");
+}
+function engineSections(models, warnings) {
+    const sections = new Map();
+    for (const model of models) {
+        const section = ensureEngineSection(sections, model.providerId, model.providerName);
+        const entry = `${model.providerId}/${model.modelId}`;
+        const updated = model.availability === "loaded"
+            ? { ...section, loaded: [...section.loaded, entry] }
+            : { ...section, startable: [...section.startable, entry] };
+        sections.set(model.providerId, updated);
+    }
+    for (const warning of warnings) {
+        const section = ensureEngineSection(sections, warning.providerId, warning.providerName);
+        sections.set(warning.providerId, {
+            ...section,
+            warnings: [...section.warnings, warning.message]
+        });
+    }
+    return [...sections.values()];
+}
+function ensureEngineSection(sections, key, title) {
+    const existing = sections.get(key);
+    if (existing !== undefined) {
+        return existing;
+    }
+    const section = { title, loaded: [], startable: [], warnings: [] };
+    sections.set(key, section);
+    return section;
+}
+function formatEngineSection(section) {
+    const lines = [`${section.title}:`];
+    if (section.loaded.length === 0) {
+        lines.push("- loaded models: none");
+    }
+    else {
+        lines.push(`- loaded models: ${section.loaded.join(", ")}`);
+    }
+    if (section.startable.length > 0) {
+        lines.push(`- startable models: ${section.startable.join(", ")}`);
+    }
+    for (const warning of section.warnings) {
+        lines.push(`- ${warning}`);
+    }
+    return lines.join("\n");
+}
+function warningsForProvider(warnings, provider) {
+    return provider === undefined
+        ? warnings
+        : warnings.filter((warning) => warning.providerId === provider);
+}

package/dist/src/localpi/runtime.js

@@ -1,4 +1,4 @@
-import { discoverModelCatalog } from "./catalog.js";
+import { discoverModelCatalog, formatCatalogWarning } from "./catalog.js";
 import { llamaBaseUrl, llamaServerStatus, stopManagedLlamaServer } from "./llama-server.js";
 import { listModelAliases } from "./models.js";
 import { catalogRuntimeConnection, connectionStatus, statusModelList } from "./runtime-connection.js";
@@ -75,7 +75,7 @@ async function catalogStatusOutput(options) {
         `runtime: ${options.runtime}`,
         `loaded models: ${statusModelList(loaded)}`,
         `startable models: ${statusModelList(startable)}`,
-        ...catalog.warnings.map((warning) => `warning: ${warning}`)
+        ...catalog.warnings.map((warning) => `warning: ${formatCatalogWarning(warning)}`)
     ].join("\n") + "\n");
 }
 function requiredOpenAiBaseUrl(options) {

package/dist/src/localpi/settings-state.js

@@ -0,0 +1,37 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { asObject, optionalString } from "../common/json.js";
+import { parseThinkingLevel } from "./options.js";
+export function settingsStatePath(options) {
+    return path.join(options.stateDir, "settings.json");
+}
+export async function applyRememberedSettings(options, explicit) {
+    const settings = await readLocalpiSettings(options);
+    return {
+        ...options,
+        thinking: explicit.thinking || settings.thinking === undefined ? options.thinking : settings.thinking
+    };
+}
+async function readLocalpiSettings(options) {
+    let raw;
+    try {
+        raw = await readFile(settingsStatePath(options), "utf8");
+    }
+    catch (error) {
+        if (isMissingFile(error)) {
+            return {};
+        }
+        throw error;
+    }
+    try {
+        const root = asObject(JSON.parse(raw), "localpi settings");
+        const thinking = optionalString(root["thinking"]);
+        return thinking === undefined ? {} : { thinking: parseThinkingLevel(thinking) };
+    }
+    catch {
+        return {};
+    }
+}
+function isMissingFile(error) {
+    return (error instanceof Error && "code" in error && error.code === "ENOENT");
+}

package/dist/src/pi/demo.js

@@ -0,0 +1,12 @@
+import { readFile } from "node:fs/promises";
+export const defaultDemoInitialPrompt = "You are narrating a never-ending sci-fi adventure. Continue in short paragraphs. Whenever the user sends a message, treat it as a live director note and incorporate it immediately. Never end the story.";
+export const defaultDemoFollowupPrompt = "Continue. Try to write as long as possible.";
+export async function resolveDemoPrompts(options) {
+    return {
+        initial: await resolvePrompt(options.demoInitialPrompt, options.demoInitialPromptFile, defaultDemoInitialPrompt),
+        followup: await resolvePrompt(options.demoFollowupPrompt, options.demoFollowupPromptFile, defaultDemoFollowupPrompt)
+    };
+}
+async function resolvePrompt(text, file, fallback) {
+    return file === undefined ? (text ?? fallback) : await readFile(file, "utf8");
+}