pi-llamacpp-infra 1.0.0 → 1.2.0

package/README.md

@@ -1,6 +1,6 @@
-# llamacpp-infra — Discovery, Metrics & Control for llama.cpp Servers
+# llamacpp-infra — Discovery, Metrics & Control for llama.cpp-family Servers
 
-**llamacpp-infra** turns pi into a first-class citizen of local llama.cpp infrastructure. It probes any number of machines — localhost, LAN or Tailscale — discovers every model served by llama.cpp and its variants, registers them into pi's native `/model` list, and gives you live Prometheus metrics, per-model thinking budgets, vision detection and a full configuration UI — all without leaving the pi prompt.
+**llamacpp-infra** turns pi into a first-class citizen of local llama.cpp infrastructure. It probes any number of machines — localhost, LAN or Tailscale — discovers every model served by llama.cpp and its variants (including LM Studio), registers them into pi's native `/model` list, and gives you live Prometheus metrics, per-model thinking budgets, vision detection and a full configuration UI — all without leaving the pi prompt.
 
 ---
 
@@ -14,17 +14,20 @@ Every endpoint llamacpp-infra talks to runs llama.cpp or a direct variant:
 | **ZINC** | `owned_by: "zinc"` | Payload workaround: empty model field + tool normalization |
 | **DwarfStar / ds4** | Opt-in ping to `/v1/chat/completions` | antirez's ds4-server for DeepSeek V4 (per-server `probeDs4` flag) |
 | **lucebox** | `GET /props` with `server.name: "luce-*"` | DeepSeek dflash server with rich metadata |
+| **LM Studio** | `GET /v1/models` + optional `/api/v1/models` metadata | Local OpenAI-compatible server backed by llama.cpp; default port `1234` |
 
-Anything else (LM Studio, vLLM, Ollama, cloud APIs…) is out of scope — use pi's built-in providers for those.
+Anything else (vLLM, Ollama, cloud APIs…) is out of scope — use pi's built-in providers for those.
 
 ## Features
 
 - **Multi-machine discovery** — configurable list of servers (host, ports, API key, options); probes all of them at startup and on demand
+- **Compact model ids** — models appear as `Name (host:port)` in pi's `/model` picker, like a native provider; the raw GGUF path/alias is sent to the server automatically on every request
 - **Single-model & router modes** — llama.cpp single-model mode (one GGUF per instance) and router mode (multiple models per server, with per-model status and args)
 - **Per-model metadata badges** — 👁️ vision (mmproj / modalities), 🚀 drafter (speculative decoding), 🗜️ quant tag from GGUF filename, 🧠 KV cache quantization (from server args or `/proc`)
 - **Live Prometheus metrics** — polls `/metrics` (or `/stats`) and renders a compact widget with instantaneous prompt/gen throughput; auto-activates for llamacpp-infra models only
 - **Thinking budgets** — llama.cpp accepts `thinking_budget_tokens` per request; configure budgets per thinking level (minimal/low/medium/high/xhigh/max) per model; models with budgets are registered with reasoning enabled
 - **Header warmup** — pre-caches the system prompt KV on llama.cpp-family servers so the first real request is faster
+- **LM Studio support** — uses LM Studio's OpenAI-compatible `/v1` API, enriches names/context/quant/vision from `/api/v1/models` (or legacy `/api/v0/models`), and avoids llama.cpp-only request fields
 - **ZINC workaround** — ZINC rejects non-empty model IDs; the payload hook rewrites the request and normalizes tool definitions automatically
 - **Vision detection** — scans `/proc` for local llama-server processes launched with `--mmproj` and marks those models as image-capable; also reads server-reported `modalities` / `input_modalities`
 - **Native configuration UI** — everything configurable through `/llamacpp-infra config` with pi's native menus; no config file editing required
