@caupulican/pi-adaptative 0.81.38 → 0.81.40

package/dist/modes/interactive/local-model-commands.js

@@ -10,6 +10,7 @@
  * fitness-role-assignment), which keep exercising interactive-mode's thin
  * wrappers unchanged.
  */
+import { existsSync, rmSync } from "node:fs";
 import { totalmem } from "node:os";
 import { getSupportedThinkingLevels } from "@caupulican/pi-ai";
 import { Container, SelectList, Spacer, Text, } from "@caupulican/pi-tui";
@@ -19,8 +20,11 @@ import { evaluateSurfaceFitness } from "../../core/model-router/fitness-gate.js"
 import { deriveLocalContextSizing, renderOllamaContextModelfile, sizedLocalModelRef, } from "../../core/models/context-sizing.js";
 import { DEFAULT_MODEL_SUGGESTIONS } from "../../core/models/default-model-suggestions.js";
 import { FitnessStore } from "../../core/models/fitness-store.js";
-import { HF_TRANSFORMERS_PROVIDER, registerLocalModel, registerTransformersModel, unregisterLocalModel, unregisterTransformersModel, } from "../../core/models/local-registration.js";
+import { PrismLlamaCppRuntime } from "../../core/models/llamacpp-runtime.js";
+import { HF_TRANSFORMERS_PROVIDER, PRISM_LLAMACPP_PROVIDER, registerLocalModel, registerPrismLlamaCppModel, registerTransformersModel, unregisterLocalModel, unregisterPrismLlamaCppModel, unregisterTransformersModel, } from "../../core/models/local-registration.js";
 import { matchesInstalledLocalModel, normalizeModelSource } from "../../core/models/model-ref.js";
+import { NeedleRuntime } from "../../core/models/needle-runtime.js";
+import { derivePrismLlamaCppNumCtx, ensurePrismModelFilesThenServe, isPiManagedPrismLlamaCppModel, PRISM_LLAMACPP_DESCRIPTORS, PRISM_LLAMACPP_SERVE_PORT, } from "../../core/models/prism-llamacpp-lifecycle.js";
 import { formatModelFitnessReport, isProbeAllFailed } from "../../core/research/model-fitness.js";
 import { DynamicBorder } from "./components/dynamic-border.js";
 import { FitnessRoleSelectorComponent } from "./components/fitness-role-selector.js";
@@ -51,6 +55,25 @@ const MODEL_ROUTER_THINKING_FALLBACK_LEVELS = [
     "high",
     "xhigh",
 ];
+function getPrismLlamaCppRuntime(host) {
+    return host.getPrismLlamaCppRuntime?.() ?? new PrismLlamaCppRuntime({ agentDir: getAgentDir() });
+}
+function getNeedleRuntime(host) {
+    return host.getNeedleRuntime?.() ?? new NeedleRuntime({ agentDir: getAgentDir() });
+}
+/**
+ * Mirrors needle-runtime.ts's own (module-private, not exported) NEEDLE_SMOKE_TOOLS — the default
+ * tool set for `/models needle <query>` when no tools-json is supplied, so an ad-hoc probe has the
+ * same sensible starting point the install pipeline's own smoke test already exercises. Kept in
+ * sync manually since the source constant isn't exported from the frozen runtime module.
+ */
+const NEEDLE_DEFAULT_TOOLS = [
+    {
+        name: "get_weather",
+        description: "Get current weather for a city.",
+        parameters: { location: { type: "string", description: "City name.", required: true } },
+    },
+];
 class ModelRouterThinkingSelectorComponent extends Container {
     selectList;
     constructor(currentLevel, availableLevels, onSelect, onCancel) {
@@ -105,9 +128,17 @@ export async function handleModelsCommand(host, argsText) {
                 if (host.getTransformersRuntime(model.id, serverUrl).stop().stopped)
                     stoppedTransformers++;
             }
-            const stoppedAny = stopped.stopped || stoppedTransformers > 0;
+            // Only touch the prism runtime when a pi-managed prism model is actually registered —
+            // never construct/stop it on a session that never used one. isPiManagedPrismLlamaCppModel
+            // is the SAME discriminator the readiness gate uses, so this never reaches for a user's own
+            // hand-configured llama-cpp entry (e.g. the built-in llama-cpp/local catalog model).
+            const hasPiManagedPrismModel = host.session.modelRegistry
+                .getAll()
+                .some((entry) => isPiManagedPrismLlamaCppModel(entry));
+            const stoppedPrism = hasPiManagedPrismModel && getPrismLlamaCppRuntime(host).stop().stopped;
+            const stoppedAny = stopped.stopped || stoppedTransformers > 0 || stoppedPrism;
             host.showStatus(stoppedAny
-                ? `Pi-managed local model server stopped${stoppedTransformers > 0 ? ` (${stoppedTransformers} Transformers sidecar(s))` : ""}; models remain installed.`
+                ? `Pi-managed local model server stopped${stoppedTransformers > 0 ? ` (${stoppedTransformers} Transformers sidecar(s))` : ""}${stoppedPrism ? " (prism llama.cpp server)" : ""}; models remain installed.`
                 : "No pi-managed server running (a system server, if any, is not pi's to stop).");
             return;
         }
@@ -118,6 +149,15 @@ export async function handleModelsCommand(host, argsText) {
                 `${imported.blobsCopied} blob(s) copied, ${imported.blobsSkipped + imported.manifestsSkipped} existing file(s) skipped.`);
             return;
         }
