turbollm 1.7.2 → 1.7.4

package/README.md

@@ -177,8 +177,8 @@ the detail:
 - **Saved per-model profiles, per engine** — tune once per (model, engine) pair, so
   switching engines (or between two installs of the same engine, e.g. a fork) never
   overwrites another engine's tuning for the same model.
-- **Configurable VRAM headroom** (Settings → Engine, 300 MB–2 GB, default 1 GB) — tell auto-tune
-  how much VRAM to keep free for other GPU workloads instead of a fixed margin.
+- **Configurable VRAM headroom** (Settings → Models & loading → Advanced, 300 MB–2 GB, default
+  1 GB) — tell auto-tune how much VRAM to keep free for other GPU workloads instead of a fixed margin.
 
 </details>
 
@@ -196,9 +196,11 @@ the detail:
   the model draws when a comparison, trend, or hierarchy is genuinely worth a visual.
 - **Live artifacts** — `html`, `svg`, and `mermaid` replies render as **sandboxed, offline
   previews** shown as an image, with one-click export to **PNG / JPEG / SVG / animated GIF / HTML**.
-- **Personas** — pick a style (Default · **Designer** · Concise · Detailed · Blunt · Formal · Tutor ·
-  Creative · Research) per conversation, no prompt-wrangling required. The **Designer** persona
-  produces polished, self-contained, previewable designs by default.
+- **Agents** — pick a style (Default · **Designer** · Concise · Detailed · Blunt · Formal · Tutor ·
+  Creative · Research · **Lite** · **Code**) per conversation, no prompt-wrangling required. The
+  **Designer** persona produces polished, self-contained, previewable designs by default; **Lite**
+  strips the hidden prompt to the bare minimum for the fastest responses. See below for editing
+  built-ins or creating your own.
 - **Edit, regenerate, delete, copy** any message; **persistent, searchable conversations**
   with rename, delete, and **auto-generated titles**, organized into **drag-resizable,
   collapsible folders** you create/rename/move conversations into.
@@ -214,22 +216,22 @@ the detail:
   in every chat with no restart. A **Research** persona forces multi-step web search and cites sources inline.
 - **Tool-call approval gate** — every tool call asks for your approval by default before it runs,
   with **Deny**, **Allow**, **Allow for this chat**, or **Always Allow** on an inline bar above the
-  composer. Set per-tool defaults globally from Developer → Tool permissions.
+  composer. Set per-tool defaults globally from Settings → Tools & safety.
 
 </details>
 
 <details>
-<summary><strong>🤖 Background agents — long-running tasks that don't tie up your chat</strong></summary>
+<summary><strong>🤖 Customize → Agents — edit any built-in, or build your own</strong></summary>
 
 <br/>
 
-- **Launch an agent and walk away.** The **Agents** screen runs tasks in the daemon, separate from
-  the chat tab — describe the task, pick which tools it may use (web search / fetch URL / run code),
-  and let it work.
-- **Live, reconnectable progress.** Watch the run stream in real time; navigate away or reload and
-  the view **reconnects** to the in-progress output. Runs **queue** behind any active run and
-  **persist** across restarts.
-- **Cancel anytime**, and review completed runs (messages + the tool calls they made) later.
+- **Edit any built-in agent in place** — system prompt, which shared skills it uses, and which
+  tools it may call — with a one-click **Reset** back to the original.
+- **Create your own agent** from scratch: a name, description, and system prompt, plus a
+  checklist of which shared skills and which tools it's allowed to use (everything on by
+  default). Pick it from the same in-chat agent picker as the built-ins.
+- **MCP tools grouped by server** in the tool checklist — one toggle selects or deselects an
+  entire server's tools at once, or expand it to pick individually.
 
 </details>
 
@@ -253,7 +255,7 @@ curl http://127.0.0.1:6996/v1/chat/completions \
 - **Anthropic-compatible** `/v1/messages` — including **tool use and streaming** — which powers
   Claude Code below. No other local host offers this.
 - **Structured output** — constrain any response to a **GBNF grammar** (or JSON shape).
-- **API-key auth** you can require when sharing over a LAN (Settings → Network).
+- **API-key auth** you can require when sharing over a LAN (Settings → Network & sharing).
 
 **The gateway loads models for you.** Most local hosts make you load a model first, then call it.
 TurboLLM's gateway reads the `model` field of any incoming request, **fuzzy-matches it to your
@@ -265,7 +267,7 @@ coding model, a vision model, and an embedder just names each one and it works
 `opencode`, `kilo`, `openclaw`, and `hermes` — each gets pointed at TurboLLM the way that tool
 expects (config file merge, or its own CLI command) instead of a manual copy-paste setup. Inside
 Claude Code, `/model` lists your local models directly (with **Auto Model Swap** on in Settings →
-Gateway) so you can switch mid-session instead of only at launch.
+Models & loading) so you can switch mid-session instead of only at launch.
 
 </details>
 