@@ -39,7 +42,7 @@ llamacpp-infra is a [pi package](https://pi.dev/packages): one extension (`src/i
 pi install git:github.com/noguerol/llamacpp-infra
 
 # Pin a tag/commit
-pi install git:github.com/noguerol/llamacpp-infra@v1.0.0
+pi install git:github.com/noguerol/llamacpp-infra@v1.2.0
 
 # From npm
 pi install npm:pi-llamacpp-infra
@@ -58,18 +61,33 @@ pi remove npm:pi-llamacpp-infra
 
 > **Security:** pi packages run with full system access. Install only packages you trust and review the source.
 
-**Requirements:** a working pi installation and at least one llama.cpp-family server running somewhere accessible (localhost, LAN or Tailscale).
+**Requirements:** a working pi installation and at least one llama.cpp-family server running somewhere accessible (localhost, LAN or Tailscale). LM Studio works when its local server is started (Developer tab or `lms server start`, usually on `http://localhost:1234/v1`).
 
 ## Quick Start
 
 ```
-/llamacpp-infra config      # open the config menu → add your first server
+/llamacpp-infra config      # open the config menu → add your first server (LM Studio: port 1234)
 /llamacpp-infra scan        # discover models now
 /llamacpp-infra list        # see what was found
 ```
 
 That's it. On the next pi startup, llamacpp-infra probes your servers automatically and registers every model into `/model`. Switch models with `/model` as usual.
 
+### LM Studio quick setup
+
+LM Studio exposes an OpenAI-compatible API on `/v1` (default `http://localhost:1234/v1`) and a richer local REST API for model metadata on `/api/v1/models` (older LM Studio versions used `/api/v0/models`). llamacpp-infra probes `/v1/models` as the source of usable model IDs and, when available, enriches them with LM Studio's context length, display name, quantization and vision capability.
+
+```bash
+# Start LM Studio's local server (or use the Developer tab in the GUI)
+lms server start
+
+# In pi: add/select host 127.0.0.1 with port 1234, then scan
+/llamacpp-infra config
+/llamacpp-infra scan
+```
+
+No special payload workaround is required: LM Studio accepts standard OpenAI chat-completions requests. llamacpp-infra deliberately does **not** send llama.cpp-only fields such as `cache_prompt` or `thinking_budget_tokens` to LM Studio.
+
 ## Commands
 
 | Command | Description |
@@ -102,12 +120,14 @@ Shows every discovered model with metadata badges:
 ```
 📋 Discovered models (8)
 
- 1. local:8080/Qwen3.6-27B-UD-Q3_K_XL   👁️ 🗜️ UD-Q3_K_XL
- 2. local:8081/DeepSeek-V4-Flash          🗜️ ROCMFP2
- 3. myserver:8080/Meta-Llama-3.1-8B       🚀 draft-model   🗜️ Q4_K_M
- 4. myserver:8081/gemma-3-4b-it           👁️ 🗜️ Q4_K_M
+ 1. Qwen3.6-27B-UD-Q3_K_XL (local:8080)   👁️ 🗜️ UD-Q3_K_XL
+ 2. DeepSeek-V4-Flash-ROCMFP2 (local:8081)          🗜️ ROCMFP2
+ 3. Meta-Llama-3.1-8B (myserver:8080)     🚀 draft-model   🗜️ Q4_K_M
+ 4. gemma-3-4b-it (myserver:8081)         👁️ 🗜️ Q4_K_M
 ```
 
+The same compact id is what pi's `/model` picker shows, with the serving machine in parentheses.
+
 ### `/llamacpp-infra status`
 
 Detailed per-endpoint report:
@@ -135,7 +155,7 @@ Everything is configurable through the UI, but the persisted file is `~/.pi/agen
       "id": "local",
       "host": "127.0.0.1",
       "label": "Local",
-      "ports": [8000, 8001, 8002, 8080, 8081, 8082],
+      "ports": [8000, 8001, 8002, 8080, 8081, 8082, 1234],
       "enabled": true,
       "probeDs4": false
     },
@@ -164,7 +184,7 @@ Everything is configurable through the UI, but the persisted file is `~/.pi/agen
     "metricsPollMs": 5000
   },
   "modelOptions": {
-    "myserver:8080/Qwen3.6-27B": {
+    "Qwen3.6-27B (myserver:8080)": {
       "thinkingBudgets": {
         "minimal": 256,
         "low": 1024,
@@ -183,7 +203,7 @@ Everything is configurable through the UI, but the persisted file is `~/.pi/agen
 | `id` | required | Unique short id (used in model IDs and logs) |
 | `host` | required | Hostname, tailnet name or IP |
 | `label` | `host` | Friendly name shown in menus |
-| `ports` | required | Array of ports to probe |
+| `ports` | required | Array of ports to probe (`1234` is LM Studio's usual local server port) |
 | `enabled` | `true` | Whether to probe this server |
 | `probeDs4` | `false` | Opt-in: ping `/v1/chat/completions` for DwarfStar/ds4 servers |
 | `apiKey` | — | Optional bearer token sent on discovery and per-model requests |
@@ -198,7 +218,7 @@ Everything is configurable through the UI, but the persisted file is `~/.pi/agen
 | `startupGraceMs` | `40000` | Keep trying at startup while nothing has answered |
 | `knownGoodFailLimit` | `3` | Consecutive failures before a live endpoint is dropped |
 | `detectVision` | `true` | Scan `/proc` for `--mmproj` + read server-reported modalities |
-| `prefixModelIds` | `true` | `host:port/model` format to avoid cross-server collisions |
+| `prefixModelIds` | `true` | Append the machine tag `(host:port)` to model ids; OFF keeps bare names and only disambiguates collisions |
 | `showBadgesInNames` | `true` | Append 👁️🚀💤 badges to model display names |
 | `includeUnloadedRouterModels` | `false` | Router mode: list models that are not currently loaded |
 | `warmup` | `true` | Pre-cache system prompt KV on llama.cpp servers |
@@ -213,7 +233,15 @@ Levels: `minimal`, `low`, `medium`, `high`, `xhigh`, `max`.
 
 ## Model ID Format
 
-With `prefixModelIds: true` (default), every model ID is `host:port/model`, e.g. `myserver:8080/Qwen3.6-27B-UD-Q3_K_XL`. This avoids collisions when the same GGUF is served on multiple machines. Localhost servers (`127.0.0.1`, `localhost`) use `local:port/model` for readability.
+Models are registered with compact display ids: `ModelName (host:port)`, e.g. `Qwen3.6-27B-UD-Q3_K_XL (myserver:8080)` — the compact model name plus the machine serving it in parentheses, matching how pi shows native provider models. Localhost servers (`127.0.0.1`, `localhost`) use `local:port` in the tag.
+
+pi sends the compact id to the extension's request hook, which transparently rewrites it to the raw server-side id (the GGUF path, alias or router id the server advertised in `/v1/models`) before the request leaves pi. Config keys under `modelOptions` use the compact id; legacy `host:port/model` keys are migrated automatically on the first scan.
+
+With `prefixModelIds: false` the machine tag is omitted (`ModelName`); it is re-added automatically only when two models would otherwise collide.
+
+### Thinking budgets in the UI
+
+llama.cpp-family models are registered as reasoning models, exactly like a native pi provider: the footer shows `ModelName (host:port) • <level>`, the thinking selector offers levels with token estimates, and pi sends the configured `thinking_budget_tokens` budget on each request. Per-model budgets configured in the extension override pi's global per-level budgets.
 
 ## Live Metrics Widget
 
@@ -233,13 +261,13 @@ llamacpp-infra/
 ├── LICENSE             # MIT
 ├── README.md
 └── src/
-    ├── index.ts        # Extension entry point (~2400 lines)
+    ├── index.ts        # Extension entry point (~2600 lines)
     └── prompt-warmup.ts # Header warmup module (inlined, ~600 lines)
 ```
 
 Two-file extension with zero external dependencies (only pi's bundled `@earendil-works/pi-coding-agent` + Node built-ins):
 
-- **Discovery engine** — multi-server probing with timeouts, retry budgets, and per-server kind detection (llama.cpp, ZINC, DwarfStar, lucebox)
+- **Discovery engine** — multi-server probing with timeouts, retry budgets, and per-server kind detection (llama.cpp, ZINC, DwarfStar, lucebox, LM Studio)
 - **Router support** — single-model and multi-model llama.cpp modes with per-model status, args parsing and metadata extraction
 - **Metrics subsystem** — Prometheus endpoint discovery, polling, and compact widget rendering
 - **Thinking budgets** — per-model per-level configuration with automatic `reasoning` registration

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-llamacpp-infra",
-  "version": "1.0.0",
-  "description": "Discovery, metrics and control of llama.cpp-family servers for pi: probes any number of machines (localhost, LAN, Tailscale), registers every model into pi's native /model list, and provides live Prometheus metrics, per-model thinking budgets, vision detection and a native config UI. Supports llama.cpp, ZINC, DwarfStar/ds4 and lucebox.",
+  "version": "1.2.0",
+  "description": "Discovery, metrics and control of llama.cpp-family servers for pi: probes any number of machines (localhost, LAN, Tailscale), registers every model into pi's native /model list, and provides live Prometheus metrics, per-model thinking budgets, vision detection and a native config UI. Supports llama.cpp, ZINC, DwarfStar/ds4, lucebox and LM Studio.",
   "keywords": [
     "pi-package",
     "llamacpp",
@@ -11,7 +11,9 @@
     "metrics",
     "tailscale",
     "vision",
-    "thinking"
+    "thinking",
+    "lm-studio",
+    "lmstudio"
   ],
   "author": "Javier Noguerol <https://github.com/noguerol>",
   "license": "MIT",

package/src/index.ts

@@ -2,8 +2,8 @@
  * extension: llamacpp-infra
  * =========================
  * Discovery, metrics and control of models served by llama.cpp and its
- * variants (ZINC, DwarfStar/ds4, lucebox, OpenAI-compatible forks) on any
- * number of machines — localhost, LAN or Tailscale.
+ * variants (ZINC, DwarfStar/ds4, lucebox, LM Studio) on any number of
+ * machines — localhost, LAN or Tailscale.
  *
  * SCOPE
  * -----
@@ -15,8 +15,9 @@
  *   ZINC        — llama.cpp-compatible runtime (owned_by: "zinc")
  *   DwarfStar   — antirez's ds4-server for DeepSeek V4 (chat ping probe)
  *   lucebox     — DeepSeek dflash server (rich /props metadata)
+ *   LM Studio   — local OpenAI-compatible server backed by llama.cpp
  *
- * Anything else (LM Studio, vLLM, Ollama, cloud APIs…) is out of scope.
+ * Anything else (vLLM, Ollama, cloud APIs…) is out of scope.
  *
  * FEATURES
  * --------
@@ -47,6 +48,12 @@
  * 7. Header warmup (pre-cache system prompt KV on llama.cpp-family servers).
  * 8. ZINC workaround: ZINC rejects non-empty model ids; the payload hook
  *    rewrites the request accordingly and normalizes tool definitions.
+ * 9. LM Studio support: discovers `/v1/models`, enriches metadata from
+ *    `/api/v1/models` or legacy `/api/v0/models`, and avoids llama.cpp-only
+ *    request fields such as `cache_prompt` / `thinking_budget_tokens`.
+ * 10. Compact model ids: models are registered as "Name (host:port)" — the
+ *    raw server-side model id (GGUF path / alias) is restored automatically
+ *    in before_provider_request before the request leaves pi.
  *
  * HISTORY
  * -------
@@ -149,6 +156,37 @@ interface LlamaCppMeta {
 	n_ctx_train?: number;
 }
 
+interface LmStudioModelInfo {
+	/** v1 REST API unique key; v0 uses `id` instead. */
+	key?: string;
+	id?: string;
+	display_name?: string;
+	/** v1: "llm" | "embedding"; v0: "llm" | "vlm" | "embeddings". */
+	type?: string;
+	publisher?: string;
+	architecture?: string | null;
+	arch?: string | null;
+	format?: string | null;
+	compatibility_type?: string | null;
+	quantization?: string | { name?: string | null; bits_per_weight?: number | null } | null;
+	state?: string;
+	max_context_length?: number;
+	loaded_instances?: Array<{ id?: string; config?: { context_length?: number; parallel?: number } }>;
+	capabilities?: {
+		vision?: boolean;
+		trained_for_tool_use?: boolean;
+		reasoning?: boolean | { allowed_options?: string[]; default?: string };
+	};
+	selected_variant?: string;
+	variants?: string[];
+}
+
+interface LmStudioModelsResponse {
+	models?: LmStudioModelInfo[];
+	data?: LmStudioModelInfo[];
+	object?: string;
+}
+
 interface LlamaCppModel {
 	id: string;
 	name?: string;
@@ -170,6 +208,8 @@ interface LlamaCppModel {
 		input_modalities?: string[];
 		output_modalities?: string[];
 	};
+	/** LM Studio REST metadata, when the local server exposes it. */
+	lmStudio?: LmStudioModelInfo;
 	meta?: LlamaCppMeta;
 	context_window?: number;
 	context_length?: number;
@@ -210,7 +250,7 @@ interface ServerProps {
 	cache_type_v?: string;
 }
 
-type ServerKind = "llamacpp" | "zinc" | "lucebox" | "dwarfstar";
+type ServerKind = "llamacpp" | "zinc" | "lucebox" | "dwarfstar" | "lmstudio";
 type ServerMode = "single" | "router" | "unknown";
 
 /** Per-model metadata extracted during discovery. */
@@ -295,7 +335,7 @@ const DEFAULT_SERVERS: ServerConfig[] = [
 		id: "local",
 		host: "127.0.0.1",
 		label: "Local",
-		ports: [8000, 8001, 8002, 8080, 8081, 8082],
+		ports: [8000, 8001, 8002, 8080, 8081, 8082, 1234],
 		enabled: true,
 		probeDs4: false,
 	},
@@ -681,22 +721,109 @@ async function fetchServerProps(
 	return undefined;
 }
 
+function lmStudioKey(info: LmStudioModelInfo): string | undefined {
+	return info.key ?? info.id;
+}
+
+function lmStudioQuantName(info: LmStudioModelInfo | undefined): string | undefined {
+	if (!info) return undefined;
+	const q = info.quantization;
+	if (typeof q === "string") return q || undefined;
+	return q?.name ?? undefined;
+}
+
+function lmStudioContextLength(info: LmStudioModelInfo | undefined): number | undefined {
+	if (!info) return undefined;
+	const loadedCtx = info.loaded_instances?.find((inst) => typeof inst.config?.context_length === "number")?.config?.context_length;
+	return loadedCtx ?? info.max_context_length;
+}
+
+function isLmStudioModelInfo(value: unknown): value is LmStudioModelInfo {
+	const m = value as LmStudioModelInfo | undefined;
+	if (!m || typeof m !== "object") return false;
+	return Boolean(
+		m.key ||
+		m.id ||
+		m.display_name ||
+		m.compatibility_type ||
+		m.format ||
+		m.loaded_instances ||
+		typeof m.max_context_length === "number" ||
+		m.capabilities,
+	);
+}
+
+async function fetchLmStudioCatalog(
+	baseUrl: string,
+	timeoutMs: number,
+	apiKey?: string,
+): Promise<LmStudioModelInfo[] | undefined> {
+	const rootUrl = baseUrl.replace(/\/v1\/?$/, "");
+	// LM Studio v1 is current; v0 is still common in older installations.
+	for (const path of ["/api/v1/models", "/api/v0/models"]) {
+		try {
+			const { status, body } = await httpGet(`${rootUrl}${path}`, timeoutMs, apiKey);
+			if (status < 200 || status >= 300) continue;
+			const payload = JSON.parse(body) as LmStudioModelsResponse;
+			const models = Array.isArray(payload.models) ? payload.models : Array.isArray(payload.data) ? payload.data : undefined;
+			if (models && models.length > 0 && models.some(isLmStudioModelInfo)) return models;
+		} catch {
+			// Not LM Studio, or an older server without the REST metadata endpoint.
+		}
+	}
+	return undefined;
+}
+
+function buildLmStudioCatalogMap(catalog: LmStudioModelInfo[]): Map<string, LmStudioModelInfo> {
+	const map = new Map<string, LmStudioModelInfo>();
+	const add = (key: string | undefined, info: LmStudioModelInfo) => {
+		const k = key?.trim().toLowerCase();
+		if (k && !map.has(k)) map.set(k, info);
+	};
+	for (const info of catalog) {
+		add(lmStudioKey(info), info);
+		add(info.key, info);
+		add(info.id, info);
+		add(info.selected_variant, info);
+		add(info.display_name, info);
+		for (const variant of info.variants ?? []) add(variant, info);
+		for (const inst of info.loaded_instances ?? []) add(inst.id, info);
+	}
+	return map;
+}
+
+function enrichWithLmStudioCatalog(models: LlamaCppModel[], catalog: LmStudioModelInfo[]): LlamaCppModel[] {
+	const byKey = buildLmStudioCatalogMap(catalog);
+	return models.map((model) => {
+		const rawId = String(model.id ?? "");
+		const info = byKey.get(rawId.toLowerCase()) ?? byKey.get(baseName(rawId).toLowerCase());
+		if (!info) return model;
+		return { ...model, display_name: info.display_name ?? model.display_name, lmStudio: info };
+	});
+}
+
 /**
  * Detect the server kind for an endpoint:
  *   1. lucebox:    /props with server.name "luce-*"
  *   2. DwarfStar:  /props build_info "dwarf*"/"ds4*" (else via chat probe)
  *   3. ZINC:       /v1/models with owned_by === "zinc"
- *   4. llama.cpp:  anything else serving models
+ *   4. LM Studio:  OpenAI-compatible /v1/models + REST /api/v1|v0/models
+ *   5. llama.cpp:  anything else serving models
  */
 async function detectServerKind(
 	baseUrl: string,
 	models: LlamaCppModel[],
 	props: ServerProps | undefined,
+	lmStudioCatalog?: LmStudioModelInfo[],
 ): Promise<ServerKind | "unknown"> {
+	void baseUrl;
 	const serverName = String(props?.server?.name ?? props?.build_info ?? "").toLowerCase();
 	if (serverName.startsWith("luce")) return "lucebox";
 	if (serverName.startsWith("dwarf") || serverName.startsWith("ds4")) return "dwarfstar";
 	if (models.length > 0 && models[0].owned_by === "zinc") return "zinc";
+	if (models.some((m) => String(m.owned_by ?? "").toLowerCase().includes("lmstudio"))) return "lmstudio";
+	if (lmStudioCatalog && lmStudioCatalog.length > 0) return "lmstudio";
+	if (models.some((m) => m.lmStudio)) return "lmstudio";
 	if (models.length > 0) return "llamacpp";
 	return "unknown";
 }
@@ -766,13 +893,14 @@ function buildModelMetadata(
 ): ModelMetadata {
 	const meta: ModelMetadata = {};
 
-	// ── Model quant (GGUF filename / router id) ──
+	// ── Model quant (GGUF filename / router id / LM Studio metadata) ──
 	const sourcePath = entry.path ?? props?.model_path ?? rawId;
-	meta.quant = extractQuantTag(sourcePath);
+	meta.quant = extractQuantTag(sourcePath) ?? lmStudioQuantName(entry.lmStudio)?.toUpperCase();
 
 	// ── Vision ──
 	if (entry.architecture?.input_modalities?.includes("image")) meta.vision = true;
 	if (meta.vision === undefined && props?.modalities?.vision === true) meta.vision = true;
+	if (!meta.vision && (entry.lmStudio?.capabilities?.vision === true || entry.lmStudio?.type === "vlm")) meta.vision = true;
 	if (!meta.vision && local?.hasMmproj) meta.vision = true;
 
 	// ── Drafter (speculative decoding) ──
@@ -791,8 +919,9 @@ function buildModelMetadata(
 	meta.cacheK = argsInfo?.cacheK ?? local?.cacheK ?? props?.cache_type_k?.toLowerCase();
 	meta.cacheV = argsInfo?.cacheV ?? local?.cacheV ?? props?.cache_type_v?.toLowerCase();
 
-	// ── Router load status ──
+	// ── Router / LM Studio load status ──
 	if (entry.status?.value) meta.routerStatus = entry.status.value;
+	else if (entry.lmStudio?.state && entry.lmStudio.state !== "loaded") meta.routerStatus = entry.lmStudio.state;
 
 	return meta;
 }
@@ -827,7 +956,7 @@ async function fetchModelsFromEndpoint(
 			return ep;
 		}
 		const payload = JSON.parse(body) as LlamaCppModelsResponse;
-		const models = payload.data ?? [];
+		let models = payload.data ?? [];
 
 		// llama.cpp provides a parallel models[] array with friendly names
 		const nameMap = new Map<string, string>();
@@ -837,18 +966,24 @@ async function fetchModelsFromEndpoint(
 			}
 		}
 
-		// ── Mode detection ──
+		// ── Mode + server metadata detection ──
 		// Router/multi-model entries carry path/status/architecture; the router's
-		// own /props answers with role: "router".
-		const isRouterShape = models.some((m) => m.path !== undefined || m.status !== undefined);
+		// own /props answers with role: "router". LM Studio answers OpenAI's
+		// /v1/models and exposes richer local metadata under /api/v1/models
+		// (legacy: /api/v0/models), without llama.cpp's /props endpoint.
 		let props = await fetchServerProps(baseUrl, settings.discoveryTimeoutMs, srv.apiKey);
+		const lmStudioCatalog = props ? undefined : await fetchLmStudioCatalog(baseUrl, settings.discoveryTimeoutMs, srv.apiKey);
+		if (lmStudioCatalog) models = enrichWithLmStudioCatalog(models, lmStudioCatalog);
+		const isRouterShape = models.some((m) => m.path !== undefined || m.status !== undefined);
 		const routerProps = props?.role === "router";
-		const mode: ServerMode = isRouterShape || routerProps ? "router" : "single";
+		const mode: ServerMode = lmStudioCatalog
+			? models.length > 1 ? "router" : "single"
+			: isRouterShape || routerProps ? "router" : "single";
 		// In single-model mode props describes THE model; in router mode the root
 		// props is the router itself (useless for per-model metadata).
 		if (mode === "router") props = undefined;
 
-		const kind = await detectServerKind(baseUrl, models, props);
+		const kind = await detectServerKind(baseUrl, models, props, lmStudioCatalog);
 		// lucebox always enriches via /props (its own schema, even without router).
 		if (kind === "lucebox") {
 			props = (await fetchServerProps(baseUrl, settings.discoveryTimeoutMs, srv.apiKey)) ?? props;
@@ -891,6 +1026,10 @@ async function fetchModelsFromEndpoint(
 // =============================================================================
 
 /** Compat profile per server kind. */
+function supportsThinkingBudget(kind: ServerKind | "unknown" | "auto" | undefined): boolean {
+	return kind === "llamacpp" || kind === "lucebox";
+}
+
 function makeCompat(kind: ServerKind | "unknown" | "auto") {
 	const usageInStreaming = kind !== "zinc";
 	return {
@@ -900,8 +1039,9 @@ function makeCompat(kind: ServerKind | "unknown" | "auto") {
 		supportsUsageInStreaming: usageInStreaming,
 		supportsStrictMode: false,
 		// llama.cpp accepts a per-request `thinking_budget_tokens` cap.
+		// LM Studio is OpenAI-compatible but does not accept llama.cpp-only fields.
 		// (Only honored by pi when the model is registered with reasoning: true.)
-		...(kind === "llamacpp" || kind === "lucebox" ? { thinkingTokenBudgetField: THINKING_BUDGET_FIELD } : {}),
+		...(supportsThinkingBudget(kind) ? { thinkingTokenBudgetField: THINKING_BUDGET_FIELD } : {}),
 	};
 }
 
@@ -917,6 +1057,8 @@ interface PiModel {
 	compat?: ReturnType<typeof makeCompat>;
 	headers?: Record<string, string>;
 	thinkingBudgets?: ThinkingBudgets;
+	/** Raw model id expected by the server (compact ids are display-only). */
+	serverModelId: string;
 	/** Metadata badges are applied to the name at build time. */
 	endpoint: { serverId: string; host: string; port: number; kind: ServerKind | "unknown" | "auto"; mode: ServerMode };
 	quant?: string;
@@ -949,8 +1091,9 @@ function toPiModel(
 ): PiModel {
 	const rawId = String(model.id ?? "");
 	const hostPort = `${idSafeHost(srv.host)}:${ep.port}`;
-	const usePrefix = settings.prefixModelIds;
-	const prefixId = (id: string) => `${hostPort}/${id.replace(/^\/+/, "")}`;
+	// Compact display id: "ModelName (host:port)". The raw server-side id is
+	// kept separately (serverModelId) and restored in before_provider_request.
+	const machineTag = settings.prefixModelIds ? ` (${hostPort})` : "";
 	const kind = ep.server;
 
 	const common = {
@@ -966,22 +1109,41 @@ function toPiModel(
 		...(srv.apiKey ? { headers: { Authorization: `Bearer ${srv.apiKey}` } } : {}),
 	};
 
+	// ── LM Studio: OpenAI-compatible runtime with rich REST model metadata ──
+	if (kind === "lmstudio") {
+		const info = model.lmStudio;
+		const contextWindow = lmStudioContextLength(info) ?? model.context_window ?? model.context_length ?? 32768;
+		const displayName = info?.display_name ? cleanModelName(info.display_name) : cleanModelName(rawId);
+		return {
+			...common,
+			id: `${displayName}${machineTag}`,
+			serverModelId: rawId,
+			name: `${displayName}${badgeSuffix(modelMeta, settings.showBadgesInNames)}`,
+			// LM Studio exposes reasoning-capable models, but its OpenAI-compatible
+			// endpoint does not use llama.cpp's thinking_budget_tokens field.
+			reasoning: false,
+			contextWindow,
+			maxTokens: model.max_tokens ?? Math.min(contextWindow, 8192),
+			compat: makeCompat(kind),
+		};
+	}
+
 	// ── lucebox: alias as source of truth, rich metadata from /props ──
 	if (kind === "lucebox") {
 		const modelPath = ep.props?.model_path || rawId;
 		const alias = ep.props?.model_alias || rawId;
 		const nCtx = ep.props?.default_generation_settings?.n_ctx;
 		const contextWindow = model.context_length ?? nCtx ?? 8192;
-		const budgets = config_ModelOptions()?.[usePrefix ? prefixId(alias) : alias]?.thinkingBudgets;
+		const displayName = cleanModelName(baseName(alias !== rawId ? alias : modelPath));
 		return {
 			...common,
-			id: usePrefix ? prefixId(alias) : alias,
-			name: `${cleanModelName(modelPath)}${badgeSuffix(modelMeta, settings.showBadgesInNames)}`,
+			id: `${displayName}${machineTag}`,
+			serverModelId: alias,
+			name: `${displayName}${badgeSuffix(modelMeta, settings.showBadgesInNames)}`,
 			reasoning: ep.props?.capabilities?.reasoning_supported ?? true,
 			contextWindow,
 			maxTokens: model.max_tokens ?? Math.min(contextWindow, 8192),
 			compat: makeCompat(kind),
-			...(budgets ? { thinkingBudgets: budgets } : {}),
 		};
 	}
 
@@ -997,21 +1159,19 @@ function toPiModel(
 	const contextWindow =
 		model.meta?.n_ctx ?? model.meta?.n_ctx_train ?? model.context_window ?? model.context_length ?? 32768;
 
-	// Models with configured thinking budgets must be registered as reasoning
-	// models so pi's thinking-level machinery (and budget field) engages.
-	const modelId = usePrefix ? prefixId(rawId) : rawId;
-	const budgets = config_ModelOptions()?.[modelId]?.thinkingBudgets;
 	const isLlamaFamily = kind === "llamacpp";
 
 	return {
 		...common,
-		id: modelId,
+		id: `${displayName}${machineTag}`,
+		serverModelId: rawId,
 		name: `${displayName}${badgeSuffix(modelMeta, settings.showBadgesInNames)}`,
-		reasoning: isLlamaFamily || Boolean(budgets),
+		// llama.cpp-family models behave like native pi reasoning models: the
+		// footer shows the thinking level and pi sends the configured budget.
+		reasoning: isLlamaFamily,
 		contextWindow,
 		maxTokens: model.max_tokens ?? Math.min(contextWindow, 8192),
 		compat: makeCompat(kind),
-		...(budgets ? { thinkingBudgets: budgets } : {}),
 	};
 }
 
@@ -1125,6 +1285,7 @@ function modelsSignature(endpoints: EndpointResult[]): string {
 		.map((r) => {
 			const models = r.models
 				.filter((m) => {
+					if (r.server === "lmstudio") return true;
 					const st = r.meta.get(String(m.id ?? ""))?.routerStatus;
 					return !st || st === "loaded" || rIncludeUnloaded;
 				})
@@ -1160,6 +1321,22 @@ const zincModelIds = new Set<string>();
 const modelBaseUrls = new Map<string, string>();
 /** baseUrl → server kind (for the warmup request profile). */
 const endpointKinds = new Map<string, string>();
+/** Registered (compact) model id → raw server-side model id (payload rewrite). */
+const serverModelIds = new Map<string, string>();
+/** Raw server-side model id → registered (compact) model id. */
+const compactModelIds = new Map<string, string>();
+
+/** Compact id registered in pi for a raw server model id (or the input). */
+function compactIdFor(modelId: string | undefined): string | undefined {
+	if (!modelId) return undefined;
+	return compactModelIds.get(modelId) ?? modelId;
+}
+
+/** Raw server-side id to send in requests for a registered model id (or the input). */
+function rawIdFor(modelId: string | undefined): string | undefined {
+	if (!modelId) return undefined;
+	return serverModelIds.get(modelId) ?? modelId;
+}
 
 /**
  * Build pi models from a scan and (re)register the provider.
@@ -1167,7 +1344,10 @@ const endpointKinds = new Map<string, string>();
  */
 function buildAndRegisterProvider(pi: ExtensionAPI, scan: ScanResult, config: InfraConfig): PiModel[] {
 	zincModelIds.clear();
+	serverModelIds.clear();
+	compactModelIds.clear();
 	const settings = config.settings;
+	let configDirty = false;
 
 	const piModels: PiModel[] = [];
 	const seenIds = new Set<string>();
@@ -1177,7 +1357,11 @@ function buildAndRegisterProvider(pi: ExtensionAPI, scan: ScanResult, config: In
 		if (!srv) continue;
 
 		// Router mode: skip unloaded models unless explicitly included.
+		// LM Studio's /v1/models can expose embedding models too; this provider
+		// registers chat/completions models only.
 		const visibleModels = ep.models.filter((m) => {
+			const lmType = m.lmStudio?.type;
+			if (ep.server === "lmstudio") return lmType !== "embedding" && lmType !== "embeddings";
 			const st = ep.meta.get(String(m.id ?? ""))?.routerStatus;
 			return !st || st === "loaded" || settings.includeUnloadedRouterModels;
 		});
@@ -1193,25 +1377,56 @@ function buildAndRegisterProvider(pi: ExtensionAPI, scan: ScanResult, config: In
 			const rawId = String(model.id ?? "");
 			const modelMeta = ep.meta.get(rawId) ?? {};
 			const pm = toPiModel(model, ep, srv, settings, modelMeta);
+			const hostPort = `${idSafeHost(srv.host)}:${ep.port}`;
 
-			// ID collision guard: force the "host:port/" prefix on collisions,
-			// then a numeric suffix if even that collides.
+			// ID collision guard: add the machine tag, then a numeric suffix.
 			if (seenIds.has(pm.id)) {
-				pm.id = `${idSafeHost(srv.host)}:${ep.port}/${pm.id.replace(/^\/+/, "")}`;
+				if (!pm.id.includes(`(${hostPort})`)) pm.id = `${pm.id} (${hostPort})`;
 				let n = 2;
 				while (seenIds.has(pm.id)) pm.id = `${pm.id}-${n++}`;
 			}
 			seenIds.add(pm.id);
 
+			// Thinking budgets: resolve by the registered (compact) id or legacy
+			// "host:port/model" keys, then migrate legacy keys forward.
+			const opts = config_ModelOptions();
+			let budgets = opts[pm.id]?.thinkingBudgets;
+			if (!budgets) {
+				for (const legacyKey of [`${hostPort}/${pm.serverModelId.replace(/^\/+/, "")}`, pm.serverModelId]) {
+					const entry = opts[legacyKey];
+					if (entry?.thinkingBudgets) {
+						if (!opts[pm.id]) opts[pm.id] = entry;
+						delete opts[legacyKey]; // migrate: compact id replaces host:port/model
+						configDirty = true;
+						budgets = entry.thinkingBudgets;
+						break;
+					}
+				}
+			}
+			if (budgets && ep.server !== "lmstudio") {
+				pm.thinkingBudgets = budgets;
+				// Models with configured thinking budgets must be registered as
+				// reasoning models so pi's thinking-level machinery engages.
+				pm.reasoning = true;
+			}
+
+			// Duplicate display names within one endpoint get the raw id appended.
 			const candidateName = cleanModelName(String(model.name ?? model.id));
 			if (nameCount.get(candidateName)! > 1) {
-				pm.name = `${candidateName}${badgeSuffix(modelMeta, settings.showBadgesInNames)} (${rawId})`;
+				pm.name = `${candidateName}${badgeSuffix(modelMeta, settings.showBadgesInNames)} (${pm.serverModelId})`;
 			}
 			piModels.push(pm);
-			if (ep.server === "zinc") zincModelIds.add(pm.id);
+			if (ep.server === "zinc") {
+				zincModelIds.add(pm.id);
+				zincModelIds.add(pm.serverModelId);
+			}
+			serverModelIds.set(pm.id, pm.serverModelId);
+			if (!compactModelIds.has(pm.serverModelId)) compactModelIds.set(pm.serverModelId, pm.id);
 		}
 	}
 
+	if (configDirty) saveConfig(config);
+
 	// Maps for hooks
 	endpointKinds.clear();
 	for (const ep of scan.endpoints) {
@@ -1281,6 +1496,7 @@ export default function (pi: ExtensionAPI) {
 		provider: PROVIDER_NAME,
 		cacheFile: join(homedir(), ".pi", "agent", "warmup-llamacpp-infra.json"),
 		kindFor: (baseUrl) => endpointKinds.get(baseUrl),
+		requestModelFor: (modelId) => rawIdFor(modelId) ?? modelId,
 		onEvent: (ev) => warmupStatus.handle(ev),
 	});
 
@@ -1587,6 +1803,21 @@ export default function (pi: ExtensionAPI) {
 	registerEmptyProvider();
 	void discoverAndRegister().then((r) => schedulePolling(r.shouldPoll));
 
+	// ── Hook 0: compact registered id → raw server model id ─────────
+	// Model ids registered in pi are compact display ids ("Name (host:port)");
+	// llama.cpp-family servers expect the raw model path/alias they advertised
+	// in /v1/models, so the payload model field is rewritten here. Registered
+	// first so every later hook (and the server) sees the raw id.
+	pi.on("before_provider_request", (event, _ctx) => {
+		const payload = event.payload as Record<string, unknown>;
+		const modelInPayload = typeof payload.model === "string" ? payload.model : undefined;
+		if (!modelInPayload) return undefined;
+		const raw = serverModelIds.get(modelInPayload);
+		if (raw === undefined || raw === modelInPayload) return undefined;
+		debugLog(`model id "${modelInPayload}" → "${raw}"`);
+		return { ...payload, model: raw };
+	});
+
 	// ── Hook 1: ZINC payload workaround ────────────────────────────
 	// ZINC rejects non-empty model ids and is picky about tool formats.
 	function isZincModel(modelInPayload: unknown): boolean {
@@ -1638,18 +1869,23 @@ export default function (pi: ExtensionAPI) {
 	// ── Hook 2: per-model thinking budget (llama.cpp thinking_budget_tokens) ──
 	// pi injects thinking_token budgets from its global settings; this hook
 	// overrides the value with the per-model budgets configured for this model.
-	// Registered after the ZINC hook so it sees the final payload.
+	// Registered after the ZINC hook so it sees the final payload. Hook 0 has
+	// already rewritten the payload model to the raw server id, so both raw
+	// and compact ids are resolved against the registered model maps.
 	pi.on("before_provider_request", (event, ctx) => {
 		const payload = event.payload as Record<string, unknown>;
 		const modelId = typeof payload.model === "string" ? payload.model : undefined;
 		if (!modelId) return undefined;
-		const budgets = config.modelOptions[modelId]?.thinkingBudgets;
+		const compactKey = compactModelIds.get(modelId) ?? modelId;
+		const baseUrl = modelBaseUrls.get(compactKey);
+		if (!supportsThinkingBudget(endpointKinds.get(baseUrl ?? "") as ServerKind | undefined)) return undefined;
+		const budgets = config.modelOptions[compactKey]?.thinkingBudgets;
 		if (!budgets) return undefined;
 		const level = normalizeLevel(ctx.thinkingLevel ?? currentThinkingLevel);
 		if (!level) return undefined;
 		const value = budgets[level];
 		if (typeof value !== "number") return undefined;
-		debugLog(`thinking budget for ${modelId} [${level}] = ${value}`);
+		debugLog(`thinking budget for ${compactKey} [${level}] = ${value}`);
 		return { ...payload, [THINKING_BUDGET_FIELD]: value };
 	});
 
@@ -1669,18 +1905,22 @@ export default function (pi: ExtensionAPI) {
 	}
 
 	// ── Hook 3: header warmup capture (runs last, sees final payload) ──
+	// Templates are keyed by the compact registered id (the same id passed to
+	// warmupForModel); PromptWarmer re-resolves the raw server id per request.
 	pi.on("before_provider_request", (event, ctx) => {
 		if (!config.settings.warmup) return undefined;
 		const payload = event.payload as Record<string, unknown>;
 		const modelId = typeof payload?.model === "string" ? payload.model : undefined;
-		const baseUrl = modelId ? modelBaseUrls.get(modelId) : undefined;
-		warmer.onProviderPayload(payload, baseUrl, ctx.cwd);
+		const compactKey = modelId ? (compactModelIds.get(modelId) ?? modelId) : undefined;
+		const baseUrl = compactKey ? modelBaseUrls.get(compactKey) : undefined;
+		const capturePayload = compactKey ? { ...payload, model: compactKey } : payload;
+		warmer.onProviderPayload(capturePayload, baseUrl, ctx.cwd);
 		return undefined;
 	});
 
 	// ── Command: /llamacpp-infra ───────────────────────────────────
 	pi.registerCommand("llamacpp-infra", {
-		description: "llama.cpp-infra: discover llama.cpp/ZINC/DwarfStar models on any machine (config, scan, metrics…)",
+		description: "llama.cpp-infra: discover llama.cpp/ZINC/DwarfStar/LM Studio models on any machine (config, scan, metrics…)",
 		getArgumentCompletions: (prefix) =>
 			["config", "scan", "status", "list", "metrics", "help"]
 				.filter((s) => s.startsWith(prefix))
@@ -1786,7 +2026,7 @@ export default function (pi: ExtensionAPI) {
 			if (!ep) return undefined;
 			// Find the raw entry whose registered id ends with the raw id fragment.
 			for (const [rawId, meta] of ep.meta) {
-				if (m.id.endsWith(`/${rawId.replace(/^\/+/, "")}`) || m.id === rawId) return meta;
+				if (m.serverModelId === rawId || m.id === rawId) return meta;
 			}
 			return undefined;
 		};
@@ -1814,7 +2054,7 @@ export default function (pi: ExtensionAPI) {
 	function showHelp(ctx: ExtensionContext) {
 		ctx.ui.notify(
 			[
-				"🦙 llama.cpp-infra — models served by llama.cpp & variants (ZINC, DwarfStar/ds4, lucebox) on any machine",
+				"🦙 llama.cpp-infra — models served by llama.cpp & variants (ZINC, DwarfStar/ds4, lucebox, LM Studio) on any machine",
 				"",
 				"  /llamacpp-infra            → quick status",
 				"  /llamacpp-infra config     → ⚙️ configure servers, budgets & settings",
@@ -1875,12 +2115,16 @@ export default function (pi: ExtensionAPI) {
 							"🦙 llama.cpp-infra",
 							"",
 							"Discovers models served by llama.cpp (single & router/multi-model),",
-							"ZINC, DwarfStar (ds4-server) and lucebox on any number of machines,",
-							"and registers them into pi's native /model list.",
+							"ZINC, DwarfStar (ds4-server), lucebox and LM Studio on any number",
+							"of machines, and registers them into pi's native /model list.",
 							"",
+							"Models appear as compact ids: \"Name (host:port)\" — the raw GGUF",
+							"path/alias is sent to the server automatically on every request.",
+							"LM Studio uses its OpenAI-compatible /v1 endpoint and enriches",
+							"metadata from /api/v1/models (or legacy /api/v0/models).",
 							"Per-model metadata: vision, drafter, model quant, KV cache quant.",
 							"Per-model thinking budgets via llama.cpp thinking_budget_tokens.",
-							"Live throughput metrics from each server's /metrics endpoint.",
+							"Live throughput metrics from each server's /metrics endpoint when exposed.",
 							"",
 							`Config: ${getConfigPath()}`,
 						].join("\n"),
@@ -2078,7 +2322,7 @@ export default function (pi: ExtensionAPI) {
 			ctx.ui.notify(`⚠️ A server with host "${trimmedHost}" already exists`, "warning");
 			return;
 		}
-		const portsRaw = await ctx.ui.input("➕ Ports to probe", "e.g. 8000, 8080-8082");
+		const portsRaw = await ctx.ui.input("➕ Ports to probe", "e.g. 1234, 8000, 8080-8082");
 		if (portsRaw === undefined) return;
 		const ports = parsePorts(portsRaw);
 		if (!ports) {
@@ -2087,7 +2331,7 @@ export default function (pi: ExtensionAPI) {
 		}
 		const label = await ctx.ui.input("🏷️ Label (optional)", trimmedHost);
 		if (label === undefined) return;
-		const probeDs4 = await ctx.ui.confirm("🕵️ ds4 (DwarfStar) probe?", "Enable the chat-completions ping probe for this machine? (for DwarfStar/ds4-server hosts)");
+		const probeDs4 = await ctx.ui.confirm("🕵️ ds4 (DwarfStar) probe?", "Enable the chat-completions ping probe for this machine? (for DwarfStar/ds4-server hosts; not needed for LM Studio)");
 
 		let id = idSafeHost(trimmedHost).replace(/[^a-z0-9.-]/g, "-");
 		let n = 2;

package/src/prompt-warmup.ts

@@ -248,6 +248,8 @@ export interface PromptWarmerOptions {
 	cacheFile?: string;
 	/** Devuelve el tipo de servidor ("llamacpp"|"lucebox"|"ds4"|"zinc"|"lmstudio") para una baseUrl. */
 	kindFor?: (baseUrl: string) => string | undefined;
+	/** Mapea el id registrado (compacto) al id crudo que espera el servidor. */
+	requestModelFor?: (modelId: string) => string;
 	/** Callback opcional para eventos de warmup (estado en footer, notify, ...). */
 	onEvent?: (ev: WarmupEvent) => void;
 	/** Log opcional. Por defecto silencioso (no-op); activa con PI_WARMUP_DEBUG=1. */
@@ -351,6 +353,7 @@ export class PromptWarmer {
 	readonly provider: string;
 	private cacheFile: string;
 	private kindFor: (baseUrl: string) => string | undefined;
+	private requestModelFor: (modelId: string) => string;
 	private onEvent?: (ev: WarmupEvent) => void;
 	private log: (msg: string) => void;
 
@@ -368,6 +371,7 @@ export class PromptWarmer {
 		this.cacheFile =
 			opts.cacheFile ?? path.join(homedir(), ".pi", "agent", `warmup-${opts.provider}.json`);
 		this.kindFor = opts.kindFor ?? (() => KIND_LLAMACPP);
+		this.requestModelFor = opts.requestModelFor ?? ((id: string) => id);
 		this.onEvent = opts.onEvent;
 		// Por defecto silencioso: escribir por stderr corrompe el render de la TUI
 		// de pi (trazas sucias en el editor / input box). Solo se loguea con
@@ -392,6 +396,15 @@ export class PromptWarmer {
 		}
 	}
 
+	/** Id crudo que espera el servidor para un id registrado (con fallback). */
+	private resolveRequestModel(modelId: string): string {
+		try {
+			return this.requestModelFor(modelId) || modelId;
+		} catch {
+			return modelId;
+		}
+	}
+
 	// ── Warmup ────────────────────────────────────────────────────────────────
 
 	/**
@@ -422,7 +435,7 @@ export class PromptWarmer {
 		let body: WarmupBody;
 		if (tpl) {
 			body = {
-				model: tpl.model,
+				model: this.resolveRequestModel(tpl.model),
 				messages: [...tpl.systemMessages, { role: "user", content: PLACEHOLDER_USER }],
 				max_tokens: 1,
 				temperature: 0,
@@ -432,7 +445,7 @@ export class PromptWarmer {
 			if (cachePromptSupported(tpl.kind)) body.cache_prompt = true;
 		} else if (systemPrompt && FALLBACK_ENABLED) {
 			body = {
-				model: model.id,
+				model: this.resolveRequestModel(model.id),
 				messages: [
 					{ role: "system", content: systemPrompt },
 					{ role: "user", content: PLACEHOLDER_USER },