+        if (action === "needle") {
+            if (rest.length === 0) {
+                host.showStatus("Usage: /models needle <query> [tools-json]");
+                host.showStatus(`  tools-json defaults to the smoke-test tool set: ${JSON.stringify(NEEDLE_DEFAULT_TOOLS)}`);
+                return;
+            }
+            await runNeedleQuery(host, rest);
+            return;
+        }
         if (action === "add") {
             const rawRef = rest.join(" ");
             if (!rawRef) {
@@ -138,6 +178,19 @@ export async function handleModelsCommand(host, argsText) {
                 await addTransformersModel(host, source.modelId);
                 return;
             }
+            if (source.type === "prism-llamacpp") {
+                const descriptor = PRISM_LLAMACPP_DESCRIPTORS[source.modelId];
+                if (!descriptor) {
+                    host.showStatus(`${source.modelId} has no curated prism llama.cpp descriptor — this is a wiring bug.`);
+                    return;
+                }
+                await addPrismLlamaCppModel(host, descriptor);
+                return;
+            }
+            if (source.type === "needle") {
+                await addNeedleModel(host);
+                return;
+            }
             await addLocalModel(host, source.pullRef);
             return;
         }
@@ -153,6 +206,14 @@ export async function handleModelsCommand(host, argsText) {
                 await removeTransformersModel(host, source.modelId, confirmed);
                 return;
             }
+            if (source.type === "prism-llamacpp") {
+                await removePrismLlamaCppModel(host, source.modelId, confirmed);
+                return;
+            }
+            if (source.type === "needle") {
+                await removeNeedleModel(host, confirmed);
+                return;
+            }
             await removeLocalModel(host, ref, confirmed);
             return;
         }
@@ -342,6 +403,60 @@ export async function addTransformersModel(host, modelId, preselectRole) {
     host.showStatus(`${modelId} installed in pi-managed Transformers and registered as ${HF_TRANSFORMERS_PROVIDER}/${modelId}. Probing fitness…`);
     await runFitnessAndAssign(host, `${HF_TRANSFORMERS_PROVIDER}/${modelId}`, preselectRole);
 }