@@ -283,7 +285,7 @@ fight for memory (and one usually OOMs). TurboLLM can hand the GPU over automati
 It's **push-based, not polling** — ComfyUI signals TurboLLM the moment a job starts/ends, so the
 handoff is immediate and deterministic (the model is gone *before* ComfyUI executes).
 
-**One-time setup** (Settings → ComfyUI): turn on **Pause for ComfyUI**, enter your ComfyUI folder
+**One-time setup** (Settings → Network & sharing → ComfyUI): turn on **Pause for ComfyUI**, enter your ComfyUI folder
 (the one containing `custom_nodes`), click **Install gate** (it writes a small custom node wired to
 this daemon), then **restart ComfyUI** once. The panel shows a live indicator (rendering / idle /
 connected); **Remove** undoes it.
@@ -331,7 +333,7 @@ daemon any time with **Ctrl+C**.
 No other local-LLM app lets you run **whatever inference engine you want**. TurboLLM treats
 the engine as a swappable component.
 
-**Add a custom engine** (Engines screen → **Add engine**):
+**Add a custom engine** (Engines screen → **Add your own engine**):
 
 1. Compile or download any `llama-server`-compatible binary — stock
    [llama.cpp](https://github.com/ggml-org/llama.cpp), a community fork, or your own build.
@@ -396,13 +398,14 @@ any OpenAI- or Anthropic-compatible tool (Open WebUI, Kilo Code, opencode, …).
 ## Use it from any device on your network
 
 The UI runs in the browser, so any phone, tablet, or laptop on your LAN can use the model on
-your GPU box:
+your GPU box — every screen is responsive down to phone widths, with the desktop layout
+untouched:
 
 ```bash
 turbollm --addr 0.0.0.0:6996    # bind all interfaces, then open http://<your-ip>:6996
 ```
 
-Turn on **Require API key** in Settings → Network when you expose it.
+Turn on **Require API key** in Settings → Network & sharing when you expose it.
 
 ---
 

package/dist/chunk-TPYU5ZAX.js

@@ -0,0 +1,175 @@
+#!/usr/bin/env node
+
+// src/agents/distiller.ts
+import { readFileSync, readdirSync, statSync, existsSync } from "fs";
+import { join } from "path";
+
+// src/engines/compat.ts
+function engineAcceptsFormat(engineKind, format) {
+  if (engineKind === "mlx") return format === "mlx";
+  if (engineKind === "vllm") return format === "mlx";
+  return format === "gguf";
+}
+var ENGINE_MODEL_ALIAS = "default_model";
+function engineModelAlias(engineKind) {
+  return engineKind === "mlx" || engineKind === "vllm" || engineKind === "sglang" ? ENGINE_MODEL_ALIAS : null;
+}
+var VENDOR_DISPLAY = {
+  nvidia: "NVIDIA",
+  amd: "AMD",
+  intel: "Intel",
+  apple: "Apple Silicon",
+  unknown: "no detected GPU"
+};
+var PLATFORM_DISPLAY = {
+  darwin: "macOS",
+  win32: "Windows",
+  linux: "Linux"
+};
+function platformName(p) {
+  return PLATFORM_DISPLAY[p] ?? p;
+}
+function platformReason(allowed) {
+  const names = allowed.map(platformName);
+  const joined = names.length <= 1 ? names.join("") : `${names.slice(0, -1).join(", ")} & ${names[names.length - 1]}`;
+  return `${joined} only`;
+}
+function evaluateVariant(p, r) {
+  if (r.platform && !r.platform.includes(p.platform)) {
+    return { ok: false, reason: platformReason(r.platform) };
+  }
+  if (r.arch && !r.arch.includes(p.arch)) {
+    return { ok: false, reason: `Needs ${r.arch.join(" / ")}` };
+  }
+  if (r.gpuVendor && !r.gpuVendor.includes(p.gpuVendor)) {
+    const needs = r.gpuVendor.map((v) => VENDOR_DISPLAY[v]).join(" / ");
+    const article = /^[NAEIO]/.test(needs) ? "an" : "a";
+    return { ok: false, reason: `Needs ${article} ${needs} GPU \u2014 you have ${VENDOR_DISPLAY[p.gpuVendor]}` };
+  }
+  if (r.minVramMb !== void 0 && p.vramMb > 0 && p.vramMb < r.minVramMb) {
+    const gb = Math.round(r.minVramMb / 1024);
+    return { ok: false, reason: `Needs ~${gb} GB VRAM` };
+  }
+  return { ok: true };
+}
+
+// src/agents/distiller.ts
+var DISTILL_SYSTEM = `You write a single reusable SKILL from the material provided. A skill captures a repeatable approach so it can be applied to similar future tasks.
+
+Output a JSON object: {"name": <short kebab-case id>, "description": <one sentence: when to use this skill>, "procedure": <concise step-by-step procedure, markdown>}
+
+Rules:
+- The skill must be GENERAL and reusable, not a one-off answer to this specific input.
+- "name" is a short kebab-case identifier (e.g. "csv-summary", "extract-config-values").
+- "description" is one sentence describing WHEN to apply it.
+- "procedure" is a concise, numbered set of steps \u2014 the how.
+- If the material does not contain a clear reusable approach, output {"name": null, "description": null, "procedure": null}.
+Respond with ONLY the JSON object, nothing else.`;
+async function distill(d, material) {
+  const ms = d.manager.status();
+  const target = d.manager.target();
+  if (ms.state !== "running" || !ms.model || !target) return { name: null, description: null, procedure: null };
+  const model = engineModelAlias(d.registry.active()?.kind ?? "") ?? ms.model.key;
+  try {
+    const res = await fetch(`${target}/v1/chat/completions`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model,
+        messages: [
+          { role: "system", content: DISTILL_SYSTEM },
+          { role: "user", content: `Material:
+
+${material.slice(0, 24e3)}
+
+Write ONE reusable skill as raw JSON \u2014 no markdown fences.` }
+        ],
+        temperature: 0.3,
+        max_tokens: 800,
+        reasoning_budget: 0,
+        chat_template_kwargs: { enable_thinking: false },
+        response_format: { type: "json_object" },
+        stream: false
+      }),
+      signal: AbortSignal.timeout(9e4)
+    });
+    if (!res.ok) return { name: null, description: null, procedure: null };
+    const data = await res.json();
+    let txt = data.choices?.[0]?.message?.content ?? "";
+    txt = txt.replace(/<think>[\s\S]*?<\/think>/gi, "").replace(/```json|```/gi, "").trim();
+    const m = txt.match(/\{[\s\S]*\}/);
+    if (!m) return { name: null, description: null, procedure: null };
+    const j = JSON.parse(m[0]);
+    const valid = (s) => typeof s === "string" && s.trim() && s.toLowerCase() !== "null" ? s.trim() : null;
+    const name = valid(j.name);
+    const procedure = valid(j.procedure);
+    if (!name || !procedure) return { name: null, description: null, procedure: null };
+    return { name: name.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64), description: valid(j.description) ?? "", procedure };
+  } catch {
+    return { name: null, description: null, procedure: null };
+  }
+}
+function distillFromConversation(d, transcript) {
+  const text = transcript.map((m) => `${m.role.toUpperCase()}: ${m.content}`).join("\n");
+  return distill(d, `A successful completed task:
+
+${text}`);
+}
+var FOLDER_TEXT = /\.(md|txt|json|ya?ml|csv|js|ts|py|sh|html?|css)$/i;
+function collectFolderFiles(folder, max) {
+  const files = [];
+  const walk = (dir, depth) => {
+    if (depth > 4 || files.length >= max) return;
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (files.length >= max) return;
+      const p = join(dir, e.name);
+      if (e.isDirectory()) {
+        walk(p, depth + 1);
+        continue;
+      }
+      if (!FOLDER_TEXT.test(e.name)) continue;
+      try {
+        if (statSync(p).size > 2e5) continue;
+        const content = readFileSync(p, "utf8").slice(0, 6e3).trim();
+        if (content) files.push({ name: e.name, content });
+      } catch {
+      }
+    }
+  };
+  walk(folder, 0);
+  return files;
+}
+async function distillSkillsFromFolder(d, folder, opts = {}) {
+  if (!existsSync(folder) || !statSync(folder).isDirectory()) return [];
+  const max = opts.max ?? 12;
+  const files = collectFolderFiles(folder, max);
+  if (!files.length) return [];
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (let i = 0; i < files.length; i++) {
+    const f = files[i];
+    opts.onProgress?.(i, files.length, f.name);
+    const s = await distill(d, `A reusable approach captured in "${f.name}":
+
+${f.content}`);
+    if (s.name && s.procedure && !seen.has(s.name)) {
+      seen.add(s.name);
+      out.push(s);
+    }
+  }
+  return out;
+}
+
+export {
+  engineAcceptsFormat,
+  engineModelAlias,
+  evaluateVariant,
+  distillFromConversation,
+  distillSkillsFromFolder
+};