localcode 0.5.6__tar.gz → 0.5.8__tar.gz

{localcode-0.5.6/src/localcode.egg-info → localcode-0.5.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localcode
-Version: 0.5.6
+Version: 0.5.8
 Summary: High-performance AI coding on consumer hardware.
 Author: LocalCode contributors
 License-Expression: Apache-2.0
@@ -101,7 +101,7 @@ See [Chat and Decisions](https://mjwsolo.github.io/localcode/guides/decisions).
 
 Docs: [mjwsolo.github.io/localcode](https://mjwsolo.github.io/localcode/)
 
-To use the running model from another local app, run `localcode api` for its
+To use the running model from another local app, open `/server` or run `localcode api` for its
 OpenAI compatible endpoint. See the [Local API guide](https://mjwsolo.github.io/localcode/guides/local-api/).
 
 ## What it does

{localcode-0.5.6 → localcode-0.5.8}/README.md

@@ -53,7 +53,7 @@ See [Chat and Decisions](https://mjwsolo.github.io/localcode/guides/decisions).
 
 Docs: [mjwsolo.github.io/localcode](https://mjwsolo.github.io/localcode/)
 
-To use the running model from another local app, run `localcode api` for its
+To use the running model from another local app, open `/server` or run `localcode api` for its
 OpenAI compatible endpoint. See the [Local API guide](https://mjwsolo.github.io/localcode/guides/local-api/).
 
 ## What it does

{localcode-0.5.6 → localcode-0.5.8}/llama-cpp-turboquant/tools/server/server-common.cpp

@@ -1426,6 +1426,17 @@ json oaicompat_chat_params_parse(
     // Apply chat template to the list of messages
     auto chat_params = common_chat_templates_apply(opt.tmpls.get(), inputs);
 
+    if (opt.no_forced_thinking && !chat_params.thinking_start_tag.empty()) {
+        // see server_chat_params::no_forced_thinking
+        for (const std::string & opener : { chat_params.thinking_start_tag + "\n", chat_params.thinking_start_tag }) {
+            if (string_ends_with(chat_params.generation_prompt, opener) && string_ends_with(chat_params.prompt, opener)) {
+                chat_params.generation_prompt.resize(chat_params.generation_prompt.size() - opener.size());
+                chat_params.prompt.resize(chat_params.prompt.size() - opener.size());
+                break;
+            }
+        }
+    }
+
     llama_params["chat_format"] = static_cast<int>(chat_params.format);
     llama_params["prompt"]      = chat_params.prompt;
     if (!chat_params.grammar.empty()) {

{localcode-0.5.6 → localcode-0.5.8}/llama-cpp-turboquant/tools/server/server-common.h

@@ -348,6 +348,11 @@ struct server_chat_params {
     std::string reasoning_budget_message;
     std::string media_path;
     bool force_pure_content = false;
+    // fork-local (PATCHES.md 0005): canvas diffusion models decide themselves whether to open a
+    // thought block. A thought opener the template appends after a tool response is never closed
+    // by DiffusionGemma, so the parser filed the whole answer as reasoning and the client saw
+    // nothing. Strip such an opener from the prompt and the parser's generation prompt.
+    bool no_forced_thinking = false;
 };
 
 // used by /completions endpoint

{localcode-0.5.6 → localcode-0.5.8}/llama-cpp-turboquant/tools/server/server-context.cpp

@@ -1646,7 +1646,8 @@ private:
                 /* reasoning_budget      */ params_base.sampling.reasoning_budget_tokens,
                 /* reasoning_budget_msg  */ params_base.sampling.reasoning_budget_message,
                 /* media_path            */ params_base.media_path,
-                /* force_pure_content    */ params_base.force_pure_content_parser
+                /* force_pure_content    */ params_base.force_pure_content_parser,
+                /* no_forced_thinking    */ diffusion.enabled
             };
 
             {
@@ -3297,6 +3298,26 @@ private:
                 }
             }
 
+            if (b == 0) {
+                // DiffusionGemma answers a tool result with an EMPTY thought block
+                // ("<|channel>thought\n<channel|>" + answer). The Gemma 4 parser files
+                // the text after an empty block as reasoning, so the client saw no
+                // answer at all. An empty block carries nothing: drop it before parsing.
+                static const std::string open_tag = "<|channel>thought";
+                static const std::string close_tag = "<channel|>";
+                if (string_starts_with(block_text, open_tag)) {
+                    size_t i = open_tag.size();
+                    while (i < block_text.size() && (block_text[i] == '\n' || block_text[i] == ' ')) i++;
+                    if (block_text.compare(i, close_tag.size(), close_tag) == 0) {
+                        block_text.erase(0, i + close_tag.size());
+                    } else if ((ended_on_eog || block_complete) && block_text.find(close_tag, i) == std::string::npos) {
+                        // The whole reply fits one block and the thought is never closed:
+                        // the model wrote its answer inside the block. It is the answer.
+                        block_text.erase(0, i);
+                    }
+                }
+            }
+
             slot.stats.n_gen += cut;
             if (b == 0) {
                 slot.t_print_last = ggml_time_us();

{localcode-0.5.6 → localcode-0.5.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "localcode"
-version = "0.5.6"
+version = "0.5.8"
 description = "High-performance AI coding on consumer hardware."
 readme = "README.md"
 requires-python = ">=3.10"

{localcode-0.5.6 → localcode-0.5.8}/src/localcode/__init__.py

@@ -8,4 +8,4 @@ from importlib.metadata import PackageNotFoundError, version as _pkg_version
 try:
     __version__ = _pkg_version("localcode")
 except PackageNotFoundError:  # not installed (e.g. raw source checkout)
-    __version__ = "0.5.6"
+    __version__ = "0.5.8"

localcode-0.5.8/src/localcode/bin/localcode-ui

@@ -0,0 +1,4 @@
+[diffend] Oversized file quarantined before diffing.
+name: localcode-0.5.8/src/localcode/bin/localcode-ui
+size: 102460976 bytes
+sha256: a09d854109bdb8e9b346777e8fa306afcae9edb32ade0780ccd15a0e15fe3c05

{localcode-0.5.6 → localcode-0.5.8}/src/localcode/bootstrap.py

@@ -1060,6 +1060,55 @@ def download_mmproj(
     return ok, result
 
 
+def download_drafter(
+    choice,
+    on_progress: Callable[[str], None] | None = None,
+    cancel_event: "threading.Event | None" = None,
+) -> tuple[bool, str]:
+    """Download the vendor-trained speculative drafter a catalog entry ships
+    with (`choice.drafter`, see models_catalog.Drafter). Idempotent. Reuses
+    download_model via a proxy entry pointing at the drafter file in its own
+    repo, with the drafter's exact size and sha256 so it is verified like a
+    model. Returns (ok, path_or_error); a model without a drafter is not an
+    error (True, "")."""
+    drafter = getattr(choice, "drafter", None)
+    if drafter is None:
+        return True, ""
+    dest = drafter.local_path
+    if dest.is_file() and dest.stat().st_size == drafter.size_bytes:
+        return True, str(dest)
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    from dataclasses import replace
+    proxy = replace(
+        choice,
+        hf_repo=drafter.hf_repo,
+        revision=drafter.revision,
+        filename=drafter.hf_filename,
+        size_gb=drafter.size_gb,
+        size_bytes=drafter.size_bytes,
+        sha256=drafter.sha256,
+        mmproj_filename=None, mmproj_size_gb=0.0, mmproj_hf_filename=None,
+        drafter=None,
+    )
+    ok, result = download_model(proxy, on_progress=on_progress, cancel_event=cancel_event)
+    if not ok:
+        return ok, result
+    downloaded = Path(result)
+    if downloaded != dest:
+        try:
+            if dest.exists():
+                dest.unlink()
+            downloaded.rename(dest)
+            # the HF path may have put it in a subfolder (MTP/...); drop it if empty
+            try:
+                downloaded.parent.rmdir()
+            except OSError:
+                pass
+        except Exception as e:  # noqa: BLE001
+            return False, f"Couldn't rename drafter to {dest.name}: {e}"
+    return True, str(dest)
+
+
 def _is_mmproj_complete(p: Path, choice) -> bool:
     """Cheap completeness check for the mmproj sidecar — like
     `_is_complete_download` but with 10% slack since catalog mmproj

{localcode-0.5.6 → localcode-0.5.8}/src/localcode/config.py

@@ -41,6 +41,7 @@ llama_cpp_threads = 10
 llama_cpp_batch_size = 2048
 llama_cpp_spec_type = ""
 llama_cpp_draft_max = 64
+llama_cpp_mtp_draft = 4
 llama_cpp_expert_offload = false
 llama_cpp_draft_model = ""
 llama_cpp_lookup_cache = false
@@ -125,7 +126,8 @@ class RuntimeConfig:
     llama_cpp_batch_size: int = -1  # -1 = auto-detect from platform at startup
     # Speed optimizations
     llama_cpp_spec_type: str = ""         # "ngram-mod", "ngram-simple" — speculative decoding (1.5-2x)
-    llama_cpp_draft_max: int = 64         # max draft tokens for speculation
+    llama_cpp_draft_max: int = 64         # max draft tokens for an explicit spec_type / draft model
+    llama_cpp_mtp_draft: int = 4          # draft tokens from the model's vendor-trained drafter (catalog Drafter or in-GGUF MTP head); 0 = off
     llama_cpp_expert_offload: bool = False # offload MoE experts to CPU (-ot exps=CPU)
     llama_cpp_draft_model: str = ""       # path to draft GGUF for speculative decoding
     llama_cpp_lookup_cache: bool = False   # prompt lookup decoding (2-4x on code edits)
@@ -276,6 +278,7 @@ def save_config(config: AppConfig) -> Path:
         f"llama_cpp_batch_size = {config.runtime.llama_cpp_batch_size}\n"
         f'llama_cpp_spec_type = {_toml_str(config.runtime.llama_cpp_spec_type)}\n'
         f"llama_cpp_draft_max = {config.runtime.llama_cpp_draft_max}\n"
+        f"llama_cpp_mtp_draft = {config.runtime.llama_cpp_mtp_draft}\n"
         f"llama_cpp_expert_offload = {'true' if config.runtime.llama_cpp_expert_offload else 'false'}\n"
         f'llama_cpp_draft_model = {_toml_str(config.runtime.llama_cpp_draft_model)}\n'
         f"llama_cpp_lookup_cache = {'true' if config.runtime.llama_cpp_lookup_cache else 'false'}\n"
@@ -389,6 +392,7 @@ def load_config() -> AppConfig:
         # unless the user EXPLICITLY opts in via env var.
         llama_cpp_spec_type=os.environ.get("LOCALCODE_LLAMA_CPP_SPEC_TYPE", ""),
         llama_cpp_draft_max=int(os.environ.get("LOCALCODE_LLAMA_CPP_DRAFT_MAX", runtime_data.get("llama_cpp_draft_max", 64))),
+        llama_cpp_mtp_draft=int(os.environ.get("LOCALCODE_LLAMA_CPP_MTP_DRAFT", runtime_data.get("llama_cpp_mtp_draft", 4))),
         llama_cpp_expert_offload=str(os.environ.get("LOCALCODE_LLAMA_CPP_EXPERT_OFFLOAD", runtime_data.get("llama_cpp_expert_offload", False))).lower() in {"1", "true", "yes", "on"},
         llama_cpp_draft_model=os.environ.get("LOCALCODE_LLAMA_CPP_DRAFT_MODEL", runtime_data.get("llama_cpp_draft_model", "")),
         # `llama_cpp_lookup_cache` migration (2026-04-26): old configs

{localcode-0.5.6 → localcode-0.5.8}/src/localcode/hf_quants.py

@@ -98,8 +98,9 @@ def _quant_from_entry(entry: dict) -> Quant | None:
     # selectable weights.
     if "/" in path:
         return None
-    # Vision projectors and MTP draft heads are sidecars, not pickable models.
-    if lowered.startswith("mmproj") or lowered.startswith("mtp-") or lowered.startswith("mtp_"):
+    # Vision projectors and speculative drafters (MTP heads, DFlash) are
+    # sidecars, not pickable models.
+    if lowered.startswith(("mmproj", "mtp-", "mtp_", "dflash-", "dflash_")):
         return None
     label = _parse_label(path)
     # Real weight quants carry a quant code (Q4_K_M, IQ3_S, BF16, …). Anything

{localcode-0.5.6 → localcode-0.5.8}/src/localcode/models_catalog.py

@@ -35,6 +35,65 @@ def model_dir() -> Path:
 CANONICAL_MODEL_DIR = DEFAULT_MODEL_DIR
 
 
+@dataclass(frozen=True)
+class Drafter:
+    """A vendor-trained speculative drafter for ONE target model (MTP head or
+    DFlash block drafter). It ships with the model: the download that installs
+    the model installs the drafter too, and the launcher passes it as
+    `--model-draft` with its `--spec-type`. Every drafted token is verified by
+    the target, so the output is the target's own; measured 1.5x to 2.3x decode
+    on Apple Silicon. Only drafters trained for the exact model are listed:
+    a generic small model as drafter is what failed in the past.
+    """
+    filename: str          # local name (unique across families)
+    hf_repo: str           # repo that ships it (may differ from the model's)
+    hf_filename: str       # path inside that repo
+    spec_type: str         # llama-server --spec-type: "draft-mtp" | "draft-dflash"
+    size_gb: float
+    size_bytes: int        # exact, from the HF API (download completeness)
+    sha256: str            # verified after download
+    revision: str = "main"
+
+    @property
+    def local_path(self) -> Path:
+        return model_dir() / self.filename
+
+
+# Verified live 2026-10-09 (greedy, same coding prompt, bundled v0.6.0 server):
+# gemma-4-12b Q4_K_XL 55 -> 120-139 tok/s; Qwen3.6-35B IQ2_M 129 -> 224 (DFlash);
+# Muse Glimmer Q4_K_XL 30 -> 45 (DFlash). Qwen 3.8 27B carries its head inside
+# the GGUF (`nextn_predict_layers`) and needs no file.
+DRAFTER_GEMMA_12B = Drafter(
+    filename="mtp-gemma-4-12b-it-Q8_0.gguf", hf_repo="unsloth/gemma-4-12b-it-GGUF",
+    hf_filename="MTP/mtp-gemma-4-12b-it-Q8_0.gguf", spec_type="draft-mtp",
+    size_gb=0.47, size_bytes=465109248,
+    sha256="145db9094bc0f85f1701e255a2ed216dcc9800fc8bc8631ad00905b456bd451b",
+    revision="fc034cfff751157913579611efad8462ac1be606",
+)
+DRAFTER_GEMMA_26B = Drafter(
+    filename="mtp-gemma-4-26B-A4B-it-Q8_0.gguf", hf_repo="unsloth/gemma-4-26B-A4B-it-GGUF",
+    hf_filename="MTP/mtp-gemma-4-26B-A4B-it-Q8_0.gguf", spec_type="draft-mtp",
+    size_gb=0.46, size_bytes=461766816,
+    sha256="6326fb9f5e487aa8dcdd313a091e3c67724cb2a666ec3b7d2895b5b26d93ed1b",
+    revision="c099eb48e663fd284577b04978a94ffccb261841",
+)
+DRAFTER_QWEN36 = Drafter(
+    filename="dflash-Qwen3.6-35B-A3B-Q8_0.gguf", hf_repo="ggml-org/Qwen3.6-35B-A3B-GGUF",
+    hf_filename="dflash-Qwen3.6-35B-A3B-Q8_0.gguf", spec_type="draft-dflash",
+    size_gb=0.42, size_bytes=421060800,
+    sha256="339030c9dad4f410c7ef2d6cbd6e38251a84fabb59c44db992538c2451a0efee",
+    revision="baec3ebee244827cda0f4557eafa8b28f7545fa6",
+)
+DRAFTER_MUSE = Drafter(
+    filename="dflash-Muse-Glimmer-30B-Q4_0.gguf", hf_repo="ggml-org/Muse-Glimmer-30B-GGUF",
+    hf_filename="dflash-Muse-Glimmer-30B-Q4_0.gguf", spec_type="draft-dflash",
+    size_gb=1.45, size_bytes=1451096896,
+    sha256="048242c69254627fc11226c9f68dc34fbc82eac1c026ef148c9dbd2f90686db2",
+    revision="c286f180ef572621f5395b55da2d3e3d53d5972e",
+)
+DRAFTERS: list[Drafter] = [DRAFTER_GEMMA_12B, DRAFTER_GEMMA_26B, DRAFTER_QWEN36, DRAFTER_MUSE]
+
+
 @dataclass(frozen=True)
 class ModelChoice:
     key: str               # short id used in config (e.g. "gemma", "qwen")
@@ -99,6 +158,8 @@ class ModelChoice:
     preserves_reasoning: bool = True
     supports_parallel_tools: bool = False
     supports_systemone: bool = False
+    # Vendor-trained speculative drafter shipped with the model (see Drafter).
+    drafter: Drafter | None = None
 
     @property
     def hf_url(self) -> str:
@@ -213,6 +274,7 @@ CHOICES: list[ModelChoice] = [
         mmproj_filename="mmproj-gemma-4-26B-A4B-F16.gguf",
         mmproj_size_gb=1.2,
         mmproj_hf_filename="mmproj-F16.gguf",
+        drafter=DRAFTER_GEMMA_26B,
     ),
     ModelChoice(
         key="gemma-12b",
@@ -237,6 +299,7 @@ CHOICES: list[ModelChoice] = [
         mmproj_filename="mmproj-gemma-4-12b-F16.gguf",
         mmproj_size_gb=0.18,  # 175 MB on HF as of 2026-09 (repo re-exported the projector)
         mmproj_hf_filename="mmproj-F16.gguf",
+        drafter=DRAFTER_GEMMA_12B,
     ),
     ModelChoice(
         key="gemma-12b-bf16",
@@ -262,6 +325,7 @@ CHOICES: list[ModelChoice] = [
         mmproj_filename="mmproj-gemma-4-12b-F16.gguf",
         mmproj_size_gb=0.18,  # 175 MB on HF as of 2026-09
         mmproj_hf_filename="mmproj-F16.gguf",
+        drafter=DRAFTER_GEMMA_12B,
     ),
     ModelChoice(
         key="qwen",
@@ -279,6 +343,7 @@ CHOICES: list[ModelChoice] = [
         mmproj_filename="mmproj-Qwen3.6-35B-A3B-F16.gguf",
         mmproj_size_gb=0.9,
         mmproj_hf_filename="mmproj-F16.gguf",
+        drafter=DRAFTER_QWEN36,
     ),
     ModelChoice(
         key="diffusiongemma",
@@ -350,6 +415,7 @@ CHOICES: list[ModelChoice] = [
         mmproj_hf_filename="mmproj-Muse-Glimmer-30B-BF16.gguf",
         reasoning_control="always",
         reasoning_budget_tokens=0,
+        drafter=DRAFTER_MUSE,
     ),
     ModelChoice(
         key="gemma-q8",
@@ -367,6 +433,7 @@ CHOICES: list[ModelChoice] = [
         mmproj_filename="mmproj-gemma-4-26B-A4B-F16.gguf",
         mmproj_size_gb=1.2,
         mmproj_hf_filename="mmproj-F16.gguf",
+        drafter=DRAFTER_GEMMA_26B,
     ),
     ModelChoice(
         key="qwen-q8",
@@ -384,6 +451,7 @@ CHOICES: list[ModelChoice] = [
         mmproj_filename="mmproj-Qwen3.6-35B-A3B-F16.gguf",
         mmproj_size_gb=0.9,
         mmproj_hf_filename="mmproj-F16.gguf",
+        drafter=DRAFTER_QWEN36,
     ),
     ModelChoice(
         key="qwen38",
@@ -676,6 +744,8 @@ class ModelGroup:
     mmproj_hf_filename: str | None = None
 
     supports_systemone: bool = False
+    # Vendor-trained speculative drafter, same file for every quant of the model.
+    drafter: Drafter | None = None
 
     @property
     def supports_vision(self) -> bool:
@@ -699,6 +769,7 @@ MODEL_GROUPS: list[ModelGroup] = [
         mmproj_filename="mmproj-gemma-4-26B-A4B-F16.gguf",
         mmproj_size_gb=1.2,
         mmproj_hf_filename="mmproj-F16.gguf",
+        drafter=DRAFTER_GEMMA_26B,
     ),
     ModelGroup(
         key="gemma-4-12b",
@@ -716,6 +787,7 @@ MODEL_GROUPS: list[ModelGroup] = [
         mmproj_filename="mmproj-gemma-4-12b-F16.gguf",
         mmproj_size_gb=0.18,  # 175 MB on HF as of 2026-09 (repo re-exported the projector)
         mmproj_hf_filename="mmproj-F16.gguf",
+        drafter=DRAFTER_GEMMA_12B,
     ),
     ModelGroup(
         key="qwen-3.6-35b-a3b",
@@ -734,6 +806,7 @@ MODEL_GROUPS: list[ModelGroup] = [
         mmproj_filename="mmproj-Qwen3.6-35B-A3B-F16.gguf",
         mmproj_size_gb=0.9,
         mmproj_hf_filename="mmproj-F16.gguf",
+        drafter=DRAFTER_QWEN36,
     ),
     ModelGroup(
         key="qwen-3.8-27b",
@@ -789,6 +862,7 @@ MODEL_GROUPS: list[ModelGroup] = [
         mmproj_filename="mmproj-Muse-Glimmer-30B-BF16.gguf",
         mmproj_size_gb=3.85,
         mmproj_hf_filename="mmproj-Muse-Glimmer-30B-BF16.gguf",
+        drafter=DRAFTER_MUSE,
     ),
     ModelGroup(
         key="diffusiongemma-26b-a4b",
@@ -898,6 +972,7 @@ def choice_for_quant(group: ModelGroup, filename: str, size_gb: float) -> ModelC
         mmproj_size_gb=group.mmproj_size_gb,
         mmproj_hf_filename=group.mmproj_hf_filename,
         supports_systemone=group.supports_systemone,
+        drafter=group.drafter,
         reasoning_control=canonical.reasoning_control if canonical else "chat_template",
         reasoning_budget_tokens=canonical.reasoning_budget_tokens if canonical else 8192,
         preserves_reasoning=canonical.preserves_reasoning if canonical else True,

{localcode-0.5.6 → localcode-0.5.8}/src/localcode/runtime.py

@@ -489,17 +489,43 @@ class LocalCodeRuntimeGateway:
         # Speculative decoding (mutual exclusion: draft model > lookup > ngram).
         # Speculative decoding is LOSSLESS — every drafted token is verified
         # against the real model, so output is identical, just faster.
+        # `--draft-max` was removed upstream (2026); the flag is `--spec-draft-n-max`.
+        spec_type = (self.config.llama_cpp_spec_type or "").strip()
         if self.config.llama_cpp_draft_model:
             draft_path = self.config.llama_cpp_draft_model
             cmd.extend(["--model-draft", draft_path,
-                        "--draft-max", str(self.config.llama_cpp_draft_max)])
+                        "--spec-draft-n-max", str(self.config.llama_cpp_draft_max)])
         elif self.config.llama_cpp_lookup_cache:
             # Prompt lookup decoding: matches n-grams from input in output (2-4x on edits)
             cmd.extend(["--lookup-cache-dynamic", "/tmp/localcode-lookup.bin"])
-        elif self.config.llama_cpp_spec_type and self.config.llama_cpp_spec_type != "none":
-            cmd.extend(["--spec-type", self.config.llama_cpp_spec_type,
-                        "--draft-max", str(self.config.llama_cpp_draft_max)])
-        # NO speculative decoding by default. An empty `llama_cpp_spec_type`
+        elif spec_type and spec_type != "none":
+            cmd.extend(["--spec-type", spec_type,
+                        "--spec-draft-n-max", str(self.config.llama_cpp_draft_max)])
+        elif (not spec_type and self.config.llama_cpp_mtp_draft > 0
+              and self._catalog_drafter_path(model_path) is not None):
+            # A vendor-trained drafter shipped with the model (catalog
+            # `Drafter`: Gemma 4 MTP heads, Qwen 3.6 / Muse DFlash). Downloaded
+            # with the model; only used when the file is present and complete.
+            drafter, path = self._catalog_drafter_path(model_path)
+            cmd.extend(["--model-draft", str(path), "--spec-type", drafter.spec_type])
+            if drafter.spec_type == "draft-mtp":
+                # A DFlash drafter emits a whole block per step; its length is
+                # the drafter's own. MTP drafts token by token: 4 measured best.
+                cmd.extend(["--spec-draft-n-max", str(self.config.llama_cpp_mtp_draft)])
+        elif (not spec_type and self.config.llama_cpp_mtp_draft > 0
+              and self._gguf_mtp_layers(model_path) > 0):
+            # The model ships its own multi-token-prediction head(s)
+            # (`<arch>.nextn_predict_layers` > 0, e.g. Qwen 3.8 27B). Drafting
+            # from that head is lossless (every draft token is verified by the
+            # target) and needs no second model. Measured on Qwen 3.8 27B
+            # Q4_K_XL, Apple Silicon: 24-26 tok/s -> 43-49 tok/s at 4 draft
+            # tokens (89% accepted), identical output; 8 tokens is slower
+            # (30 tok/s) because the misses cost more than the hits save.
+            # `llama_cpp_spec_type = "none"` or `llama_cpp_mtp_draft = 0`
+            # turns it off. Models without the metadata are untouched.
+            cmd.extend(["--spec-type", "draft-mtp",
+                        "--spec-draft-n-max", str(self.config.llama_cpp_mtp_draft)])
+        # Otherwise NO speculative decoding. An empty `llama_cpp_spec_type`
         # means OFF — NOT a cue to fall back to in-context n-gram decoding.
         # The previous default here emitted `--spec-type ngram-mod`, which
         # directly contradicted config.py's force-disable of spec_type (added
@@ -789,7 +815,7 @@ class LocalCodeRuntimeGateway:
                         wanted = (
                             ".block_count", ".attention.head_count_kv",
                             ".attention.head_count", ".attention.key_length",
-                            ".embedding_length",
+                            ".embedding_length", ".nextn_predict_layers",
                         )
                         for _ in range(n_kv):
                             k = _rs()
@@ -809,12 +835,55 @@ class LocalCodeRuntimeGateway:
                                 "n_layers": n_layers,
                                 "n_kv_heads": n_kv_heads,
                                 "head_dim": head_dim,
+                                # Multi-token-prediction heads shipped inside
+                                # the GGUF (Qwen 3.6+/3.8 `nextn_predict_layers`).
+                                "n_mtp_layers": found.get(".nextn_predict_layers", 0),
                             }
         except Exception:
             meta = None
         cache[path] = meta
         return meta
 
+    def _catalog_drafter_path(self, model_path: str | None):
+        """(Drafter, path) for the catalog drafter of this GGUF when the file is
+        on disk with its exact size, else None."""
+        try:
+            from pathlib import Path as _P
+            from .models_catalog import by_filename, MODEL_GROUPS, choice_for_quant
+            name = _P(str(model_path or "")).name
+            choice = by_filename(name)
+            drafter = getattr(choice, "drafter", None) if choice is not None else None
+            if drafter is None:
+                # a browsed quant of a group that ships a drafter
+                for g in MODEL_GROUPS:
+                    if getattr(g, "drafter", None) is not None and self._gguf_in_group(name, g):
+                        drafter = g.drafter
+                        break
+            if drafter is None:
+                return None
+            path = drafter.local_path
+            if not path.is_file() or path.stat().st_size != drafter.size_bytes:
+                return None
+            return drafter, path
+        except Exception:
+            return None
+
+    @staticmethod
+    def _gguf_in_group(name: str, group) -> bool:
+        """Does a (browsed) quant filename belong to this group's repo listing?
+        Cheap heuristic on the repo's model name prefix."""
+        stem = group.hf_repo.split("/", 1)[-1].removesuffix("-GGUF").lower()
+        return name.lower().startswith(stem.lower())
+
+    def _gguf_mtp_layers(self, model_path: str | None = None) -> int:
+        """Number of multi-token-prediction (MTP) draft layers stored in the
+        GGUF, 0 when there are none or the file can't be read."""
+        meta = self._gguf_kv_meta(model_path)
+        try:
+            return int((meta or {}).get("n_mtp_layers", 0) or 0)
+        except (TypeError, ValueError):
+            return 0
+
     def _kv_bytes_per_token(self, model_path: str | None = None) -> float | None:
         """KV-cache bytes per token = n_layers × n_kv_heads × head_dim ×
         (bytes_K + bytes_V). Returns None when the metadata or the launched

localcode-0.5.8/src/localcode/ui/api.py

@@ -0,0 +1,85 @@
+"""Discover the authenticated local model API for use by other tools."""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+import urllib.request
+import urllib.error
+
+from . import run_dir
+from .auth import read_auth_file, control_headers
+from .ports import find_running, save_port
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="localcode api",
+        description="Show the OpenAI compatible API of a running LocalCode session.",
+    )
+    parser.add_argument("--json", action="store_true", help="Print machine readable connection details")
+    parser.add_argument("--show-key", action="store_true", help="Include the server API key in the output")
+    parser.add_argument("--port", help="Change the live API port, or save it for startup (1024–65535 or auto)")
+    args = parser.parse_args(argv)
+    if args.port is not None:
+        try:
+            port = None if args.port == "auto" else int(args.port)
+            if port is not None and not 1024 <= port <= 65535:
+                raise ValueError("Port must be between 1024 and 65535, or auto")
+            running = find_running()
+            if running is None:
+                save_port(port)
+                print("API port saved for the next launch; no running LocalCode service was found.")
+                return 0
+            auth = read_auth_file(run_dir())
+            if not auth:
+                raise ValueError("Cannot authenticate to the running service; port unchanged")
+            request = urllib.request.Request(
+                f"http://127.0.0.1:{running[0]}/server/port",
+                data=json.dumps({"port": port}).encode(),
+                headers={**control_headers(auth[0]), "Content-Type": "application/json"},
+            )
+            with urllib.request.urlopen(request, timeout=5) as response:
+                result = json.load(response)
+            print(f"API moved to {result['base_url']}. Update external clients to this address; LocalCode stays connected.")
+            return 0
+        except urllib.error.HTTPError as exc:
+            try:
+                message = json.loads(exc.read()).get("error", str(exc))
+            except (ValueError, OSError):
+                message = str(exc)
+            print(f"localcode: {message}", file=sys.stderr)
+            return 1
+        except (ValueError, OSError, KeyError) as exc:
+            print(f"localcode: {exc}. Run `localcode api` to check the current address.", file=sys.stderr)
+            return 1
+
+    running = find_running()
+    if running is None:
+        print("localcode: no running model server; start `localcode` first", file=sys.stderr)
+        return 1
+    _, status = running
+    auth = read_auth_file(run_dir())
+    if auth is None or not auth[1]:
+        print("localcode: the running server's API key is unavailable", file=sys.stderr)
+        return 1
+    port = int(status["port"])
+    alias = status.get("current") or None
+    info = {
+        "base_url": f"http://127.0.0.1:{port}/v1",
+        "model": f"localcode/{alias}" if alias else None,
+        "state": status.get("state"),
+    }
+    if args.show_key:
+        info["api_key"] = auth[1]
+    if args.json:
+        print(json.dumps(info))
+    else:
+        print(f"Base URL: {info['base_url']}")
+        print(f"Model: {info['model'] or '(none loaded)'}")
+        print(f"State: {info['state'] or 'unknown'}")
+        if args.show_key:
+            print(f"API key: {info['api_key']}")
+        else:
+            print("Use --show-key to include the API key.")
+    return 0