pi-llamacpp-infra 1.2.4 → 1.2.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-llamacpp-infra",
-  "version": "1.2.4",
+  "version": "1.2.5",
   "description": "Discovery, metrics and control of llama.cpp-family servers for pi (llama.cpp, ZINC, DwarfStar/ds4, lucebox, LM Studio): scan machines (localhost, LAN, Tailscale), register models, live metrics, per-model thinking budgets, vision detection, native config UI.",
   "keywords": [
     "pi-package",

package/src/core.ts

@@ -17,6 +17,7 @@ import type {
 export const PROVIDER_NAME = "llamacpp-infra";
 export const STATUS_KEY = "llamacpp-infra";
 export const CONFIG_FILE = "llamacpp-infra.json";
+export const MODELS_CACHE_FILE = "llamacpp-infra-models.json";
 export const LEGACY_CONFIG_FILE = "local-models.json";
 export const METRICS_STATUS_KEY = "llamacpp-infra-speed";
 export const DEFAULT_API_KEY = "no-auth";
@@ -113,6 +114,130 @@ export function saveConfig(config: InfraConfig): void {
 	}
 }
 
+// ── Last-known-models cache ────────────────────────────────────────────────
+// Lets a freshly booted pi process register the provider with the models from
+// the previous scan IMMEDIATELY (synchronously, during the extension factory),
+// so CLI consumers that resolve --model at startup (e.g. trimegisto sub-agents
+// spawned as `pi -p --no-session --model provider/model`) find the model before
+// the async discovery re-scan completes. The async scan then refreshes this
+// registration with live data as usual.
+
+const MODELS_CACHE_VERSION = 1;
+
+/** JSON-safe projection of a registered PiModel (no secrets; headers re-derived). */
+interface CachedModelEntry {
+	id: string;
+	name: string;
+	baseUrl: string;
+	reasoning: boolean;
+	input: ("text" | "image")[];
+	contextWindow: number;
+	maxTokens: number;
+	serverModelId: string;
+	endpoint: import("./types.ts").PiModel["endpoint"];
+	thinkingBudgets?: import("./types.ts").ThinkingBudgets;
+	quant?: string;
+	cacheK?: string;
+	cacheV?: string;
+	drafter?: string;
+	routerStatus?: string;
+}
+
+interface ModelsCacheFile {
+	version: number;
+	savedAt: string;
+	models: CachedModelEntry[];
+}
+
+export function getModelsCachePath(): string {
+	return join(getAgentDir(), MODELS_CACHE_FILE);
+}
+
+/** Persist the last successfully registered models for fast boot on next process. */
+export function saveModelsCache(models: import("./types.ts").PiModel[]): void {
+	if (!models || models.length === 0) return;
+	try {
+		const file: ModelsCacheFile = {
+			version: MODELS_CACHE_VERSION,
+			savedAt: new Date().toISOString(),
+			models: models.map((m) => ({
+				id: m.id,
+				name: m.name,
+				baseUrl: m.baseUrl,
+				reasoning: m.reasoning,
+				input: m.input,
+				contextWindow: m.contextWindow,
+				maxTokens: m.maxTokens,
+				serverModelId: m.serverModelId,
+				endpoint: m.endpoint,
+				thinkingBudgets: m.thinkingBudgets,
+				quant: m.quant,
+				cacheK: m.cacheK,
+				cacheV: m.cacheV,
+				drafter: m.drafter,
+				routerStatus: m.routerStatus,
+			})),
+		};
+		const dir = getAgentDir();
+		if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+		writeFileSync(getModelsCachePath(), JSON.stringify(file), "utf-8");
+		debugLog(`models cache saved (${models.length} model(s))`);
+	} catch (err) {
+		console.error(`[llamacpp-infra] Models cache save error: ${err instanceof Error ? err.message : String(err)}`);
+	}
+}
+
+/** Load models cached by a previous scan, or null when absent/corrupt/empty. */
+export function loadModelsCache(): import("./types.ts").PiModel[] | null {
+	try {
+		const path = getModelsCachePath();
+		if (!existsSync(path)) return null;
+		const raw = JSON.parse(readFileSync(path, "utf-8")) as Partial<ModelsCacheFile>;
+		if (raw?.version !== MODELS_CACHE_VERSION || !Array.isArray(raw.models) || raw.models.length === 0) return null;
+		return raw.models.map((c) => ({
+			id: c.id,
+			name: c.name,
+			baseUrl: c.baseUrl,
+			reasoning: c.reasoning,
+			input: Array.isArray(c.input) && c.input.length > 0 ? c.input : (["text"] as ("text" | "image")[]),
+			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+			contextWindow: c.contextWindow,
+			maxTokens: c.maxTokens,
+			compat: makeCompat(c.endpoint?.kind),
+			serverModelId: c.serverModelId,
+			endpoint: c.endpoint,
+			thinkingBudgets: c.thinkingBudgets,
+			quant: c.quant,
+			cacheK: c.cacheK,
+			cacheV: c.cacheV,
+			drafter: c.drafter,
+			routerStatus: c.routerStatus,
+		}));
+	} catch (err) {
+		debugLog(`models cache load failed: ${err instanceof Error ? err.message : String(err)}`);
+		return null;
+	}
+}
+
+/** Rebuild the shared maps (id↔raw, baseUrls, kinds, zinc) from cached models. */
+export function applyCachedSharedState(models: import("./types.ts").PiModel[]): void {
+	shared.zincModelIds.clear();
+	shared.serverModelIds.clear();
+	shared.compactModelIds.clear();
+	shared.endpointKinds.clear();
+	shared.modelBaseUrls.clear();
+	for (const pm of models) {
+		if (pm.endpoint?.kind === "zinc") {
+			shared.zincModelIds.add(pm.id);
+			shared.zincModelIds.add(pm.serverModelId);
+		}
+		shared.serverModelIds.set(pm.id, pm.serverModelId);
+		if (!shared.compactModelIds.has(pm.serverModelId)) shared.compactModelIds.set(pm.serverModelId, pm.id);
+		shared.endpointKinds.set(pm.baseUrl, pm.endpoint?.kind ?? "unknown");
+		shared.modelBaseUrls.set(pm.id, pm.baseUrl);
+	}
+}
+
 // ── Compat profile ─────────────────────────────────────────────────────────
 export function supportsThinkingBudget(kind: ServerKind | "unknown" | "auto" | undefined): boolean {
 	return kind === "llamacpp" || kind === "lucebox";

package/src/index.ts

@@ -9,9 +9,11 @@ import {
 	PROVIDER_NAME,
 	STATUS_KEY,
 	THINKING_BUDGET_FIELD,
+	applyCachedSharedState,
 	compactIdFor,
 	debugLog,
 	loadConfig,
+	loadModelsCache,
 	modelOptions,
 	normalizeLevel,
 	rawIdFor,
@@ -127,6 +129,43 @@ export default function (pi: ExtensionAPI) {
 		providerIsEmpty = true;
 	}
 
+	// ── Boot provider registration (synchronous, cache-first) ────────────
+	// Registers models from the last known scan IMMEDIATELY when a cache exists,
+	// so this process can resolve `--model llamacpp-infra/...` at startup without
+	// waiting for the async discovery re-scan (which refreshes right after).
+	// Falls back to the empty "scanning…" provider when there is no cache.
+	function registerBootProvider() {
+		const cached = loadModelsCache();
+		if (cached && cached.length > 0) {
+			try {
+				pi.unregisterProvider(PROVIDER_NAME);
+			} catch {
+				// not registered yet
+			}
+			// Re-derive per-server auth headers (never persisted with the cache).
+			for (const m of cached) {
+				const srv = config.servers.find((s) => s.id === m.endpoint?.serverId && s.host === m.endpoint?.host);
+				if (srv?.apiKey) m.headers = { Authorization: `Bearer ${srv.apiKey}` };
+			}
+			applyCachedSharedState(cached);
+			const bootSrv = config.servers.find((s) => s.id === cached[0].endpoint?.serverId);
+			pi.registerProvider(PROVIDER_NAME, {
+				name: `🦙 llama.cpp-infra (cached ${cached.length}, rescanning…)`,
+				baseUrl: cached[0].baseUrl,
+				apiKey: bootSrv?.apiKey || "no-auth",
+				api: "openai-completions",
+				streamSimple: createLongTimeoutOpenAICompletionsStream,
+				models: cached,
+			});
+			providerIsEmpty = false;
+			shared.registeredCount = cached.length;
+			shared.lastModels = cached;
+			debugLog(`boot: registered ${cached.length} cached model(s); async rescan will refresh`);
+			return;
+		}
+		registerEmptyProvider();
+	}
+
 	async function discoverAndRegister(): Promise<{ scan: import("./types.ts").ScanResult; shouldPoll: boolean }> {
 		try {
 			if (!extensionActive) {
@@ -474,7 +513,7 @@ export default function (pi: ExtensionAPI) {
 	});
 
 	// ── Initial non-blocking registration ─────────────────────────────────
-	registerEmptyProvider();
+	registerBootProvider();
 	void discoverAndRegister()
 		.then((r) => {
 			if (extensionActive) schedulePolling(r.shouldPoll);

package/src/registration.ts

@@ -9,6 +9,7 @@ import {
 	makeCompat,
 	modelOptions,
 	saveConfig,
+	saveModelsCache,
 	shared,
 } from "./core.ts";
 import type { ExtensionAPI } from "./types.ts";
@@ -128,7 +129,12 @@ function toPiModel(
  * Build pi models from a scan and (re)register the provider.
  * Returns the registered model list.
  */
-export function buildAndRegisterProvider(pi: ExtensionAPI, scan: ScanResult, config: InfraConfig): PiModel[] {
+export function buildAndRegisterProvider(
+	pi: ExtensionAPI,
+	scan: ScanResult,
+	config: InfraConfig,
+	options?: { persistCache?: boolean },
+): PiModel[] {
 	shared.zincModelIds.clear();
 	shared.serverModelIds.clear();
 	shared.compactModelIds.clear();
@@ -237,5 +243,11 @@ export function buildAndRegisterProvider(pi: ExtensionAPI, scan: ScanResult, con
 		models: piModels,
 	});
 
+	// Persist the last known good models so a fresh pi process can register them
+	// synchronously at boot (before async discovery completes) — required for CLI
+	// consumers that resolve --model right after startup (e.g. trimegisto spawns).
+	// Tests opt out so they never touch the real per-user cache.
+	if (piModels.length > 0 && options?.persistCache !== false) saveModelsCache(piModels);
+
 	return piModels;
 }