+/**
+ * Zero-setup pipeline for a curated prism llama.cpp model (Bonsai-27B): install the pinned prism
+ * llama.cpp runtime (prebuilt release download, no compiler needed), ensure both GGUF files and
+ * start llama-server (see `ensurePrismModelFilesThenServe`), register the model, then probe
+ * fitness. Mirrors addTransformersModel's shape — each stage checks its own `{ ok }`/
+ * `{ runtimeInstalled }` result and stops with an honest status message on failure; nothing
+ * continues past a failed stage.
+ */
+export async function addPrismLlamaCppModel(host, descriptor, preselectRole) {
+    const runtime = getPrismLlamaCppRuntime(host);
+    const modelId = descriptor.repo;
+    let status = await runtime.detect();
+    if (!status.runtimeInstalled) {
+        host.showStatus(`Installing prism llama.cpp runtime for ${descriptor.displayName} at ${runtime.runtimeDir()}…`);
+        const installed = await runtime.installManaged((progress) => host.showStatus(`  prism-llamacpp: ${progress}`));
+        if (!installed.ok) {
+            host.showStatus(`Prism llama.cpp runtime install failed: ${installed.error}`);
+            return;
+        }
+        status = await runtime.detect();
+    }
+    if (!status.runtimeInstalled) {
+        host.showStatus(`Prism llama.cpp runtime is still unavailable at ${runtime.runtimeDir()}.`);
+        return;
+    }
+    const numCtx = derivePrismLlamaCppNumCtx(totalmem());
+    const served = await ensurePrismModelFilesThenServe(runtime, descriptor, { port: PRISM_LLAMACPP_SERVE_PORT, numCtx }, (message) => host.showStatus(message));
+    if (!served.ok) {
+        const label = served.stage === "model-download"
+            ? "Model download failed"
+            : served.stage === "mmproj-download"
+                ? "Vision projector download failed"
+                : "Could not start llama-server";
+        host.showStatus(`${label}: ${served.error}`);
+        return;
+    }
+    const registration = registerPrismLlamaCppModel({
+        agentDir: getAgentDir(),
+        modelId,
+        baseUrl: served.baseUrl,
+        contextWindow: numCtx,
+        servedContextWindow: numCtx,
+    });
+    if (!registration.ok) {
+        host.showStatus(`Served, but not auto-registered: ${registration.reason}`);
+        if (registration.manualSnippet) {
+            host.showStatus(`Add this to ${registration.modelsJsonPath} yourself:\n${registration.manualSnippet}`);
+        }
+        return;
+    }
+    host.session.modelRegistry.refresh();
+    host.showStatus(`${descriptor.displayName} installed and registered as ${PRISM_LLAMACPP_PROVIDER}/${modelId}. Probing fitness…`);
+    await runFitnessAndAssign(host, `${PRISM_LLAMACPP_PROVIDER}/${modelId}`, preselectRole);
+}
 export async function removeLocalModel(host, ref, confirmed) {
     const status = await host.localRuntime.detect();
     if (!status.serverUp) {
@@ -399,6 +514,165 @@ async function removeTransformersModel(host, modelId, confirmed) {
     host.session.modelRegistry.refresh();
     host.showStatus(`${modelId} registration and fitness report dropped; cached weights remain under ${status.cacheDir}.`);
 }
+/**
+ * Drop a pi-managed prism llama.cpp model's registration and fitness report. Production supplies a
+ * session-cached runtime (see `LocalModelHost.getPrismLlamaCppRuntime`'s doc comment), the SAME
+ * instance the readiness gate uses, so `stop()` here reliably reaches the tracked child whenever
+ * THIS session is the one that started it — including a server started earlier in the session by
+ * the readiness gate itself, not just by a prior `/models add`. Only a server started by a
+ * DIFFERENT process/session (pi restarted, a different terminal) is out of reach; the status text
+ * only carries that caveat, not a blanket "may not stop" disclaimer.
+ */
+async function removePrismLlamaCppModel(host, modelId, confirmed) {
+    const runtime = getPrismLlamaCppRuntime(host);
+    if (!confirmed) {
+        host.showStatus([
+            `Removing ${modelId} will delete:`,
+            `  - the ${PRISM_LLAMACPP_PROVIDER}/${modelId} entry in models.json`,
+            `  - its cached fitness report for this host`,
+            `Downloaded GGUF weights remain under ${runtime.modelsDir()}. Its llama-server will be stopped if ` +
+                `this session started it; if it was started by a different pi process or session, it will keep ` +
+                `serving on 127.0.0.1:${PRISM_LLAMACPP_SERVE_PORT} until stopped manually.`,
+            `Run: /models remove hf.co/${modelId} confirm`,
+        ].join("\n"));
+        return;
+    }
+    const stopped = runtime.stop();
+    const registration = unregisterPrismLlamaCppModel({ agentDir: getAgentDir(), modelId });
+    if (!registration.ok) {
+        host.showStatus(`Remove failed: ${registration.reason}`);
+        return;
+    }
+    FitnessStore.forAgentDir(getAgentDir()).remove(`${PRISM_LLAMACPP_PROVIDER}/${modelId}`);
+    host.session.modelRegistry.refresh();
+    host.showStatus(`${modelId} registration and fitness report dropped; downloaded weights remain under ${runtime.modelsDir()}.` +
+        (stopped.stopped
+            ? " Its llama-server was stopped."
+            : ` No llama-server tracked by this session — if one is still running (started by a different pi process or session), stop it manually on port ${PRISM_LLAMACPP_SERVE_PORT}.`));
+}
+/**
+ * Zero-setup pipeline for needle (see needle-runtime.ts): a standalone 26M-parameter function-call
+ * test bench, NOT a chat/executor/lane model — no OpenAI-compatible endpoint, no models.json
+ * registration, no /fitness probe. Install the pinned needle clone+venv (menu pick = consent, same
+ * doctrine as the Transformers/prism precedents), download and sha256-verify the pickle checkpoint
+ * (never called implicitly by installManaged — see the module's SECURITY note: the checkpoint is a
+ * pickle file, arbitrary code execution on load by construction, so this is deliberately a separate
+ * consent-adjacent step, not folded into install), then run its own smoke test as the honest
+ * post-install verification. Each stage checks its own `{ ok }` result and stops with a stage-tagged
+ * status on failure; nothing continues past a failed stage.
+ */
+export async function addNeedleModel(host) {
+    const runtime = getNeedleRuntime(host);
+    let status = await runtime.detect();
+    if (!status.installed) {
+        host.showStatus(`Installing needle (function-call test bench) at ${runtime.runtimeDir()}…`);
+        const installed = await runtime.installManaged((progress) => host.showStatus(`  needle: ${progress}`));
+        if (!installed.ok) {
+            host.showStatus(`needle install failed: ${installed.error}`);
+            return;
+        }
+        status = await runtime.detect();
+    }
+    if (!status.installed) {
+        host.showStatus(`needle is still unavailable at ${runtime.runtimeDir()}.`);
+        return;
+    }
+    const downloaded = await runtime.downloadWeights((progress) => host.showStatus(`  ${progress}`));
+    if (!downloaded.ok) {
+        host.showStatus(`needle weights download failed: ${downloaded.error}`);
+        return;
+    }
+    host.showStatus("Running needle smoke test (function-call probe)…");
+    const smoke = await runtime.smokeTest();
+    if (!smoke.ok || !smoke.call) {
+        host.showStatus(`needle smoke test failed: ${smoke.error ?? "smoke test reported success but returned no parsed call"}`);
+        return;
+    }
+    host.showStatus(`needle installed and verified: smoke test called ${smoke.call.name}(${JSON.stringify(smoke.call.arguments)}) ` +
+        `in ${smoke.latencyMs}ms. Use /models needle <query> [tools-json] to test it further — it is a standalone ` +
+        "bench, not a chat/executor lane.");
+}
+/**
+ * Wipe pi's needle runtime (clone+venv) and downloaded checkpoint. Unlike the other /models remove
+ * flows, there is no models.json entry or fitness report to drop (needle never registers as a model
+ * — see the roster entry's rationale) and no server process to stop (every needle invocation is a
+ * one-shot runCommand call — see needle-runtime.ts's `dispose()` doc comment); removal is purely
+ * deleting the two pi-owned directories. needle-runtime.ts exposes no delete method of its own (its
+ * public surface is detect/installManaged/downloadWeights/runFunctionCall/smokeTest/dispose), so
+ * this deletes directly via the runtime's own path-derivation methods.
+ */
+async function removeNeedleModel(host, confirmed) {
+    const runtime = getNeedleRuntime(host);
+    const runtimeDir = runtime.runtimeDir();
+    const modelsDir = runtime.modelsDir();
+    if (!confirmed) {
+        host.showStatus([
+            "Removing needle will delete:",
+            `  - the pi-managed needle runtime (clone + venv) at ${runtimeDir}`,
+            `  - the downloaded checkpoint at ${runtime.checkpointPath()}`,
+            "needle has no models.json entry or fitness report — it is a standalone function-call test bench, " +
+                "never registered as a chat/lane model.",
+            "Run: /models remove hf.co/Cactus-Compute/needle confirm",
+        ].join("\n"));
+        return;
+    }
+    if (existsSync(runtimeDir))
+        rmSync(runtimeDir, { recursive: true, force: true });
+    if (existsSync(modelsDir))
+        rmSync(modelsDir, { recursive: true, force: true });
+    host.showStatus(`needle removed: deleted ${runtimeDir} and ${modelsDir}.`);
+}
+/**
+ * `/models needle <query> [tools-json]` — the actual test surface for needle (see the roster
+ * entry's rationale: there is no chat lane to probe it through). `tools-json`, when present, must be
+ * the LAST whitespace-split token and start with `[`/`{` (compact JSON, no embedded spaces) —
+ * anything else is treated as part of the query and the default smoke-test tool set is used. A fast
+ * `detect()`-based pre-check gives friendly install guidance without spawning a doomed process;
+ * `runFunctionCall`'s own not-installed/checkpoint-missing pre-flight is still the final honest
+ * backstop if state changes between the check and the call.
+ */
+async function runNeedleQuery(host, args) {
+    if (args.length === 0) {
+        host.showStatus("Usage: /models needle <query> [tools-json]");
+        return;
+    }
+    const runtime = getNeedleRuntime(host);
+    const status = await runtime.detect();
+    if (!status.installed) {
+        host.showStatus("needle is not installed. Run /models add hf.co/Cactus-Compute/needle first (or /models suggest).");
+        return;
+    }
+    if (!status.checkpointPresent) {
+        host.showStatus("needle is installed but its checkpoint hasn't been downloaded. Run /models add hf.co/Cactus-Compute/needle to fetch and verify it.");
+        return;
+    }
+    let tools = NEEDLE_DEFAULT_TOOLS;
+    let toolsJsonParsed = false;
+    const last = args[args.length - 1];
+    if (last && (last.startsWith("[") || last.startsWith("{"))) {
+        try {
+            tools = JSON.parse(last);
+            toolsJsonParsed = true;
+        }
+        catch {
+            // Not valid JSON — treat the whole thing as the query, keep the default tools.
+        }
+    }
+    const query = (toolsJsonParsed ? args.slice(0, -1) : args).join(" ");
+    if (!query.trim()) {
+        host.showStatus("Usage: /models needle <query> [tools-json]");
+        return;
+    }
+    host.showStatus(`needle: running "${query}"…`);
+    const startedAt = Date.now();
+    const result = await runtime.runFunctionCall({ query, tools });
+    const latencyMs = Date.now() - startedAt;
+    if (!result.ok) {
+        host.showStatus(`needle call failed (${latencyMs}ms): ${result.error}\nraw output:\n${result.rawOutput}`);
+        return;
+    }
+    host.showStatus(`needle (${latencyMs}ms): ${result.call.name}(${JSON.stringify(result.call.arguments)})`);
+}
 /** /fitness with no args: pick a model from the configured registry, probe it, assign a role. */
 /** Pick a validated suggestion → install it → probe on this host → land its shaped role. */
 export function showModelSuggestionSelector(host) {
@@ -412,6 +686,19 @@ export function showModelSuggestionSelector(host) {
                 await addTransformersModel(host, source.modelId, suggestion.assignRole);
                 return;
             }
+            if (source.type === "prism-llamacpp") {
+                const descriptor = PRISM_LLAMACPP_DESCRIPTORS[source.modelId];
+                if (!descriptor) {
+                    host.showStatus(`Suggestion ${suggestion.name} maps to an unknown curated prism model "${source.modelId}" — wiring bug.`);
+                    return;
+                }
+                await addPrismLlamaCppModel(host, descriptor, suggestion.assignRole);
+                return;
+            }
+            if (source.type === "needle") {
+                await addNeedleModel(host);
+                return;
+            }
             if (source.type === "local") {
                 await addLocalModel(host, source.pullRef, suggestion.assignRole);
                 return;