turbollm 1.13.6 → 1.14.0

package/README.md

@@ -368,6 +368,25 @@ there. Entirely local; nothing leaves your machine.
 
 </details>
 
+<details>
+<summary><strong>🧠 Jev — ask structured questions about any text, locally</strong></summary>
+
+<br/>
+
+- **Load an NLI model (such as OpenJev) and TurboLLM detects it as a Jev model.** Workspace turns
+  into a JSON-first playground: two editors — the content, and the questions you're asking about
+  it — *are* the request. Ctrl/Cmd+Enter to run; see the answers per question, the raw response,
+  and a copyable `curl`.
+- **`POST /v1/systemone`** answers yes/no, pick-one, and scale questions in one call, using the
+  public System One API's exact field names — a client written for that shape only changes its
+  base URL and key. `POST /v1/classify` and `POST /v1/rerank` are there too for raw
+  premise/hypothesis work.
+- **Honestly labelled:** answers are the model's NLI entailment scores, not a calibrated decision
+  model, and the docs explain exactly how each number is computed.
+- Runs on vLLM (Linux or WSL2). Full guide: <https://turbollm.dev/docs/jev>.
+
+</details>
+
 <details>
 <summary><strong>🔌 APIs &amp; integrations — OpenAI + Anthropic, a model-loading gateway, and a stateful chat API</strong></summary>
 

package/dist/{chunk-FJDRILNH.js → chunk-IX5FQWMQ.js}

@@ -195,6 +195,14 @@ function resolveChatUpstream(d, requestedModel) {
   if (ms.state !== "running" || !ms.model) {
     return { ok: false, status: 409, code: "model_not_loaded", message: "Load a model first." };
   }
+  if (d.scanner.get(ms.model.key)?.jev) {
+    return {
+      ok: false,
+      status: 409,
+      code: "jev_model_loaded",
+      message: "A Jev model is loaded \u2014 it labels text and cannot chat. Switch to a chat model, or use the Jev Playground."
+    };
+  }
   const target = d.manager.target();
   if (!target) {
     return { ok: false, status: 409, code: "model_not_loaded", message: "Engine not running." };
@@ -1909,7 +1917,7 @@ var CREATE_ROUTINE_TOOL = {
         prompt: { type: "string", description: "The task to run, in the same words a user would ask it." },
         scheduleDisplay: { type: "string", description: 'Human-readable schedule, e.g. "Runs weekdays at 9:00 AM". Must accurately describe scheduleRule.' },
         scheduleRule: SCHEDULE_RULE_SCHEMA,
-        modelKey: { type: "string", description: `One of TurboLLM's own model keys \u2014 a compound id (e.g. "gemma 4 26b a4b qat|Q4_0|14439362752"), never a generic name like "gpt-4" or "claude". Call list_models first if you don't already know a real one; never guess.` },
+        modelKey: { type: "string", description: `One of TurboLLM's own model keys \u2014 a compound id (e.g. "gemma 4 26b a4b qat|Q4_0|14439362752"), never a generic name like "gpt-4" or "claude". Call list_models first if you don't already know a real one; never guess. Never pick a model list_models marks "kind: jev" \u2014 it labels text and cannot run a routine.` },
         agentId: { type: "string", description: 'Required when flavor is "chat": an existing Customize -> Agents persona id.' },
         workspacePath: { type: "string", description: 'Required when flavor is "code": absolute path to the workspace directory.' },
         // Driven off schema.ts's list, not a second hand-maintained copy: this enum is what a MODEL
@@ -3602,6 +3610,11 @@ var CodeRunManager = class {
     }
     return false;
   }
+  /** Every session mid-turn (running or queued) — the per-session form of {@link anyActive}, for
+   *  the active-work probe that names what a model load would interrupt (ADR-434 (i)(3)). */
+  activeSessionIds() {
+    return [...this.sessions.keys()].filter((id) => this.isActive(id));
+  }
   /** The turns currently WAITING behind the active turn (not the running one) — the server-side
    *  message queue, surfaced to the UI so its "Queued" chips survive a disconnect. `userMsgId`
    *  (not just index) identifies each entry so a per-chip action (sendNow) can target one

package/dist/{chunk-5IU2DOOW.js → chunk-J24U6O5Q.js}

@@ -5,6 +5,42 @@ import { readFileSync, readdirSync, statSync, existsSync } from "fs";
 import { join } from "path";
 
 // src/engines/compat.ts
+function modelIncompatibility(engineKind, entry) {
+  if (entry.jev && engineKind !== "vllm") return NEEDS_VLLM;
+  if (!engineAcceptsFormat(engineKind, entry.format)) return formatIncompatibility(engineKind, entry.format);
+  if (entry.audio && engineRejectsAudioModel(engineKind)) return audioIncompatibility(engineKind);
+  return null;
+}
+var NEEDS_VLLM = {
+  code: "needs_vllm",
+  label: "Needs vLLM (Linux or WSL2)",
+  message: "This is a Jev model \u2014 it runs only on vLLM (Linux or WSL2). Activate a vLLM engine to load it."
+};
+var NEEDS_PYTHON_ENGINE_LABEL = "needs MLX or vLLM";
+function formatIncompatibility(engineKind, format) {
+  const label = format === "gguf" ? "needs llama.cpp" : NEEDS_PYTHON_ENGINE_LABEL;
+  return { code: "format", label, message: formatMismatchMessage(engineKind, format) };
+}
+function formatMismatchMessage(engineKind, format) {
+  if (engineKind === "mlx")
+    return "The active engine is MLX \u2014 pick a safetensors model, or switch to a llama.cpp engine for GGUF.";
+  if (engineKind === "rapid-mlx")
+    return "The active engine is Rapid-MLX \u2014 pick a safetensors model, or switch to a llama.cpp engine for GGUF.";
+  if (engineKind === "mlx-vlm")
+    return "The active engine is MLX-VLM \u2014 pick a safetensors model, or switch to a llama.cpp engine for GGUF.";
+  if (engineKind === "vllm")
+    return "The active engine is vLLM \u2014 pick a safetensors / HF model, or switch to a llama.cpp engine for GGUF.";
+  return format === "mlx" ? "This is a safetensors model \u2014 activate an MLX or vLLM engine to load it." : "The active engine can only load GGUF models.";
+}
+function audioIncompatibility(engineKind) {
+  const engineLabel = engineKind === "mlx-vlm" ? "MLX-VLM" : "Rapid-MLX";
+  const certainty = engineKind === "mlx-vlm" ? "is expected to fail" : "fails";
+  return {
+    code: "audio",
+    label: NEEDS_PYTHON_ENGINE_LABEL,
+    message: `${engineLabel} cannot load models with an audio tower \u2014 the audio encoder ${certainty} due to an upstream mlx-vlm bug in the sanitizer for these architectures. Switch to the MLX engine instead.`
+  };
+}
 function engineAcceptsFormat(engineKind, format) {
   if (engineKind === "mlx") return format === "mlx";
   if (engineKind === "rapid-mlx") return format === "mlx";
@@ -178,8 +214,8 @@ ${f.content}`);
 }
 
 export {
-  engineAcceptsFormat,
-  engineRejectsAudioModel,
+  modelIncompatibility,
+  ENGINE_MODEL_ALIAS,
   engineModelAlias,
   evaluateVariant,
   distillFromConversation,