chore(recon): re-pin to squashed release commits (voice 1db1759, face e22260d)

Both engine repos were squashed to a single release commit and force-pushed, which
orphaned the previous pins (voice 30beecd, face 6107a24). Re-pin to the new
single-commit SHAs. These also fold in a real fix: the persistent graph-cache
fingerprint now includes op_params, so two structurally identical GGML_OP_CUSTOM
graphs (e.g. a blocked 3x3 vs a blocked 1x1 strided conv) can no longer false-hit
the cache and replay the wrong kernel. voice CI is now green (was failing
conv1x1_s2 with an out-of-bounds write on the GGML_NATIVE=OFF build); face stays
green. WeSpeaker embed parity 1.0 vs golden.

Signed-off-by: Ettore Di Giacinto <mudler@localai.io>
Assisted-by: Claude:claude-opus-4-8 [Claude Code]

.agents/adding-backends.md

@@ -34,7 +34,7 @@ The build matrix is data-only YAML at `.github/backend-matrix.yml` (not inside `
 
 **Without an entry here no image is ever built or pushed, and the gallery entry in `backend/index.yaml` will point at a tag that does not exist.** The `dockerfile:` field must point at `./backend/Dockerfile.<lang>` matching the language bucket from step 1 (e.g. `Dockerfile.python`, `Dockerfile.golang`, `Dockerfile.rust`). The `tag-suffix` must match the `uri:` in the corresponding `backend/index.yaml` image entry exactly.
 
-**Path-filter registration — REQUIRED for any new dockerfile suffix.** This is the single most common omission, because it has no effect on the PR that adds the backend (when no prior path filter could catch it anyway) — it only breaks the *next* PR that touches your backend's directory, which then gets zero CI jobs and looks broken for unrelated reasons. Edit `scripts/lib/backend-filter.mjs:inferBackendPath` and add a branch BEFORE the more-generic suffixes:
+**`scripts/changed-backends.js` registration — REQUIRED for any new dockerfile suffix.** This is the single most common omission, because it has no effect on the PR that adds the backend (when no prior path filter could catch it anyway) — it only breaks the *next* PR that touches your backend's directory, which then gets zero CI jobs and looks broken for unrelated reasons. Edit `scripts/changed-backends.js:inferBackendPath` and add a branch BEFORE the more-generic suffixes:
 
 ```js
 if (item.dockerfile.endsWith("<your-dockerfile-suffix>")) {
@@ -54,9 +54,7 @@ for (const e of m.include.filter(e => e.backend === '<your-backend>')) {
 }"
 ```
 
-A quick way to find the right insertion point: `grep -n 'item.dockerfile.endsWith' scripts/lib/backend-filter.mjs`.
-
-If your backend consumes a *shared* build input that lives outside its own directory (a new script under `scripts/build/`, a new file copied into every image), add a rule to `SHARED_BUILD_INPUTS` in the same file — the per-backend prefix match cannot see those, and a miss ships your change to no image at all. See `scripts/lib/backend-filter_test.mjs` for the pattern; `make test-ci-scripts` runs it.
+A quick way to find the right insertion point: `grep -n 'item.dockerfile.endsWith' scripts/changed-backends.js`.
 
 **`bump_deps.yaml` registration — REQUIRED for any backend pinning an upstream commit.** If your backend's Makefile has a `*_VERSION?=<sha>` pin to a third-party repo, the daily auto-bump bot at `.github/workflows/bump_deps.yaml` won't notice it unless you register the backend in its matrix. The bot runs `.github/bump_deps.sh` which `grep`s for `^$VAR?=` in the Makefile you list — so the pin MUST live in the Makefile (not in a separate shell script). The bump for ds4 (#9761) had to walk this back because the original landed the pin in `prepare.sh`, which the bot can't see. Pattern (for `antirez/ds4`):
 
@@ -104,24 +102,6 @@ Multi-arch backends are NOT a single matrix entry with `platforms: 'linux/amd64,
 
 Entries whose `dockerfile` is `./backend/Dockerfile.{llama-cpp,ik-llama-cpp,turboquant}` must also set a `builder-base-image` field pointing at a prebuilt base from `quay.io/go-skynet/ci-cache:base-grpc-*` (CI builds these via `.github/workflows/base-images.yml`). The mapping is by `(build-type, platforms)` — see existing entries for the pattern. CI uses these prebuilt bases to skip the gRPC compile (~25–35 min cold). Local `make backends/<name>` ignores `builder-base-image` and uses the from-source path inside the Dockerfile, so you don't need quay access for local builds.
 
-### Cover every OS the project supports (Linux **and** Darwin)
-
-`.github/backend-matrix.yml` has two matrices, and they are the source of truth for which OS a backend ships on:
-
-- `include:` — the **Linux** matrix (x86_64 + arm64; CPU and CUDA / ROCm / SYCL / Vulkan).
-- `includeDarwin:` — the **macOS / Apple Silicon** matrix (arm64; Metal where the engine supports it, otherwise a native arm64 CPU build).
-
-**A new backend must target every OS it can build for — do not ship Linux-only by default.** A backend that appears only under `include:` is silently unavailable on macOS even when its code would run there. Most C/C++/GGML engines build on Darwin out of the box (ggml defaults `GGML_METAL=ON` on Apple, so a plain build is Metal-enabled), and many Python backends do too (CPU / MPS wheels). If a backend genuinely cannot support an OS (e.g. CUDA-only, no CPU variant), state that in the PR description instead of omitting it silently.
-
-Wiring a backend into `includeDarwin:` is more than the matrix entry:
-
-1. **`includeDarwin:` entry** — `tag-suffix: "-metal-darwin-arm64-<backend>"`, `build-type: "metal"`, `lang: "go"` for go+ggml backends; omit `build-type` for the bespoke C++ ones (llama-cpp / ds4 / privacy-filter). Match an existing entry of the same shape.
-2. **`backend/index.yaml`** — add `metal:` to the backend's `capabilities` map (main and `-development`) and concrete `metal-<backend>` / `metal-<backend>-development` image entries pointing at the `-metal-darwin-arm64-<backend>` images.
-3. **C/C++ backends only** — add an `inferBackendPathDarwin` case in `scripts/lib/backend-filter.mjs` returning `backend/cpp/<backend>/` (the generic fallthrough assumes `backend/<lang>/`, which is wrong for a C++ source tree driven with `lang: go`), and give `run.sh` a Darwin branch that exports `DYLD_LIBRARY_PATH` instead of `LD_LIBRARY_PATH`. If the build is bespoke (single `grpc-server` + dylib bundling), model it on `scripts/build/ds4-darwin.sh` and add a `backends/<backend>-darwin` make target plus a gated step in `.github/workflows/backend_build_darwin.yml`.
-4. **C++ proto gotcha** — if the backend compiles the generated gRPC/protobuf in a separate CMake target (e.g. `hw_grpc_proto`), that target must link `protobuf::libprotobuf` + `gRPC::grpc++` so the Homebrew include dirs propagate; otherwise macOS fails with `google/protobuf/runtime_version.h not found` (Linux hides this because apt headers sit in `/usr/include`).
-
-The CI path filter only builds a backend on a PR when a file under its directory changes, so a darwin-only YAML edit builds nothing — touch a file under `backend/<lang>/<backend>/` (a one-line comment is enough) in the same PR.
-
 ## 3. Add Backend Metadata to `backend/index.yaml`
 
 **Step 3a: Add Meta Definition**
@@ -218,69 +198,6 @@ docker-build-backends: ... docker-build-<backend-name>
 - If the backend is in `backend/python/<backend-name>/` but uses `.` as context in the workflow file, use `.` context
 - Check similar backends to determine the correct context
 
-## Engine preference for gallery model variants
-
-A gallery entry can declare `variants`, alternative builds of the same weights,
-and LocalAI picks one per host: it drops builds whose backend cannot run here or
-that do not fit memory, then ranks the survivors by **engine preference
-first, serving feature second, size third** (`SelectVariant` in
-`core/gallery/resolve_variant.go`).
-
-Ask whether your backend should outrank another one on some hardware. If it
-should, add it to `engineNamePreferenceRules` in `pkg/system/capabilities.go`,
-best engine first for that capability:
-
-```go
- 	{Nvidia, []string{engineVLLM, engineSGLang, engineLlamaCpp}},
-+	{Nvidia, []string{engineVLLM, engineSGLang, engineMyEngine, engineLlamaCpp}},
-```
-
-That is the ENGINE NAME table, matched as a substring of a gallery entry's
-`backend:` value. Two sibling tables in the same file speak different
-vocabularies and are matched against different things:
-
-| Table | Vocabulary | Matched against | Consumer |
-|-------|-----------|-----------------|----------|
-| `backendBuildTagPreferenceRules` | build tags (`cuda`, `rocm`, `metal`) | installed build directory names, as a substring | alias resolution in `ListSystemBackends` |
-| `engineNamePreferenceRules` | engine names (`vllm`, `llama-cpp`, `mlx`) | a gallery entry's `backend:`, as a substring | gallery variant ranking |
-| `servingFeaturePreferenceTokens` | serving features (`dflash`, `mtp`) | a gallery entry's `tags:`, compared whole and case-insensitively, and nothing else | gallery variant ranking, one rank below the engine |
-
-**Putting a token in the wrong table matches nothing and does not error**: every
-candidate scores equal and the next sort key decides, so the preference silently
-stops existing. The block comment above all three tables spells the contract out.
-
-The serving feature table is the odd one: it is not keyed by capability, because
-no hardware prefers a plain build over an equivalent faster build of the same
-weights. It reads a declared tag and nothing else. The entry name was the
-original signal and is gone: a naming convention is not a contract, and names
-are author-supplied free text where a short marker like `mtp` turns up inside
-unrelated words or on weights whose entry enables nothing.
-`overrides.options` was rejected for the mirror-image reason: `spec_type:` is
-llama.cpp's config vocabulary, whereas a cross-backend ranking decision must
-work the same for `ds4`'s `mtp_path:` and `sglang`'s `speculative_algorithm:`.
-
-**If your backend can serve the same weights faster** (speculative decoding,
-multi-token prediction), say so in the docs for its gallery entries so curators
-tag them: the tagging rule and the per-backend evidence table live in
-[adding-gallery-models.md](adding-gallery-models.md). A backend never needs to
-appear in the token table itself; it ranks builds, not engines.
-
-Leaving your backend out is a valid choice when no ordering can be justified for
-it. It then ranks below every known engine and selection falls back to size,
-which is the behaviour that predates preference.
-
-**Leaving a whole capability out is not.** A missing row gives that host an
-empty preference list, so size alone decides among everything that survives the
-filters, and the filter will not save you: `IsBackendCompatible` derives hardware
-support from the engine NAME, so `vllm` and `sglang` carry no darwin, cuda, rocm
-or sycl token and are never dropped on a host with no GPU. That is why `default`
-(no usable accelerator, including a GPU under the 4 GiB VRAM floor) and
-`darwin-x86` both have rows putting `llama-cpp` first. Every capability
-`getSystemCapabilities()` can return needs a row unless every engine really is
-equally at home there. When you add one, enumerate the engines you are demoting
-rather than relying on them falling through unmatched: unmatched engines all tie
-with each other, so size decides among them.
-
 ## Documenting the backend (README + docs)
 
 A backend is not "added" until it is discoverable. Update the user-facing docs:
@@ -308,7 +225,6 @@ After adding a new backend, verify:
 
 - [ ] Backend directory structure is complete with all necessary files
 - [ ] Build configurations added to `.github/backend-matrix.yml` for all desired platforms (per-arch entries with `platform-tag` for multi-arch; `builder-base-image` for llama-cpp / ik-llama-cpp / turboquant)
-- [ ] **OS coverage considered**: added to `includeDarwin:` (macOS/Apple Silicon) if the backend can build there — with the `backend/index.yaml` `metal:` capability + `metal-<backend>` image entries, a `run.sh` Darwin/DYLD branch and `inferBackendPathDarwin` case (in `scripts/lib/backend-filter.mjs`) for C++ backends — or the PR explains why an OS is unsupported. Do not ship Linux-only by default.
 - [ ] Meta definition added to `backend/index.yaml` in the `## metas` section
 - [ ] Image entries added to `backend/index.yaml` for all build variants (latest + development)
 - [ ] Tag suffixes match between workflow file and index.yaml
@@ -316,8 +232,6 @@ After adding a new backend, verify:
 - [ ] No YAML syntax errors (check with linter)
 - [ ] No Makefile syntax errors (check with linter)
 - [ ] Follows the same pattern as similar backends (e.g., if it's a transcription backend, follow `faster-whisper` pattern)
-- [ ] **`Load` validates its input and refuses models it can't serve.** When a model config has no explicit `backend:`, the model loader greedily probes *every* installed backend with the model's name and binds to the first `Load` that succeeds — an accept-anything `Load` will capture arbitrary LLMs (issue #9287). Backends that load a real artefact get this for free (the load fails); backends with no artefact must gate on the name: `opus` accepts only its own name (or none), `local-store` requires the `store.NamespacePrefix` namespace marker sent by `core/backend/stores.go`.
-- [ ] **Gallery variant ranking considered**: if this backend should be preferred over another on some hardware, it is listed in `engineNamePreferenceRules` (NOT `backendBuildTagPreferenceRules`, NOT `servingFeaturePreferenceTokens`) in `pkg/system/capabilities.go`. A missing entry silently ranks it last and lets the next sort key decide.
 - [ ] Documented: added to the category list in `docs/content/features/backends.md` (and any new endpoint/realtime capability documented under `docs/content/`)
 - [ ] If it is an in-house native C/C++/GGML engine, added to the maintained-engines table in the top-level `README.md`
 

.agents/adding-gallery-models.md

@@ -91,108 +91,6 @@ To add a variant (e.g., different quantization), use YAML merge:
       uri: huggingface://<gguf-org>/<gguf-repo>/<filename>-Q8_0.gguf
 ```
 
-## Offering several builds of one model (`variants`)
-
-When the same model is published in more than one quantization, or is also
-servable by another engine, add each build as its own ordinary gallery entry and
-then point one of them at the others with `variants`:
-
-```yaml
-- !!merge <<: *chatml
-  name: "nanbeige4.1-3b-q4"
-  # ... the usual urls / overrides / files for the Q4 build ...
-  variants:
-    - model: nanbeige4.1-3b-q8
-```
-
-Rules:
-
-- The declaring entry is a **complete, normal entry**. It keeps its own
-  `files`/`overrides` and stays installable on every host and by every older
-  LocalAI release, which simply ignore `variants`.
-- A variant references another gallery entry **by name**. That entry must exist
-  and must not declare `variants` of its own.
-- **A referenced entry keeps its own gallery row by default.** It is hidden only
-  in the collapsed listing (`collapse_variants=true`, which the web UI requests
-  by default), where the declaring entry stands in for it. Searching there still
-  matches the referenced entry and answers with the entry declaring it, so
-  referencing an entry never makes it unfindable; turning the collapse off
-  returns it under its own name.
-- **Order carries no meaning.** Do not try to encode a preference; write the
-  list in whatever order reads best.
-- **A variant may be smaller than the declaring entry.** Offering a downgrade
-  for small hosts is a normal shape: the declaring entry's own build competes
-  like every other candidate, so a large host keeps the large build.
-- **Do not describe hardware.** At install time LocalAI drops variants whose
-  backend cannot run on the host, then drops those that do not fit available
-  memory. The declaring entry's own build is exempt from both filters, so
-  selection always terminates on something installable. Sizes are measured live
-  from the weights and cached, so nothing has to be written down.
-- **Engine preference outranks size.** Among the builds that survive the
-  filters, the host's preferred engine wins first and only then does the larger
-  footprint win. On NVIDIA a vLLM build beats a larger llama.cpp one; on Apple
-  silicon an MLX build beats a larger GGUF one; on a host with no preference for
-  either engine the larger build wins, since a bigger footprint is a higher
-  quality quantization of the same weights. Predict what a user gets by asking
-  which engine the host prefers before asking which build is biggest. The
-  per-capability order lives in `engineNamePreferenceRules`
-  (`pkg/system/capabilities.go`); see
-  [adding-backends.md](adding-backends.md) for how a backend gets into it.
-- **Serving feature preference sits between engine and size.** Among builds on
-  an equally preferred engine, one that speculates or predicts several tokens
-  per step beats the plain build of the same weights, because it answers faster
-  for the same output: a `dflash` build beats an `mtp` one, and either beats a
-  plain build. The order lives in `servingFeaturePreferenceTokens`
-  (`pkg/system/capabilities.go`) and is matched against the entry's `tags:` and
-  **nothing else**: not the entry name, not `overrides.options`. See
-  [the tagging rule](#the-dflash--mtp-tagging-rule) below. Engine deliberately
-  outranks it: a serving feature makes the right engine faster, it does not make
-  a wrong engine right. Fit still outranks both, so a drafter pairing (strictly
-  larger than the plain build, since it ships a drafter alongside it) is dropped
-  on a host too small for it before this order is ever consulted.
-- A variant is nothing but a name; there is no per-variant memory field. When
-  the measured size for a build is wrong, correct it on the referenced entry by
-  setting that entry's own `size:` (e.g. `size: "20GiB"`). The estimator prefers
-  a declared size over its own guesswork, so the fix applies everywhere the size
-  is shown or compared rather than only to variant selection.
-
-Users can override the automatic choice with `variant` on `POST /models/apply`,
-`local-ai models install --variant`, or the `install_model` MCP tool. See
-`docs/content/features/model-gallery.md`.
-
-The gallery lint specs live in `core/gallery`, so run that suite after adding a
-`variants` list.
-
-### The `dflash` / `mtp` tagging rule
-
-**Tag an entry `dflash` or `mtp` when the entry actually configures that
-feature. Variant ranking reads the tag and nothing else.**
-
-Decide by looking at what the entry configures, in whatever vocabulary its
-backend uses:
-
-| Backend | Configures the feature when it declares |
-|---------|------------------------------------------|
-| `llama-cpp` | `overrides.options` contains `spec_type:draft-dflash` or `spec_type:draft-mtp` |
-| `ds4` | `overrides.options` contains `mtp_path:` / `mtp_draft:` |
-| `sglang` | the referenced `gallery/*.yaml` sets `speculative_algorithm:` |
-
-That check is curation-time only. `spec_type` is llama.cpp's config vocabulary,
-and a cross-backend ranking decision must not depend on one backend's option
-syntax, which is precisely why the ranker reads the tag instead of the options.
-
-Two mistakes the rule exists to prevent:
-
-- **Weights that carry the heads are not an entry that enables them.** The
-  NVFP4 GGUF entries ship MTP-bearing weights but set only `use_jinja:true`, so
-  they enable no speculative decoding and must NOT be tagged. Tagging them wins
-  them the feature axis without being any faster.
-- **A name is not a declaration.** An entry whose name spells `-mtp` while
-  configuring nothing gets no tag, and an entry that configures the feature is
-  tagged even when its name says nothing (`hy3`, `glm-5.2`). Ranking never reads
-  the name, so an untagged build that does enable the feature is simply ranked
-  as plain rather than promoted on a marker nobody meant.
-
 ## Available template configs
 
 Look at existing `.yaml` files in `gallery/` to find the right prompt template for your model architecture:

.agents/building-and-testing.md

@@ -28,6 +28,7 @@ The core Go suites (`./pkg`, `./core`, plus the in-process integration suite `./
   - **Build tags (`COVERAGE_TAGS`, passed via `GINKGO_TAGS`):** defaults to `debug auth`. The `auth` tag is required to compile the real (sqlite-backed) auth implementation and its ~150 `//go:build auth` tests — without it those files aren't built, the tests don't run, and the gate scores auth against a stub (~3.7% instead of ~38%). If you add new tag-gated tests, extend `COVERAGE_TAGS` or they won't count (and likely won't run in CI at all).
 - `make test-coverage-check` — runs `test-coverage`, then `scripts/coverage-check.sh` fails the build if total coverage is **below** the committed baseline in `coverage-baseline.txt`. The Linux job in `.github/workflows/test.yml` runs this instead of `make test`.
 - `make test-coverage-baseline` — regenerates and overwrites `coverage-baseline.txt` from the current run.
+- `make install-hooks` — sets `core.hooksPath` to the versioned `.githooks/`, whose `pre-commit` runs checks scoped to what's staged: Go changes → `make lint` + `make test-coverage-check`; `core/http/react-ui/` changes → `make test-ui-coverage-check` (Playwright e2e + UI coverage gate). A commit touching neither is skipped; bypass with `git commit --no-verify`. The hook resolves golangci-lint's new-from base to `upstream/master` → `origin/master` → `master`, so it works from a fork clone where `origin/master` is stale (passed to `make lint` via `LINT_NEW_FROM`).
 
 ### React UI coverage
 
@@ -37,11 +38,12 @@ The React UI (`core/http/react-ui/`) has **no component/unit tests** — its onl
 - **Browser:** the flake dev shell ships `chromium` and exports `PLAYWRIGHT_CHROMIUM_PATH`; `playwright.config.js` uses it via `launchOptions.executablePath`, and the Makefile skips `playwright install` when it's set. This avoids Playwright's downloaded browser, which can't resolve system libs (`libglib-2.0`, …) on NixOS. In CI (no `PLAYWRIGHT_CHROMIUM_PATH`) the Makefile falls back to `playwright install --with-deps chromium`.
 - The app is a React SPA, so coverage accumulates across in-app navigation within a test; a full `page.goto`/reload resets it.
 - `.nycrc.json` uses `all: true`, so **every `src/**` file is in the report**, including 0%-coverage ones — that's how you spot features with no test at all (sort the HTML report or `coverage-summary.json` by line% ascending). 
-- **UI coverage gate:** `make test-ui-coverage-check` runs the suite then `scripts/ui-coverage-check.sh`, failing if total line coverage drops more than `UI_COVERAGE_TOLERANCE` below `core/http/react-ui/coverage-baseline.txt`. `make test-ui-coverage-baseline` regenerates the baseline. Runs in CI (`tests-ui-e2e.yml`).
+- **UI coverage gate:** `make test-ui-coverage-check` runs the suite then `scripts/ui-coverage-check.sh`, failing if total line coverage drops more than `UI_COVERAGE_TOLERANCE` below `core/http/react-ui/coverage-baseline.txt`. `make test-ui-coverage-baseline` regenerates the baseline. Runs in CI (`tests-ui-e2e.yml`) and pre-commit on `core/http/react-ui/` changes.
 - **Why it has a tolerance (unlike the strict Go gate):** UI e2e coverage is *non-deterministic*. Specs that assert on state and end while async/lazy render work is still in flight collect those lines only when the render beats the coverage teardown — so the total drifts with machine speed/load (a fast local box reads higher than a slow CI runner), diffusely across many specs. The tolerance absorbs that drift, so set the baseline *below* the slow-CI floor, never to a fast-local `make test-ui-coverage-baseline` number, or CI flaps.
 - **Raising coverage is cheap:** a *render-smoke* spec (navigate to a route, assert its header renders) mounts a lazy page and runs its full render + initial effects, capturing most of its lines in a few lines of test — see `e2e/page-render-smoke.spec.js`. Auth is disabled in the test server (`isAdmin=true`), so `RequireAdmin`/`RequireFeature` routes render without a mock. The most *deterministic* win is removing a race: make a spec `await` a rendered element before ending (see `e2e/agents.spec.js` → AgentCreate) so its lines count every run.
 
 Rules (both gates):
-- **Don't weaken the gate:** never hand-lower a baseline or widen a tolerance to turn a red gate green. The ratchet only moves up.
+- **Install the hooks:** `make install-hooks` once per clone so lint + coverage run pre-commit. Don't lean on CI for what the hook catches.
+- **Don't work around the gate:** never `git commit --no-verify`, and never hand-lower a baseline or widen a tolerance to turn a red gate green. The ratchet only moves up.
 - If a change drops coverage, **add tests** (sort `coverage-summary.json` by line% ascending to find untested code) rather than editing the baseline. When coverage legitimately rises, commit the regenerated baseline (`make test-coverage-baseline` / `test-ui-coverage-baseline`).
 - The Go gate is **strict — no tolerance**; `covermode=atomic` keeps it deterministic. The UI gate keeps a small tolerance only because its e2e coverage isn't.

.agents/ci-caching.md

@@ -114,24 +114,6 @@ Both `backend.yml` (push) and `backend_pr.yml` (PR) generate their matrix dynami
 - **Tag pushes**: `FORCE_ALL=true` is set from the workflow side (`startsWith(github.ref, 'refs/tags/')`) — releases rebuild every backend regardless of diff.
 - **Schedule / `workflow_dispatch`**: no `event.before`, falls through to "run everything" automatically.
 
-### Shared build inputs
-
-The per-backend prefix match only sees files under a backend's own directory, so a change to shared build infrastructure would rebuild *nothing* — an empty matrix, every job green, and the change reaching no image. That silently un-shipped PR #10946 (a partial-cuDNN packaging fix in `scripts/build/package-gpu-libs.sh`), which merged 1h48m after the weekly cron and so sat unbuilt for a week.
-
-`SHARED_BUILD_INPUTS` in `scripts/lib/backend-filter.mjs` closes that hole. Each rule maps a shared path to the narrowest set of matrix entries it can honestly invalidate, since a full matrix is 417 Linux + 56 Darwin builds:
-
-| Changed path | Rebuilds |
-|---|---|
-| `backend/backend.proto` | everything (all languages compile or copy it) |
-| `backend/Dockerfile.<x>` | the Linux entries whose `dockerfile:` names it |
-| `backend/python/common/` | Python, Linux + Darwin |
-| `scripts/build/package-gpu-libs.sh` | Python, Linux only |
-| `scripts/build/<lang>-darwin.sh` | the Darwin entries that build target routes to |
-| `.github/workflows/backend_build[_darwin].yml` | everything on that OS |
-| anything else under `scripts/build/` (except `*_test.sh`) | everything — conservative default for unclassified packaging inputs |
-
-Deliberately excluded: `backend/index.yaml` (gallery metadata, never enters an image), `.github/backend-matrix.yml` (adding a backend would rebuild all of them), `backend/Dockerfile.base-grpc-builder` (owned by `base-images.yml`), and the root `Makefile` (touched in ~11% of commits, and its backend-relevant edits arrive alongside the backend directory anyway). `make test-ci-scripts` pins all of this.
-
 The Sunday 06:00 UTC cron on `backend.yml` exists specifically because path filtering can leave Python backends frozen on stale wheels. `DEPS_REFRESH` (below) only fires when the build actually runs, so an untouched Python backend would never re-resolve its unpinned deps. The weekly cron is the safety net.
 
 ## The `DEPS_REFRESH` cache-buster (Python backends)

.agents/coding-style.md

@@ -65,7 +65,6 @@ This is enforced by `forbidigo` (see `.golangci.yml`): `http.DefaultClient` and
 
 The project documentation is located in `docs/content`. When adding new features or changing existing functionality, it is crucial to update the documentation to reflect these changes. This helps users understand how to use the new capabilities and ensures the documentation stays relevant.
 
-- **Docs-with-code rule**: When you change user-facing behavior (API endpoints, CLI flags, config keys, or features), update the corresponding page under `docs/content/` in the SAME change, not as a follow-up. A user-facing change without a matching docs update is incomplete. The PR template carries a checklist item for this.
 - **Feature Documentation**: If you add a new feature (like a new backend or API endpoint), create a new markdown file in `docs/content/features/` explaining what it is, how to configure it, and how to use it.
 - **Configuration**: If you modify configuration options, update the relevant sections in `docs/content/`.
 - **Examples**: providing concrete examples (like YAML configuration blocks) is highly encouraged to help users get started quickly.

.docker/bonsai-compile.sh

@@ -1,39 +0,0 @@
-#!/usr/bin/env bash
-# Shared compile logic for backend/Dockerfile.bonsai.
-# Sourced (via bind mount) from both builder-fromsource and builder-prebuilt stages.
-
-set -euxo pipefail
-
-export CCACHE_DIR=/root/.ccache
-ccache --max-size=5G || true
-ccache -z || true
-
-export CMAKE_ARGS="${CMAKE_ARGS:-} -DCMAKE_C_COMPILER_LAUNCHER=ccache -DCMAKE_CXX_COMPILER_LAUNCHER=ccache -DCMAKE_CUDA_COMPILER_LAUNCHER=ccache"
-
-if [[ -n "${CUDA_DOCKER_ARCH:-}" ]]; then
-  CUDA_ARCH_ESC="${CUDA_DOCKER_ARCH//;/\\;}"
-  export CMAKE_ARGS="${CMAKE_ARGS} -DCMAKE_CUDA_ARCHITECTURES=${CUDA_ARCH_ESC}"
-  echo "CMAKE_ARGS(env) = ${CMAKE_ARGS}"
-  rm -rf /LocalAI/backend/cpp/bonsai-*-build
-fi
-
-cd /LocalAI/backend/cpp/bonsai
-
-if [ -z "${BUILD_TYPE:-}" ]; then
-  # Pure CPU image: one ggml CPU_ALL_VARIANTS build replaces the per-microarch binaries.
-  # arm64: the armv9.2 SME variants need gcc-14 (gcc-13 rejects +sme).
-  if [ "${TARGETARCH}" = "arm64" ]; then
-    apt-get update -qq && apt-get install -y -qq gcc-14 g++-14
-    export CC=gcc-14 CXX=g++-14
-  fi
-  make bonsai-cpu-all
-else
-  # GPU build (cublas/hipblas/sycl/vulkan/...): single fallback CPU build, the accelerator
-  # does the compute. Keeps the GPU compile from also building the CPU variant matrix and
-  # avoids the gcc-14 apt step on GPU base images such as nvidia l4t.
-  make bonsai-fallback
-fi
-make bonsai-grpc
-make bonsai-rpc-server
-
-ccache -s || true

.docker/llama-cpp-compile.sh

@@ -17,33 +17,19 @@ if [[ -n "${CUDA_DOCKER_ARCH:-}" ]]; then
   rm -rf /LocalAI/backend/cpp/llama-cpp-*-build
 fi
 
-cd /LocalAI/backend/cpp/llama-cpp
-if [ -z "${BUILD_TYPE:-}" ]; then
-  # Pure CPU image (BUILD_TYPE empty): one build with ggml CPU_ALL_VARIANTS replaces the
-  # per-microarch binaries (x86: avx/avx2/avx512/fallback; arm64: armv8.x/armv9.x). ggml
-  # dlopens the best libggml-cpu-*.so at runtime by probing host CPU features.
-  #
-  # arm64: the CPU_ALL_VARIANTS table includes armv9.2 SME variants whose -march=...+sme is
-  # rejected by the Ubuntu 24.04 default gcc-13. gcc-14 accepts it, so build the arm64
-  # variants with it (the host never *selects* SME unless it has it, but every variant must
-  # still compile).
-  if [ "${TARGETARCH}" = "arm64" ]; then
-    # The prebuilt base inherits default ports.ubuntu.com sources; honor the
-    # APT_*_MIRROR build args here like the from-source path does, so this
-    # apt step survives a mirror outage.
-    sh /LocalAI/.docker/apt-mirror.sh || true
-    apt-get update -qq && apt-get install -y -qq gcc-14 g++-14
-    export CC=gcc-14 CXX=g++-14
-  fi
-  make llama-cpp-cpu-all
-else
-  # GPU build (cublas/hipblas/sycl/vulkan/...): the accelerator does the compute, so a
-  # single fallback CPU build is enough - no per-microarch CPU variants needed. (This also
-  # keeps the heavy GPU backend compile from also building the whole CPU variant matrix,
-  # and avoids the gcc-14 apt step on GPU base images such as nvidia l4t.)
+if [ "${TARGETARCH}" = "arm64" ] || [ "${BUILD_TYPE}" = "hipblas" ]; then
+  cd /LocalAI/backend/cpp/llama-cpp
   make llama-cpp-fallback
+  make llama-cpp-grpc
+  make llama-cpp-rpc-server
+else
+  cd /LocalAI/backend/cpp/llama-cpp
+  make llama-cpp-avx
+  make llama-cpp-avx2
+  make llama-cpp-avx512
+  make llama-cpp-fallback
+  make llama-cpp-grpc
+  make llama-cpp-rpc-server
 fi
-make llama-cpp-grpc
-make llama-cpp-rpc-server
 
 ccache -s || true

.docker/turboquant-compile.sh

@@ -19,21 +19,17 @@ fi
 
 cd /LocalAI/backend/cpp/turboquant
 
-if [ -z "${BUILD_TYPE:-}" ]; then
-  # Pure CPU image: one ggml CPU_ALL_VARIANTS build replaces the per-microarch binaries.
-  # arm64: the armv9.2 SME variants need gcc-14 (gcc-13 rejects +sme).
-  if [ "${TARGETARCH}" = "arm64" ]; then
-    apt-get update -qq && apt-get install -y -qq gcc-14 g++-14
-    export CC=gcc-14 CXX=g++-14
-  fi
-  make turboquant-cpu-all
-else
-  # GPU build (cublas/hipblas/sycl/vulkan/...): single fallback CPU build, the accelerator
-  # does the compute. Keeps the GPU compile from also building the CPU variant matrix and
-  # avoids the gcc-14 apt step on GPU base images such as nvidia l4t.
+if [ "${TARGETARCH}" = "arm64" ] || [ "${BUILD_TYPE}" = "hipblas" ]; then
   make turboquant-fallback
+  make turboquant-grpc
+  make turboquant-rpc-server
+else
+  make turboquant-avx
+  make turboquant-avx2
+  make turboquant-avx512
+  make turboquant-fallback
+  make turboquant-grpc
+  make turboquant-rpc-server
 fi
-make turboquant-grpc
-make turboquant-rpc-server
 
 ccache -s || true

.githooks/pre-commit

@@ -0,0 +1,60 @@
+#!/usr/bin/env sh
+#
+# LocalAI pre-commit hook. Install it (once per clone) with:
+#
+#     make install-hooks
+#
+# Runs only the checks relevant to what's staged:
+#   - Go files          -> make lint + make test-coverage-check
+#   - core/http/react-ui -> make test-ui-coverage-check (Playwright e2e + gate)
+# A commit touching neither is skipped entirely (docs/YAML/etc. can't change
+# lint findings, Go coverage, or the UI).
+#
+# To bypass for a single commit (e.g. a WIP checkpoint): git commit --no-verify
+set -eu
+
+repo_root="$(git rev-parse --show-toplevel)"
+cd "$repo_root"
+
+staged="$(git diff --cached --name-only --diff-filter=ACMRD)"
+
+go_changed=0
+ui_changed=0
+if echo "$staged" | grep -qE '\.go$'; then go_changed=1; fi
+if echo "$staged" | grep -qE '^core/http/react-ui/'; then ui_changed=1; fi
+
+if [ "$go_changed" -eq 0 ] && [ "$ui_changed" -eq 0 ]; then
+	echo "pre-commit: no Go or React UI changes staged — skipping."
+	exit 0
+fi
+
+if [ "$go_changed" -eq 1 ]; then
+	# Resolve the ref golangci-lint's new-from-merge-base should compare
+	# against. .golangci.yml pins origin/master, which is correct in CI
+	# (origin == the canonical repo) but wrong from a fork clone, where
+	# origin/master lags behind and lint would report the whole upstream
+	# backlog. Prefer upstream/master, then origin/master, then master.
+	lint_base=""
+	for ref in upstream/master origin/master master; do
+		if git rev-parse --verify --quiet "${ref}^{commit}" >/dev/null 2>&1; then
+			lint_base="$ref"
+			break
+		fi
+	done
+
+	echo "pre-commit ▶ golangci-lint (make lint${lint_base:+, new-from $lint_base})"
+	make lint LINT_NEW_FROM="$lint_base"
+
+	echo "pre-commit ▶ coverage gate (make test-coverage-check) — builds and runs the"
+	echo "             pkg/core suites plus tests/e2e; can take a few minutes."
+	make test-coverage-check
+fi
+
+if [ "$ui_changed" -eq 1 ]; then
+	echo "pre-commit ▶ React UI e2e + coverage gate (make test-ui-coverage-check) —"
+	echo "             rebuilds the UI + ui-test-server, runs the Playwright specs, and"
+	echo "             fails if line coverage regressed; can take a couple of minutes."
+	make test-ui-coverage-check
+fi
+
+echo "pre-commit ✓ all relevant checks passed"

.github/PULL_REQUEST_TEMPLATE.md

@@ -7,7 +7,6 @@ This PR fixes #
 
 **[Signed commits](../CONTRIBUTING.md#signing-off-on-commits-developer-certificate-of-origin)**
 - [ ] Yes, I signed my commits.
-- [ ] Documentation updated (docs/content/) for user-facing changes, or not applicable
  
 <!--
 Thank you for contributing to LocalAI! 

.github/bump_deps.sh

@@ -1,8 +1,5 @@
 #!/bin/bash
 set -xe
-
-source "$(dirname "${BASH_SOURCE[0]}")/gh_curl.sh"
-
 REPO=$1
 BRANCH=$2
 VAR=$3
@@ -12,20 +9,7 @@ if [ -z "$FILE" ]; then
     FILE="Makefile"
 fi
 
-# gh_curl follows redirects so a renamed/transferred upstream repo (GitHub
-# answers 301) still resolves, and fails on HTTP errors rather than letting an
-# error page reach sed below. `|| true` keeps a failed lookup from aborting the
-# script at exit 22 with no context — the SHA guard below reports it instead.
-LAST_COMMIT=$(gh_curl -H "Accept: application/vnd.github.VERSION.sha" "https://api.github.com/repos/$REPO/commits/$BRANCH" || true)
-
-# Guard the sed input: anything that is not a bare 40-hex SHA (an API error
-# body, an empty response) would otherwise be spliced into the Makefile pin —
-# either corrupting it silently or blowing up sed with an unterminated
-# expression, which is how this job failed for a renamed repo.
-if ! [[ "$LAST_COMMIT" =~ ^[0-9a-f]{40}$ ]]; then
-    echo "Refusing to bump $VAR: expected a 40-char commit SHA for $REPO@$BRANCH, got: $LAST_COMMIT" >&2
-    exit 1
-fi
+LAST_COMMIT=$(curl -s -H "Accept: application/vnd.github.VERSION.sha" "https://api.github.com/repos/$REPO/commits/$BRANCH")
 
 # Read $VAR from Makefile (only first match)
 set +e

.github/bump_docs.sh

@@ -1,18 +1,7 @@
 #!/bin/bash
 set -xe
-
-source "$(dirname "${BASH_SOURCE[0]}")/gh_curl.sh"
-
 REPO=$1
 
-LATEST_TAG=$(gh_curl -H "Accept: application/vnd.github+json" \
-    "https://api.github.com/repos/$REPO/releases/latest" | jq -r '.tag_name')
-
-# jq prints the string "null" for a missing key, so a throttled or otherwise
-# unexpected API response would otherwise be published as the docs version.
-if [ -z "$LATEST_TAG" ] || [ "$LATEST_TAG" = "null" ]; then
-    echo "Refusing to bump docs version: could not resolve the latest release tag for $REPO." >&2
-    exit 1
-fi
+LATEST_TAG=$(curl -s "https://api.github.com/repos/$REPO/releases/latest" | jq -r '.tag_name')
 
 cat <<< $(jq ".version = \"$LATEST_TAG\"" docs/data/version.json) > docs/data/version.json

.github/bump_vllm_metal.sh

@@ -1,58 +0,0 @@
-#!/bin/bash
-# Bump the single vllm-metal pin (VLLM_METAL_VERSION) in the vLLM backend's
-# darwin (Apple Silicon) install path. The macOS/Metal build
-# (backend/python/vllm/install.sh, Darwin branch) installs vllm-metal, which is
-# version-locked to a specific vLLM source release. install.sh derives that vLLM
-# version at build time from vllm-metal's own installer (`vllm_v=`) at the pinned
-# tag, so there is only ONE value to bump here -- mirroring bump_vllm_wheel.sh,
-# which bumps the Linux cu130 wheel pin.
-#
-# This deliberately tracks vllm-project/vllm-metal, NOT vllm-project/vllm: the
-# darwin build can only use the exact vLLM version vllm-metal supports, so it may
-# lag the Linux pin (requirements-cublas13-after.txt) until vllm-metal catches up.
-set -xe
-
-source "$(dirname "${BASH_SOURCE[0]}")/gh_curl.sh"
-
-REPO=$1   # vllm-project/vllm-metal
-FILE=$2   # backend/python/vllm/install.sh
-VAR=$3    # VLLM_METAL_VERSION (used for the workflow's output file names)
-
-if [ -z "$FILE" ] || [ -z "$REPO" ] || [ -z "$VAR" ]; then
-    echo "usage: $0 <repo> <install-file> <var-name>" >&2
-    exit 1
-fi
-
-# vllm-metal ships frequent dev releases, all flagged as non-prerelease, so
-# /releases/latest returns the newest one (with its cp312 wheel asset).
-LATEST_TAG=$(gh_curl -H "Accept: application/vnd.github+json" \
-    "https://api.github.com/repos/$REPO/releases/latest" \
-    | python3 -c "import json,sys; print(json.load(sys.stdin)['tag_name'])")
-
-# The coupled vLLM source version lives in vllm-metal's installer at that tag.
-NEW_VLLM_VERSION=$(gh_curl \
-    "https://raw.githubusercontent.com/$REPO/$LATEST_TAG/install.sh" \
-    | grep -oE 'vllm_v="[0-9]+\.[0-9]+\.[0-9]+"' | head -1 | cut -d'"' -f2)
-
-if [ -z "$LATEST_TAG" ] || [ -z "$NEW_VLLM_VERSION" ]; then
-    echo "Could not resolve vllm-metal tag ($LATEST_TAG) or its vllm_v ($NEW_VLLM_VERSION)." >&2
-    exit 1
-fi
-
-set +e
-CURRENT_TAG=$(grep -oE 'VLLM_METAL_VERSION="[^"]*"' "$FILE" | head -1 | cut -d'"' -f2)
-set -e
-
-# Rewrite the single pin. install.sh derives VLLM_VERSION from this tag at build
-# time, so there is nothing else to touch. peter-evans/create-pull-request opens
-# no PR on a clean tree, so a no-op rewrite (already current) is safe.
-sed -i "$FILE" \
-    -e "s|VLLM_METAL_VERSION=\"[^\"]*\"|VLLM_METAL_VERSION=\"$LATEST_TAG\"|"
-
-if [ -z "$CURRENT_TAG" ]; then
-    echo "Could not find VLLM_METAL_VERSION=\"...\" in $FILE." >&2
-    exit 0
-fi
-
-echo "vllm-metal ${CURRENT_TAG} -> ${LATEST_TAG} (builds vLLM ${NEW_VLLM_VERSION}): https://github.com/$REPO/releases/tag/${LATEST_TAG}" >> "${VAR}_message.txt"
-echo "${LATEST_TAG}" >> "${VAR}_commit.txt"

.github/bump_vllm_wheel.sh

@@ -9,9 +9,6 @@
 # vars in Makefiles; this script handles the two-value rewrite specific to the
 # vLLM requirements file.
 set -xe
-
-source "$(dirname "${BASH_SOURCE[0]}")/gh_curl.sh"
-
 REPO=$1   # vllm-project/vllm
 FILE=$2   # backend/python/vllm/requirements-cublas13-after.txt
 VAR=$3    # VLLM_VERSION (used for output file names so the workflow can read them)
@@ -22,7 +19,7 @@ if [ -z "$FILE" ] || [ -z "$REPO" ] || [ -z "$VAR" ]; then
 fi
 
 # /releases/latest returns the most recent non-prerelease tag.
-LATEST_TAG=$(gh_curl -H "Accept: application/vnd.github+json" \
+LATEST_TAG=$(curl -sS -H "Accept: application/vnd.github+json" \
     "https://api.github.com/repos/$REPO/releases/latest" \
     | python3 -c "import json,sys; print(json.load(sys.stdin)['tag_name'])")
 

.github/ci/apexentries/README.md

@@ -1,194 +0,0 @@
-# apexentries
-
-Generates gallery entries for the `mudler/*-APEX-GGUF` HuggingFace repositories.
-
-Each APEX repo becomes one **family**: one entry per quality rung the repo
-publishes and one per quantization rung its unsloth counterpart publishes, all
-gathered under the **base model's** entry. LocalAI's variant selector then picks
-the build that fits the hardware in front of it.
-
-## The hub is the base model entry, never a generated `*-apex` parent
-
-Somebody looking for `qwen3.6-35b-a3b` must find every build of those weights
-under that one name: the APEX imatrix rungs, the unsloth quant rungs and any
-speculative build. A separate `qwen3.6-35b-a3b-apex` hub competing with the base
-entry would split the family in two and leave whichever half the user did not
-search for effectively invisible.
-
-So the generator resolves the hub by stripping the `-APEX`, `-MTP` and `-TQ`
-markers and looking the result up in the index, trying both the repo-derived and
-the stem-derived candidate the same way `CounterpartCandidates` does. Then:
-
-- **The hub exists** (14 of the 45 repos, resolving to 10 distinct entries).
-  Nothing new is emitted for the family root. A `variants:` block is spliced into
-  the entry that is already there, textually, leaving its description, icon,
-  tags, overrides and files untouched. The line editing is shared with the
-  `variantproposals` job via `.github/ci/galleryedit`.
-- **The hub is absent** (the other 31). A new hub is emitted, named for the base
-  model and never for the APEX repo. It carries one of the discovered builds as
-  its own payload so it is a complete installable entry rather than a bare index,
-  and that payload is what gives it an `overrides.backend`. Without a declared
-  backend the verifier would skip it, so a hub carrying feature tags would escape
-  the tagging check in silence.
-
-Several APEX repos routinely resolve to one base model, so both paths accumulate
-by hub name rather than assuming one family per hub.
-
-Two references are always filtered out of a hub's list: anything the entry
-already declares, and the hub's own name. The self reference is not merely
-redundant. An unsloth rung whose weights the gallery already ships under the base
-name resolves, through the merge, straight back to the hub, and the verifier
-reads a self reference as a variant that declares variants of its own.
-
-The four hand-written `*-apex` entries (`qwen3.6-35b-a3b-apex`,
-`gemma-4-26b-a4b-it-apex`, `qwen3.5-35b-a3b-apex`,
-`nemotron-3-nano-omni-30b-a3b-reasoning-apex`) are **ordinary builds**, not hubs.
-They are referenced from their hub's variants list like any other rung, and are
-never deleted or renamed.
-
-## Flags
-
-| Flag | Default | Meaning |
-|------|---------|---------|
-| `-index <path>` | `gallery/index.yaml` | Gallery index to dedup against. Read only, unless `-apply` is passed. |
-| `-only <a,b,c>` | (all) | Comma-separated full repo names (`mudler/Foo-APEX-GGUF`) to restrict generation to. A name that matches nothing is reported as a warning, since it is a typo rather than an empty result. |
-| `-out <path>` | (none) | Write the entries to add to this file. Nothing is written to the gallery. |
-| `-apply` | `false` | Splice the variants into `-index` and append the new entries to it. |
-| `-verify <path>` | (none) | Verify a gallery index and exit. Ignores every other flag. |
-
-Either `-out` or `-apply` is required, otherwise the run has nothing to do.
-
-`-apply` splices variant lines into existing entries and **appends** new ones. It
-never re-serialises the index: it is roughly 40,000 lines, and a YAML round trip
-would reflow the whole file, drop the anchors and merge keys the gallery relies
-on, and produce a diff nobody can review. On the three-family sample the splice
-is 24 added lines across 3 hunks with zero deletions.
-
-## Discovery is by filename suffix, never by repo name
-
-Builds come from the files a repo actually publishes. A filename is never
-constructed from a repo name, because the two disagree:
-`mudler/gemma-4-26B-A4B-it-APEX-GGUF` ships `gemma-4-26B-A4B-APEX-*.gguf`, and
-five other repos likewise drop a suffix (`-it`, `-2603`) or a vendor prefix
-(`NVIDIA-`) that the repo name carries. Composing a URL from the repo name would
-produce a 404 for every one of them, and the 404 would only surface after the
-entry shipped.
-
-The quality ladder is matched on the trailing tier marker, `-(I-)?(Quality|
-Balanced|Compact|Mini|Nano).gguf`. The `I-` prefix marks the imatrix ladder. The
-imatrix ladder is emitted when it is non-empty and the plain ladder is used only
-as a fallback, because two of the 45 repos publish no imatrix tiers at all and
-must still contribute. Eleven repos carry a fifth `I-Nano` rung, so nothing
-assumes a fixed number of rungs.
-
-Every run prints, per repo, the counts that discovery accounted for. If the
-number of classified files is short of the number of `.gguf` files the repo
-publishes, the shortfall is printed as `UNCLASSIFIED`. That check is a set
-difference on counts rather than a second pass over filenames: a second matcher
-would duplicate the tier regex and the two copies would drift. The failure it
-catches is quiet. A publishing-script typo that breaks every imatrix filename in
-a repo does not produce a short ladder; it makes the imatrix ladder empty, and
-the fallback then downgrades the whole family to the plain ladder with nothing
-said. A downstream HTTP check cannot catch it either, because it validates the
-URLs that were emitted, and an undiscovered tier emits none.
-
-The same reasoning applies to `UNACCOUNTED QUANT`, printed when the unsloth
-counterpart demonstrably publishes a wanted quant that produced no build. It is
-reported at discovery time because a dropped quant leaves no trace at all in the
-finished gallery file.
-
-## sha256 always comes from the API
-
-Every file stanza takes its `sha256` from the HuggingFace models API
-(`lfs.sha256`). A GGUF the API describes without one is a fatal error for that
-family: the repo is reported by name and the run ends non-zero. It is never
-substituted from another field, because that is exactly how a Xet hash ends up
-masquerading as a content hash.
-
-## The dflash / mtp tagging rule
-
-An entry is tagged `dflash` or `mtp` **if and only if** it configures the
-matching `spec_type:draft-<feature>`. Variant ranking reads tags and nothing
-else, so a tag that does not match the configuration either promotes a build
-that is no faster or hides one that genuinely is.
-
-A repo name is not configuration. `mudler/Qwen3.6-35B-A3B-APEX-MTP-GGUF` ships
-weights that carry MTP heads; an entry that does not enable them is not an MTP
-entry and is not tagged as one.
-
-A generated hub inherits the tags of the build it carries as its payload, rather
-than rebuilding them from the base set, so a hub whose payload configures a
-`spec_type` stays tagged consistently with the overrides copied alongside it.
-
-## Reuse reporting: two categories, not one
-
-Generated entries are deduped against the gallery and against the batch itself.
-The run prints the result under two separate headings, because the two cases are
-not equivalent:
-
-- **URI MATCHES** mean the gallery, or an earlier entry in this batch, already
-  ships exactly these weights. Pointing the hub at the existing entry is correct
-  and needs no thought.
-- **NAME COLLISIONS** mean an entry already owns the name but holds different
-  weights. Referencing it would point the hub at a build other than the one
-  generated. Every one of these must be inspected by hand.
-
-The run then prints `HUBS SPLICED`, listing every reference that will be added to
-an entry the gallery already ships along with the line it will be added at, and
-`HUBS CREATED` for the families that get a new hub. The splices are the part a
-review has to read closely, because they modify entries somebody else wrote.
-
-Hubs are deliberately kept out of the merge. A new hub carries the family's top
-rung as its own payload, so URI dedup would fold the hub into that rung and the
-family would lose the very entry point this command exists to create.
-
-## Workflow: sample first, then the full set
-
-Never run the full generation straight into the gallery. Generate a small,
-deliberately awkward sample, have it reviewed, then run the rest.
-
-```bash
-# 1. Sample three families that between them cover the awkward shapes:
-#    a standard four-rung repo, one with the extra I-Nano rung AND a file stem
-#    that differs from its repo name, and one whose unsloth counterpart shards
-#    its quants across subdirectories.
-go run ./.github/ci/apexentries \
-  -index gallery/index.yaml \
-  -only mudler/Qwen3.6-35B-A3B-APEX-GGUF,mudler/gemma-4-26B-A4B-it-APEX-GGUF,mudler/Step-3.7-Flash-APEX-GGUF \
-  -out /tmp/sample.yaml
-
-# 2. Verify the sample against the gallery it would join, splices included. Apply
-#    to a COPY, never to the real index, and check that the diff is only the
-#    intended variant lines. Compare the verifier output to the gallery's own
-#    baseline: what matters is that the sample adds no new problem, not that the
-#    total is zero.
-cp gallery/index.yaml /tmp/index-copy.yaml
-go run ./.github/ci/apexentries -index /tmp/index-copy.yaml -only <same list> -apply
-diff -u gallery/index.yaml /tmp/index-copy.yaml   # expect zero deletions
-
-go run ./.github/ci/apexentries -verify gallery/index.yaml > /tmp/baseline.log 2>&1
-go run ./.github/ci/apexentries -verify /tmp/index-copy.yaml > /tmp/spliced.log 2>&1
-diff /tmp/baseline.log /tmp/spliced.log
-
-# 3. Have a human review /tmp/sample.yaml and every reported name collision.
-
-# 4. Only then, the full set.
-go run ./.github/ci/apexentries -index gallery/index.yaml -apply
-```
-
-## Tests
-
-```bash
-go test ./.github/ci/apexentries/
-```
-
-The shared line editor has its own package:
-
-```bash
-go test ./.github/ci/galleryedit/
-```
-
-`.github/ci/` is invisible to `go list ./...`, so these specs are not covered by
-`make lint` or the repository test run. `.github/workflows/ci-tools-tests.yaml`
-names the package explicitly; keep that workflow in step with any package added
-under `.github/ci/`.

.github/ci/apexentries/discover.go

@@ -1,70 +0,0 @@
-package main
-
-import (
-	"regexp"
-	"strings"
-)
-
-// tierRE matches the tier marker APEX repos put at the end of a weight
-// filename. Discovery is by suffix because the stem is not predictable from
-// the repo name: six of the 45 repos drop a suffix ("-it", "-2603") or a
-// vendor prefix ("NVIDIA-") that the repo name carries.
-var tierRE = regexp.MustCompile(`-(I-)?(Quality|Balanced|Compact|Mini|Nano)\.gguf$`)
-
-// fullPrecisionRE matches the unquantized source weights an APEX repo publishes
-// alongside its ladder, flat (-F16.gguf) or sharded across a numbered set
-// (-F16-00001-of-00010.gguf). bf16 is accepted because some repos publish that
-// instead, and the match is case-insensitive because the casing varies between
-// publishing scripts.
-//
-// These are deliberately not tiers: they are the weights the ladder is quantized
-// FROM, and generation is scoped to the ladder itself.
-var fullPrecisionRE = regexp.MustCompile(`(?i)-b?f16(-\d{5}-of-\d{5})?\.gguf$`)
-
-// IsFullPrecision reports whether a weight filename is an unquantized source.
-func IsFullPrecision(name string) bool {
-	return fullPrecisionRE.MatchString(name)
-}
-
-// Tier is one discovered build of an APEX repo.
-type Tier struct {
-	Label string
-	File  GGUFFile
-}
-
-// DiscoverAPEXTiers splits a repo's weight files into the imatrix ladder and
-// the plain ladder. mmproj files are never tiers.
-func DiscoverAPEXTiers(files []GGUFFile) (imatrix, plain []Tier) {
-	for _, f := range files {
-		if strings.HasPrefix(f.Name, "mmproj") {
-			continue
-		}
-		m := tierRE.FindStringSubmatch(f.Name)
-		if m == nil {
-			continue
-		}
-		if m[1] != "" {
-			imatrix = append(imatrix, Tier{Label: "I-" + m[2], File: f})
-			continue
-		}
-		plain = append(plain, Tier{Label: m[2], File: f})
-	}
-	return imatrix, plain
-}
-
-// DiscoverMMProj returns the repo's projector file, if it publishes one. The
-// name varies across repos (mmproj.gguf, mmproj-F16.gguf,
-// mmproj-step3.7-flash-f16.gguf), so match the prefix rather than a fixed name.
-func DiscoverMMProj(files []GGUFFile) (GGUFFile, bool) {
-	for _, f := range files {
-		if strings.HasPrefix(f.Name, "mmproj") {
-			return f, true
-		}
-	}
-	return GGUFFile{}, false
-}
-
-// FileStem returns a tier's filename with its tier suffix removed.
-func FileStem(t Tier) string {
-	return tierRE.ReplaceAllString(t.File.Name, "")
-}

.github/ci/apexentries/discover_test.go

@@ -1,68 +0,0 @@
-package main
-
-import (
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("DiscoverAPEXTiers", func() {
-	It("finds tiers regardless of how the stem relates to the repo name", func() {
-		// This repo is mudler/gemma-4-26B-A4B-it-APEX-GGUF but its files drop "-it".
-		files := []GGUFFile{
-			{Name: "gemma-4-26B-A4B-APEX-I-Quality.gguf", SHA256: "a"},
-			{Name: "gemma-4-26B-A4B-APEX-I-Nano.gguf", SHA256: "b"},
-			{Name: "gemma-4-26B-A4B-APEX-Quality.gguf", SHA256: "c"},
-			{Name: "mmproj-F16.gguf", SHA256: "d"},
-		}
-
-		imatrix, plain := DiscoverAPEXTiers(files)
-
-		Expect(labels(imatrix)).To(ConsistOf("I-Quality", "I-Nano"))
-		Expect(labels(plain)).To(ConsistOf("Quality"))
-	})
-
-	It("excludes mmproj from the tier list", func() {
-		files := []GGUFFile{{Name: "mmproj.gguf", SHA256: "d"}}
-
-		imatrix, plain := DiscoverAPEXTiers(files)
-
-		Expect(imatrix).To(BeEmpty())
-		Expect(plain).To(BeEmpty())
-	})
-})
-
-var _ = Describe("DiscoverMMProj", func() {
-	It("finds an mmproj whatever its suffix", func() {
-		files := []GGUFFile{
-			{Name: "Model-APEX-I-Mini.gguf", SHA256: "a"},
-			{Name: "mmproj-step3.7-flash-f16.gguf", SHA256: "b"},
-		}
-
-		got, ok := DiscoverMMProj(files)
-
-		Expect(ok).To(BeTrue())
-		Expect(got.Name).To(Equal("mmproj-step3.7-flash-f16.gguf"))
-	})
-
-	It("reports absence when the repo ships none", func() {
-		_, ok := DiscoverMMProj([]GGUFFile{{Name: "Model-APEX-Quality.gguf", SHA256: "a"}})
-
-		Expect(ok).To(BeFalse())
-	})
-})
-
-var _ = Describe("FileStem", func() {
-	It("strips the tier suffix", func() {
-		t := Tier{Label: "I-Quality", File: GGUFFile{Name: "gemma-4-26B-A4B-APEX-I-Quality.gguf"}}
-
-		Expect(FileStem(t)).To(Equal("gemma-4-26B-A4B-APEX"))
-	})
-})
-
-func labels(ts []Tier) []string {
-	out := make([]string, 0, len(ts))
-	for _, t := range ts {
-		out = append(out, t.Label)
-	}
-	return out
-}

.github/ci/apexentries/hf.go

@@ -1,130 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"net/http"
-	"strings"
-	"time"
-
-	"github.com/mudler/LocalAI/pkg/httpclient"
-)
-
-// ErrNoSHA256 marks a GGUF the HuggingFace API describes without an
-// lfs.sha256. Emitting an entry without a hash would ship an unverifiable
-// download, and guessing one from another field is how a Xet hash ends up
-// masquerading as a content hash, so this is fatal rather than skippable.
-var ErrNoSHA256 = errors.New("gguf file has no lfs.sha256")
-
-// GGUFFile is one .gguf sibling of a HuggingFace repo.
-type GGUFFile struct {
-	Name   string
-	Size   int64
-	SHA256 string
-}
-
-type apiSibling struct {
-	RFilename string `json:"rfilename"`
-	Size      int64  `json:"size"`
-	LFS       *struct {
-		SHA256 string `json:"sha256"`
-	} `json:"lfs"`
-}
-
-type apiModel struct {
-	Siblings []apiSibling `json:"siblings"`
-}
-
-// ParseRepoFiles returns every .gguf sibling described by a models API body.
-func ParseRepoFiles(body []byte) ([]GGUFFile, error) {
-	var m apiModel
-	if err := json.Unmarshal(body, &m); err != nil {
-		return nil, fmt.Errorf("decoding model response: %w", err)
-	}
-
-	var out []GGUFFile
-	for _, s := range m.Siblings {
-		if !strings.HasSuffix(s.RFilename, ".gguf") {
-			continue
-		}
-		if s.LFS == nil || s.LFS.SHA256 == "" {
-			return nil, fmt.Errorf("%s: %w", s.RFilename, ErrNoSHA256)
-		}
-		out = append(out, GGUFFile{Name: s.RFilename, Size: s.Size, SHA256: s.LFS.SHA256})
-	}
-	return out, nil
-}
-
-// FetchOptionalRepoFiles asks the models API for a repo the caller can do
-// without, and reports separately whether the repo was merely unreadable.
-//
-// HuggingFace answers 401 Unauthorized, not 404, for a repo that does not exist
-// when the request carries no credentials. Without a token there is therefore no
-// way to tell "this repo was never published" from "this repo is private", so an
-// optional probe has to treat 401 and 403 exactly like 404: whatever the reason,
-// there is nothing here for us to read, so there is no counterpart.
-//
-// The second return value exists because that collapse is lossy in one
-// direction: 401/403 can also mean a real, gated repo whose quants we would
-// genuinely want. The caller reports those repos so a silently dropped
-// counterpart is visible to a human rather than invisible.
-func FetchOptionalRepoFiles(client *http.Client, repo string) ([]GGUFFile, bool, error) {
-	files, status, err := fetchRepoFiles(client, repo)
-	if err != nil && (status == http.StatusUnauthorized || status == http.StatusForbidden) {
-		return nil, true, nil
-	}
-	return files, false, err
-}
-
-// FetchRepoFiles asks the models API for one repo. A 404 yields (nil, nil) so
-// that probing for an optional counterpart repo is not an error. Every other
-// non-200, 401 and 403 included, is an error: for a repo the run REQUIRES there
-// is no benign reading of "we cannot see it".
-func FetchRepoFiles(client *http.Client, repo string) ([]GGUFFile, error) {
-	files, _, err := fetchRepoFiles(client, repo)
-	return files, err
-}
-
-// fetchRepoFiles does the request and returns the HTTP status alongside the
-// result, so the optional and required callers can apply different policies to
-// the same response without duplicating the request.
-func fetchRepoFiles(client *http.Client, repo string) ([]GGUFFile, int, error) {
-	url := fmt.Sprintf("https://huggingface.co/api/models/%s?blobs=true", repo)
-	req, err := http.NewRequest(http.MethodGet, url, nil)
-	if err != nil {
-		return nil, 0, err
-	}
-	req.Header.Set("User-Agent", "localai-apexentries/1.0")
-
-	resp, err := client.Do(req)
-	if err != nil {
-		return nil, 0, err
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode == http.StatusNotFound {
-		return nil, resp.StatusCode, nil
-	}
-	if resp.StatusCode != http.StatusOK {
-		return nil, resp.StatusCode, fmt.Errorf("%s: unexpected status %d", repo, resp.StatusCode)
-	}
-
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return nil, resp.StatusCode, err
-	}
-	files, err := ParseRepoFiles(body)
-	return files, resp.StatusCode, err
-}
-
-// newHTTPClient builds the client used against the HuggingFace API. It goes
-// through pkg/httpclient rather than a bare &http.Client{} because the std
-// client follows redirects and forwards custom credential headers to the
-// redirect target on a cross-host hop (GHSA-3mj3-57v2-4636). This caller sends
-// only a User-Agent today, but it talks to an external API that could start
-// redirecting, and an HF_TOKEN header here later would then leak.
-func newHTTPClient() *http.Client {
-	return httpclient.NewWithTimeout(60 * time.Second)
-}

.github/ci/apexentries/hf_test.go

@@ -1,142 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"io"
-	"net/http"
-	"testing"
-
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-func TestApexEntries(t *testing.T) {
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "apexentries")
-}
-
-// stubTransport answers every request with one canned status and body, so the
-// status handling of the fetchers can be exercised without reaching the real
-// HuggingFace API.
-type stubTransport struct {
-	status int
-	body   string
-}
-
-func (t stubTransport) RoundTrip(req *http.Request) (*http.Response, error) {
-	return &http.Response{
-		StatusCode: t.status,
-		Body:       io.NopCloser(bytes.NewBufferString(t.body)),
-		Header:     make(http.Header),
-		Request:    req,
-	}, nil
-}
-
-func stubClient(status int, body string) *http.Client {
-	return &http.Client{Transport: stubTransport{status: status, body: body}}
-}
-
-const oneGGUFBody = `{"siblings":[{"rfilename":"Model-APEX-I-Quality.gguf","size":10,"lfs":{"sha256":"aa","size":10}}]}`
-
-var _ = Describe("FetchOptionalRepoFiles", func() {
-	// HuggingFace answers 401 rather than 404 for a repo that does not exist
-	// when the client carries no credentials, so an optional probe cannot tell
-	// "absent" from "unauthorized" and must treat both as "no counterpart".
-	It("treats a 401 as an absent repo and flags it as unavailable", func() {
-		files, unavailable, err := FetchOptionalRepoFiles(stubClient(http.StatusUnauthorized, ""), "unsloth/Nope-GGUF")
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(files).To(BeEmpty())
-		Expect(unavailable).To(BeTrue())
-	})
-
-	It("treats a 403 as an absent repo and flags it as unavailable", func() {
-		files, unavailable, err := FetchOptionalRepoFiles(stubClient(http.StatusForbidden, ""), "unsloth/Gated-GGUF")
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(files).To(BeEmpty())
-		Expect(unavailable).To(BeTrue())
-	})
-
-	// A clean 404 is an unambiguous absence, so it must NOT be reported as
-	// unavailable: the whole point of the flag is to separate the ambiguous
-	// case a human may need to look at from the settled one.
-	It("treats a 404 as an absent repo without flagging it as unavailable", func() {
-		files, unavailable, err := FetchOptionalRepoFiles(stubClient(http.StatusNotFound, ""), "unsloth/Nope-GGUF")
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(files).To(BeEmpty())
-		Expect(unavailable).To(BeFalse())
-	})
-
-	It("parses a 200 body as usual", func() {
-		files, unavailable, err := FetchOptionalRepoFiles(stubClient(http.StatusOK, oneGGUFBody), "unsloth/Real-GGUF")
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(unavailable).To(BeFalse())
-		Expect(files).To(HaveLen(1))
-		Expect(files[0].Name).To(Equal("Model-APEX-I-Quality.gguf"))
-		Expect(files[0].SHA256).To(Equal("aa"))
-	})
-
-	// Tolerating 401/403 must not widen into tolerating everything: a 500 is a
-	// broken API, not evidence about whether the repo exists.
-	It("still errors on a 500", func() {
-		_, _, err := FetchOptionalRepoFiles(stubClient(http.StatusInternalServerError, ""), "unsloth/Real-GGUF")
-
-		Expect(err).To(HaveOccurred())
-		Expect(err.Error()).To(ContainSubstring("unexpected status 500"))
-	})
-})
-
-var _ = Describe("FetchRepoFiles", func() {
-	// The APEX repo itself is not optional. A 401 there means the repo the run
-	// was asked to publish cannot be read, which is a real failure and must not
-	// be quietly downgraded to "no files".
-	It("errors on a 401 for a required repo", func() {
-		_, err := FetchRepoFiles(stubClient(http.StatusUnauthorized, ""), "mudler/Model-APEX-GGUF")
-
-		Expect(err).To(HaveOccurred())
-		Expect(err.Error()).To(ContainSubstring("unexpected status 401"))
-	})
-
-	It("errors on a 403 for a required repo", func() {
-		_, err := FetchRepoFiles(stubClient(http.StatusForbidden, ""), "mudler/Model-APEX-GGUF")
-
-		Expect(err).To(HaveOccurred())
-		Expect(err.Error()).To(ContainSubstring("unexpected status 403"))
-	})
-
-	It("still treats a 404 as an absent repo", func() {
-		files, err := FetchRepoFiles(stubClient(http.StatusNotFound, ""), "mudler/Model-APEX-GGUF")
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(files).To(BeEmpty())
-	})
-})
-
-var _ = Describe("ParseRepoFiles", func() {
-	It("returns gguf siblings with their lfs sha256", func() {
-		body := []byte(`{"siblings":[
-			{"rfilename":"Model-APEX-I-Quality.gguf","size":10,"lfs":{"sha256":"aa","size":10}},
-			{"rfilename":"README.md"},
-			{"rfilename":"mmproj.gguf","size":5,"lfs":{"sha256":"bb","size":5}}
-		]}`)
-
-		files, err := ParseRepoFiles(body)
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(files).To(HaveLen(2))
-		Expect(files[0].Name).To(Equal("Model-APEX-I-Quality.gguf"))
-		Expect(files[0].SHA256).To(Equal("aa"))
-		Expect(files[1].Name).To(Equal("mmproj.gguf"))
-	})
-
-	It("reports a gguf that carries no lfs sha256", func() {
-		body := []byte(`{"siblings":[{"rfilename":"mmproj.gguf","size":5}]}`)
-
-		_, err := ParseRepoFiles(body)
-
-		Expect(err).To(MatchError(ErrNoSHA256))
-	})
-})

.github/ci/apexentries/hub.go

@@ -1,143 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"os"
-	"strings"
-
-	"gopkg.in/yaml.v3"
-
-	"github.com/mudler/LocalAI/.github/ci/galleryedit"
-)
-
-// IndexText is the gallery index seen as text: the entries it declares plus the
-// exact lines each one occupies, which is what splicing a variants block into an
-// entry the gallery already ships requires.
-//
-// It is a second, narrower read of the same file LoadExisting parses. The two
-// answer different questions: LoadExisting answers "do these weights already
-// exist anywhere", this one answers "where in the file does this entry live".
-type IndexText struct {
-	Lines   []string
-	Entries []*indexEntry
-
-	byName map[string]*indexEntry
-}
-
-// indexEntry is one entry of the index: its name, the variants it already
-// declares, and its coordinates in the file.
-type indexEntry struct {
-	Name     string       `yaml:"name"`
-	Variants []VariantRef `yaml:"variants"`
-
-	Pos galleryedit.Entry `yaml:"-"`
-}
-
-// LoadIndexText reads the gallery index for editing.
-func LoadIndexText(path string) (*IndexText, error) {
-	raw, err := os.ReadFile(path)
-	if err != nil {
-		return nil, err
-	}
-	return ParseIndexText(string(raw))
-}
-
-// ParseIndexText pairs the decoded entries with the top level list items the
-// text actually contains.
-//
-// If the two views disagree on how many entries there are then every line number
-// a splice would compute is suspect, and the failure mode is writing a variants
-// block into the wrong model. The parse refuses instead.
-func ParseIndexText(text string) (*IndexText, error) {
-	var entries []*indexEntry
-	if err := yaml.Unmarshal([]byte(text), &entries); err != nil {
-		return nil, fmt.Errorf("decoding gallery index: %w", err)
-	}
-
-	lines, starts := galleryedit.Scan(text)
-	if len(starts) != len(entries) {
-		return nil, fmt.Errorf("gallery index has %d decoded entries but %d top level list items; refusing to edit by line number",
-			len(entries), len(starts))
-	}
-
-	ix := &IndexText{Lines: lines, Entries: entries, byName: map[string]*indexEntry{}}
-	for i, e := range entries {
-		if e == nil {
-			return nil, fmt.Errorf("gallery index list item %d is empty; refusing to edit by line number", i)
-		}
-		end := len(lines)
-		if i+1 < len(starts) {
-			end = starts[i+1]
-		}
-		e.Pos = galleryedit.Entry{Name: e.Name, StartLine: starts[i], EndLine: end}
-
-		// First occurrence wins, matching the gallery's own resolution.
-		key := strings.ToLower(e.Name)
-		if _, seen := ix.byName[key]; !seen {
-			ix.byName[key] = e
-		}
-	}
-	return ix, nil
-}
-
-// Find looks an entry up by name, case insensitively.
-func (ix *IndexText) Find(name string) *indexEntry {
-	return ix.byName[strings.ToLower(name)]
-}
-
-// ResolveHub returns the gallery name of a family's hub and whether the gallery
-// already ships an entry under it.
-//
-// The hub is the BASE model entry, never a generated *-apex parent. Somebody
-// looking for qwen3.6-35b-a3b has to find every build of those weights under
-// that one name: the APEX imatrix rungs, the unsloth quant rungs and any
-// speculative build. A separate qwen3.6-35b-a3b-apex hub competing with the base
-// entry would split the family in two and leave whichever half the user did not
-// search for invisible.
-//
-// Both candidates are tried for the same reason CounterpartCandidates tries
-// both. The repo name and the published file stem disagree for several of these
-// repos, and either one may be what the base entry was named after.
-func ResolveHub(ix *IndexText, repoBase, stem string) (name string, exists bool) {
-	candidates := CounterpartCandidates(repoBase, stem)
-	for _, c := range candidates {
-		if n := slug(c); ix.Find(n) != nil {
-			return n, true
-		}
-	}
-	// Nothing matched, so the family needs a hub of its own under the repo
-	// derived name, which is the more reliable of the two.
-	return slug(candidates[0]), false
-}
-
-// HubLabel is the human-cased base model name, for prose rather than lookup.
-func HubLabel(repoBase, stem string) string {
-	return CounterpartCandidates(repoBase, stem)[0]
-}
-
-// filterVariants drops the references a hub must not carry: itself, and anything
-// it already lists.
-//
-// The self reference is not merely redundant. A hub that names itself makes the
-// verifier resolve the reference back to the hub, see that the hub declares
-// variants, and report a variant that declares variants of its own. It arises
-// for real rather than in theory: an unsloth rung whose weights the gallery
-// already ships under the base model name resolves, through Merge, straight back
-// to the hub that is about to reference it.
-func filterVariants(hub string, already []VariantRef, want []string) []string {
-	seen := map[string]bool{strings.ToLower(hub): true}
-	for _, v := range already {
-		seen[strings.ToLower(v.Model)] = true
-	}
-
-	var out []string
-	for _, w := range want {
-		key := strings.ToLower(w)
-		if seen[key] {
-			continue
-		}
-		seen[key] = true
-		out = append(out, w)
-	}
-	return out
-}

.github/ci/apexentries/main.go

@@ -1,795 +0,0 @@
-// Command apexentries generates gallery entries for the mudler APEX GGUF
-// repositories: one entry per imatrix tier and per unsloth quant rung, all
-// gathered under the BASE model's entry. Builds off a *-APEX-MTP-GGUF repo turn
-// speculative decoding on, because those weights retain the model's MTP heads
-// and are only worth their extra size with the heads in use.
-//
-// The base model entry is the hub. Somebody looking for qwen3.6-35b-a3b must
-// find every build of those weights under that one name, so when the gallery
-// already ships the base entry this command splices a variants block into it
-// rather than emitting a competing *-apex parent beside it. Only a family whose
-// base model the gallery does not ship at all gets a new hub entry, and that one
-// is still named for the base model.
-//
-// Builds are discovered by inspecting the filenames a repo actually publishes.
-// Repo names do not reliably predict them: mudler/gemma-4-26B-A4B-it-APEX-GGUF
-// ships gemma-4-26B-A4B-APEX-*.gguf, and six of the 45 repos drop a suffix or a
-// vendor prefix in the same way.
-package main
-
-import (
-	"encoding/json"
-	"flag"
-	"fmt"
-	"io"
-	"net/http"
-	"os"
-	"path"
-	"sort"
-	"strings"
-
-	"gopkg.in/yaml.v3"
-
-	"github.com/mudler/LocalAI/.github/ci/galleryedit"
-)
-
-const (
-	// entryTemplate carries no backend and no parameters of its own, which is
-	// why RenderChild states everything inline.
-	entryTemplate = "virtual.yaml"
-	unslothOwner  = "unsloth"
-	authorListURL = "https://huggingface.co/api/models?author=mudler&limit=300"
-)
-
-// rungRank orders the quality ladder from best to smallest. The HuggingFace API
-// returns siblings alphabetically and DiscoverAPEXTiers preserves that order, so
-// an unsorted variants list reads I-Balanced, I-Compact, I-Mini, I-Nano,
-// I-Quality. Selection ignores authored order, so this is purely so the file a
-// human reviews scans in a meaningful sequence.
-var rungRank = map[string]int{
-	"I-Quality": 0, "I-Balanced": 1, "I-Compact": 2, "I-Mini": 3, "I-Nano": 4,
-	"Quality": 5, "Balanced": 6, "Compact": 7, "Mini": 8, "Nano": 9,
-}
-
-// baseTags are the tags every generated entry carries. dflash and mtp are never
-// among them: RenderChild adds those if and only if the entry configures the
-// matching spec_type.
-var baseTags = []string{"llm", "gguf", "cpu", "gpu"}
-
-// childBuild pairs a rendered entry with its position on the quality ladder, so
-// the parent's variants list can be sorted without re-parsing entry names.
-type childBuild struct {
-	entry GalleryEntry
-	rank  int
-}
-
-// family is one APEX repo's full generated output.
-type family struct {
-	repo      string
-	repoBase  string
-	stem      string
-	hasMMProj bool
-	children  []childBuild
-
-	// skippedRepos are counterpart candidates HuggingFace would not describe.
-	// Carried on the family rather than printed and forgotten so the run can
-	// summarize them next to everything else a reviewer has to eyeball.
-	skippedRepos []string
-	census       fileCensus
-	unaccounted  int
-}
-
-// fileCensus splits the files discovery emitted nothing for into the ones a
-// reviewer must chase and the ones that are deliberately out of scope.
-//
-// Full-precision sources are the second kind: they are the unquantized weights
-// the ladder is derived FROM, not a rung of it. Folding them into the
-// unclassified total would leave a permanent benign baseline, and a permanent
-// baseline is exactly what hides the one file that ever genuinely matters.
-type fileCensus struct {
-	unclassified  int
-	fullPrecision int
-}
-
-// add accumulates one repo's census into a running total.
-func (c *fileCensus) add(o fileCensus) {
-	c.unclassified += o.unclassified
-	c.fullPrecision += o.fullPrecision
-}
-
-// sortedChildren returns the family's builds in ladder order, best first.
-func (f *family) sortedChildren() []childBuild {
-	sorted := append([]childBuild{}, f.children...)
-	sort.SliceStable(sorted, func(i, j int) bool { return sorted[i].rank < sorted[j].rank })
-	return sorted
-}
-
-func main() {
-	verify := flag.String("verify", "", "verify a gallery index and exit")
-	index := flag.String("index", "gallery/index.yaml", "gallery index to dedup against")
-	only := flag.String("only", "", "comma-separated repo names to restrict generation to")
-	out := flag.String("out", "", "write the entries to add to this file")
-	apply := flag.Bool("apply", false, "append the entries to add to -index")
-	flag.Parse()
-
-	if *verify != "" {
-		problems := Verify(*verify)
-		for _, p := range problems {
-			fmt.Fprintln(os.Stderr, p)
-		}
-		if len(problems) > 0 {
-			fmt.Fprintf(os.Stderr, "%d problem(s)\n", len(problems))
-			os.Exit(1)
-		}
-		fmt.Println("index is sound")
-		return
-	}
-
-	if err := generate(*index, *only, *out, *apply); err != nil {
-		fmt.Fprintln(os.Stderr, "error:", err)
-		os.Exit(1)
-	}
-}
-
-func generate(indexPath, only, outPath string, apply bool) error {
-	if outPath == "" && !apply {
-		return fmt.Errorf("nothing to do: pass -out <file> or -apply")
-	}
-
-	client := newHTTPClient()
-
-	repos, err := listAPEXRepos(client)
-	if err != nil {
-		return err
-	}
-	if only != "" {
-		repos = restrict(repos, only)
-	}
-	if len(repos) == 0 {
-		return fmt.Errorf("no APEX repos selected")
-	}
-	fmt.Printf("repos selected: %d\n", len(repos))
-
-	var families []family
-	var failed []string
-
-	for _, repo := range repos {
-		f, err := buildFamily(client, repo)
-		if err != nil {
-			// A missing sha256 is fatal for the family rather than skippable: an
-			// entry without one ships an unverifiable download. Report which repo
-			// and keep going, so one bad repo does not hide the state of the rest.
-			fmt.Fprintf(os.Stderr, "FAILED %s: %v\n", repo, err)
-			failed = append(failed, repo)
-			continue
-		}
-		families = append(families, *f)
-	}
-
-	existing, err := LoadExisting(indexPath)
-	if err != nil {
-		return err
-	}
-	ixText, err := LoadIndexText(indexPath)
-	if err != nil {
-		return err
-	}
-	fmt.Printf("existing index: %d names, %d weight URIs, %d lines\n",
-		len(existing.ByName), len(existing.ByURI), len(ixText.Lines))
-
-	// Only the builds go through Merge. A hub is deliberately kept out of it: a
-	// new hub carries the family's top rung as its own payload, so Merge's URI
-	// dedup would fold the hub into that rung and the family would lose the very
-	// entry point this command exists to create. Hub names are checked against
-	// the index directly, by ResolveHub.
-	var generated []GalleryEntry
-	for _, f := range families {
-		for _, c := range f.children {
-			generated = append(generated, c.entry)
-		}
-	}
-
-	add, reused := Merge(existing, generated)
-	reportReuse(existing, generated, reused)
-
-	// Variant references are resolved from `reused`, never used to decide what to
-	// emit: on a within-batch name collision Merge records reused[name] = name
-	// while the first entry of that name is still in `add`, so treating presence
-	// in `reused` as "dropped" would silently emit nothing for it.
-	added := map[string]bool{}
-	for _, e := range add {
-		added[e.Name] = true
-	}
-
-	inserts, newHubs, err := planHubs(families, ixText, reused, added)
-	if err != nil {
-		return err
-	}
-	reportHubs(ixText, inserts, newHubs)
-
-	skipped, census, fullPrecisionRepos, unaccounted := reportSkipped(families)
-
-	add = append(add, newHubs...)
-
-	fmt.Printf("\nentries generated: %d\nentries to add:    %d\nentries reused:    %d\nhubs spliced:      %d\nhubs created:      %d\nrepos skipped:     %d\nexcluded (full precision): %d files across %d repos\nunclassified:      %d\nunaccounted:       %d\n",
-		len(generated), len(add), len(reused), len(inserts), len(newHubs), len(skipped),
-		census.fullPrecision, fullPrecisionRepos, census.unclassified, unaccounted)
-
-	lines, err := galleryedit.Apply(ixText.Lines, inserts)
-	if err != nil {
-		return err
-	}
-
-	if err := writeEntries(add, lines, outPath, apply, indexPath); err != nil {
-		return err
-	}
-
-	if len(failed) > 0 {
-		return fmt.Errorf("%d repo(s) failed: %s", len(failed), strings.Join(failed, ", "))
-	}
-	return nil
-}
-
-// resolveVariant maps a generated child name onto whatever entry actually stands
-// for it after the merge. `added` is consulted first because a within-batch name
-// collision puts a name in BOTH add and reused, and the entry that was emitted
-// is the one the parent must reference.
-func resolveVariant(name string, reused map[string]string, added map[string]bool) string {
-	if added[name] {
-		return name
-	}
-	if target, ok := reused[name]; ok {
-		return target
-	}
-	return name
-}
-
-// SpecTypeForRepo reports the speculative decoding mechanism a repo's builds can
-// turn on with no extra download.
-//
-// The *-APEX-MTP-GGUF repos republish the base weights with the model's own MTP
-// heads retained, so those builds are only worth their extra size if the heads
-// are actually used. Every other APEX repo drops them, and switching MTP on
-// there would name a mechanism the weights cannot serve.
-//
-// The suffix is read off the repo the FILES come from, so nothing downstream has
-// to infer a capability from an entry name.
-func SpecTypeForRepo(repo string) string {
-	if strings.HasSuffix(path.Base(repo), "-APEX-MTP-GGUF") {
-		return "draft-mtp"
-	}
-	return ""
-}
-
-// buildFamily discovers everything one APEX repo and its unsloth counterpart
-// publish, and renders it.
-func buildFamily(client *http.Client, repo string) (*family, error) {
-	files, err := FetchRepoFiles(client, repo)
-	if err != nil {
-		return nil, err
-	}
-	if len(files) == 0 {
-		return nil, fmt.Errorf("no gguf files")
-	}
-
-	imatrix, plain := DiscoverAPEXTiers(files)
-	mmproj, hasMMProj := DiscoverMMProj(files)
-
-	census := reportUnclassified(repo, files, imatrix, plain)
-
-	// The imatrix ladder is preferred, but two of the 45 repos publish no
-	// imatrix tiers at all and must still contribute their plain ladder.
-	ladder := imatrix
-	ladderKind := "imatrix"
-	if len(ladder) == 0 {
-		ladder = plain
-		ladderKind = "plain"
-	}
-	if len(ladder) == 0 {
-		return nil, fmt.Errorf("no tiers discovered")
-	}
-
-	sortTiers(ladder)
-
-	var mm *GGUFFile
-	if hasMMProj {
-		mm = &mmproj
-	}
-
-	repoBase := strings.TrimSuffix(path.Base(repo), "-GGUF")
-	f := &family{repo: repo, repoBase: repoBase, hasMMProj: hasMMProj, census: census}
-
-	// Only the APEX ladder can carry MTP heads; the unsloth counterpart quantizes
-	// the plain weights and gets nothing from this.
-	specType := SpecTypeForRepo(repo)
-
-	for _, t := range ladder {
-		f.children = append(f.children, childBuild{
-			rank: rungRank[t.Label],
-			entry: RenderChild(ChildInput{
-				Name:     slug(repoBase) + "-" + slug(t.Label),
-				Repo:     repo,
-				Template: entryTemplate,
-				SpecType: specType,
-				Weights:  []GGUFFile{t.File},
-				MMProj:   mm,
-				BaseTags: baseTags,
-			}),
-		})
-	}
-
-	stem := FileStem(ladder[0])
-	f.stem = stem
-	fmt.Printf("%s: %d %s tier(s) [%s], stem %s, mmproj %v\n",
-		repo, len(ladder), ladderKind, tierLabels(ladder), stem, hasMMProj)
-
-	counterpart, cpFiles, skipped, err := resolveCounterpart(client, repoBase, stem)
-	f.skippedRepos = skipped
-	if err != nil {
-		return nil, err
-	}
-	if counterpart != "" {
-		builds := DiscoverUnslothQuants(cpFiles)
-
-		// Called here rather than inside Verify: a quant dropped at discovery
-		// leaves no trace at all in the finished gallery file, so the only place
-		// the shortfall is still visible is the moment of discovery.
-		unaccounted := UnaccountedQuants(cpFiles, builds)
-		f.unaccounted = len(unaccounted)
-		for _, p := range unaccounted {
-			fmt.Fprintf(os.Stderr, "UNACCOUNTED QUANT %s: %s\n", counterpart, p)
-		}
-
-		cpMMProj, hasCPMMProj := DiscoverMMProj(cpFiles)
-		var cpMM *GGUFFile
-		if hasCPMMProj {
-			cpMM = &cpMMProj
-		}
-		cpBase := strings.TrimSuffix(path.Base(counterpart), "-GGUF")
-
-		for i, b := range builds {
-			f.children = append(f.children, childBuild{
-				rank: 100 + i,
-				entry: RenderChild(ChildInput{
-					Name:     slug(cpBase) + "-" + slug(b.Quant),
-					Repo:     counterpart,
-					Template: entryTemplate,
-					Weights:  b.Files,
-					MMProj:   cpMM,
-					BaseTags: baseTags,
-				}),
-			})
-		}
-		fmt.Printf("%s: counterpart %s, %d quant build(s) %s\n", repo, counterpart, len(builds), quantLabels(builds))
-	} else {
-		fmt.Printf("%s: no unsloth counterpart\n", repo)
-	}
-
-	return f, nil
-}
-
-// planHubs decides, per family, whether the family's builds are spliced into a
-// base model entry the gallery already ships or gathered under a new hub.
-//
-// Splicing is strongly preferred and is the measured majority-adjacent case. The
-// existing entry keeps its description, icon, tags, overrides and files
-// untouched; only variant lines are added to it.
-func planHubs(families []family, ix *IndexText, reused map[string]string, added map[string]bool) ([]galleryedit.Insert, []GalleryEntry, error) {
-	// Several APEX repos can resolve to one base model, so both paths accumulate
-	// by hub name rather than assuming one family per hub.
-	wantByHub := map[string][]string{}
-	var spliceOrder []string
-
-	var newHubs []GalleryEntry
-	hubAt := map[string]int{}
-
-	for i := range families {
-		f := &families[i]
-
-		hubName, exists := ResolveHub(ix, f.repoBase, f.stem)
-		want := hubVariants(f, ix, reused, added)
-
-		if exists {
-			if _, seen := wantByHub[hubName]; !seen {
-				spliceOrder = append(spliceOrder, hubName)
-			}
-			wantByHub[hubName] = append(wantByHub[hubName], want...)
-			continue
-		}
-
-		if at, dup := hubAt[hubName]; dup {
-			for _, v := range filterVariants(hubName, newHubs[at].Variants, want) {
-				newHubs[at].Variants = append(newHubs[at].Variants, VariantRef{Model: v})
-			}
-			continue
-		}
-
-		builds := f.sortedChildren()
-		if len(builds) == 0 {
-			return nil, nil, fmt.Errorf("%s: no builds to hang a hub on", f.repo)
-		}
-		hubAt[hubName] = len(newHubs)
-		newHubs = append(newHubs, renderHub(hubName, f, builds[0], filterVariants(hubName, nil, want)))
-	}
-
-	var inserts []galleryedit.Insert
-	for _, name := range spliceOrder {
-		e := ix.Find(name)
-		items := filterVariants(name, e.Variants, wantByHub[name])
-		if len(items) == 0 {
-			continue
-		}
-		inserts = append(inserts, galleryedit.Insert{Entry: e.Pos, Variants: items})
-	}
-	return inserts, newHubs, nil
-}
-
-// hubVariants is a family's full build list, in ladder order, named as the hub
-// must reference them after the merge.
-func hubVariants(f *family, ix *IndexText, reused map[string]string, added map[string]bool) []string {
-	var out []string
-
-	// A hand-written *-apex entry is an ordinary build of these weights. It is
-	// never deleted, never renamed and never treated as a hub; it is simply
-	// referenced like any other rung.
-	if apex := slug(f.repoBase); ix.Find(apex) != nil {
-		out = append(out, apex)
-	}
-	for _, c := range f.sortedChildren() {
-		out = append(out, resolveVariant(c.entry.Name, reused, added))
-	}
-	return out
-}
-
-// renderHub builds the hub for a family whose base model the gallery does not
-// ship at all. It is named for the BASE model, never for the APEX repo.
-//
-// It carries one of the discovered builds as its own payload so it is a complete
-// installable entry rather than a bare index pointing at other entries. That
-// payload is what supplies overrides.backend, which matters beyond installation:
-// the verifier can only judge the tagging rule for a backend it can read, so a
-// hub carrying feature tags and no backend would escape the check in silence.
-//
-// The payload's own tags are kept rather than rebuilt from baseTags, so a hub
-// whose payload configures a spec_type stays tagged for it and consistent with
-// the overrides copied alongside.
-func renderHub(name string, f *family, payload childBuild, variants []string) GalleryEntry {
-	e := payload.entry
-	e.Name = name
-	e.Description = fmt.Sprintf(
-		"%s. Quality ladder and quantization rungs published by %s and its unsloth counterpart; LocalAI picks the build that fits the hardware.",
-		HubLabel(f.repoBase, f.stem), f.repo)
-
-	e.Tags = append([]string{}, payload.entry.Tags...)
-	if f.hasMMProj && !hasTag(e.Tags, "vision") {
-		e.Tags = append(e.Tags, "vision")
-	}
-
-	e.Variants = nil
-	for _, v := range variants {
-		e.Variants = append(e.Variants, VariantRef{Model: v})
-	}
-	return e
-}
-
-func hasTag(tags []string, want string) bool {
-	for _, t := range tags {
-		if t == want {
-			return true
-		}
-	}
-	return false
-}
-
-// resolveCounterpart probes the unsloth candidates in order and returns the
-// first that publishes files.
-//
-// CounterpartCandidates is handed a BARE repo name: its cleaner does not strip
-// an owner prefix, so passing "mudler/Foo-APEX-GGUF" would yield "mudler/Foo"
-// and compose into the nonsense probe "unsloth/mudler/Foo".
-//
-// It also returns the candidates HuggingFace refused to describe. Those are
-// indistinguishable from absent without credentials, so they are skipped, but
-// they are named rather than dropped: one of them could be a real gated repo
-// whose quants belong in the gallery.
-func resolveCounterpart(client *http.Client, repoBase, stem string) (string, []GGUFFile, []string, error) {
-	var unavailable []string
-	for _, cand := range CounterpartCandidates(repoBase, stem) {
-		repo := unslothOwner + "/" + cand + "-GGUF"
-		files, unreadable, err := FetchOptionalRepoFiles(client, repo)
-		if err != nil {
-			return "", nil, unavailable, fmt.Errorf("probing %s: %w", repo, err)
-		}
-		if unreadable {
-			unavailable = append(unavailable, repo)
-			continue
-		}
-		if len(files) > 0 {
-			return repo, files, unavailable, nil
-		}
-	}
-	return "", nil, unavailable, nil
-}
-
-// reportUnclassified prints the files discovery turned into nothing.
-//
-// It is a set difference on COUNTS, not a re-match of filenames: re-matching
-// would duplicate the tier regex from discover.go and the two copies would
-// drift. The likeliest trigger is a typo or case change from a publishing script
-// rather than a genuine sixth tier, and because generation falls back to the
-// plain ladder when the imatrix one is empty, a repo whose imatrix files all
-// fail to match silently downgrades the whole family instead of erroring. The
-// downstream HTTP check cannot catch that: it validates URLs that were emitted,
-// and an undiscovered tier emits none.
-// It returns the census so the run can total it.
-func reportUnclassified(repo string, files []GGUFFile, imatrix, plain []Tier) fileCensus {
-	mmprojCount, fullPrecision := 0, 0
-	for _, f := range files {
-		// The mmproj test comes first because projectors are themselves often
-		// published at f16 (mmproj-F16.gguf), and counting such a file in both
-		// buckets would understate the unclassified remainder.
-		if strings.HasPrefix(f.Name, "mmproj") {
-			mmprojCount++
-			continue
-		}
-		if IsFullPrecision(f.Name) {
-			fullPrecision++
-		}
-	}
-
-	classified := len(imatrix) + len(plain) + mmprojCount + fullPrecision
-	if classified >= len(files) {
-		return fileCensus{fullPrecision: fullPrecision}
-	}
-	fmt.Fprintf(os.Stderr, "UNCLASSIFIED %s: %d of %d .gguf files classified, %d unaccounted for\n",
-		repo, classified, len(files), len(files)-classified)
-	return fileCensus{unclassified: len(files) - classified, fullPrecision: fullPrecision}
-}
-
-// reportReuse splits Merge's single reused map into the two cases it conflates.
-//
-// A URI match means the gallery already ships exactly these weights, and
-// pointing the parent at the existing entry is correct. A NAME match with a
-// different URI means an unrelated entry happens to own the name, and
-// referencing it would point the parent at different weights than were
-// generated, substituting a build without saying so. Only the first is safe to
-// wave through.
-func reportReuse(existing *ExistingIndex, generated []GalleryEntry, reused map[string]string) {
-	byName := map[string]GalleryEntry{}
-	for _, e := range generated {
-		if _, seen := byName[e.Name]; !seen {
-			byName[e.Name] = e
-		}
-	}
-
-	var nameCollisions, uriMatches []string
-	for name, target := range reused {
-		gen := byName[name]
-		uri := ""
-		if len(gen.Files) > 0 {
-			uri = gen.Files[0].URI
-		}
-
-		switch {
-		case hasName(existing, name):
-			nameCollisions = append(nameCollisions,
-				fmt.Sprintf("  %s -> gallery entry of the same name (generated uri: %s)", name, orNone(uri)))
-		case target == name:
-			nameCollisions = append(nameCollisions,
-				fmt.Sprintf("  %s -> earlier entry of the same name in this batch (generated uri: %s)", name, orNone(uri)))
-		default:
-			uriMatches = append(uriMatches, fmt.Sprintf("  %s -> %s (same weights: %s)", name, target, orNone(uri)))
-		}
-	}
-	sort.Strings(nameCollisions)
-	sort.Strings(uriMatches)
-
-	fmt.Printf("\nNAME COLLISIONS (%d) - inspect each by hand, the target may hold different weights\n", len(nameCollisions))
-	for _, l := range nameCollisions {
-		fmt.Println(l)
-	}
-	fmt.Printf("\nURI MATCHES (%d) - the gallery or this batch already ships these exact weights\n", len(uriMatches))
-	for _, l := range uriMatches {
-		fmt.Println(l)
-	}
-}
-
-// reportHubs prints exactly what will be written where. The splices are the part
-// a human has to read: they modify entries the gallery already ships, so the
-// review needs the target, the line, and every added reference spelled out.
-func reportHubs(ix *IndexText, inserts []galleryedit.Insert, newHubs []GalleryEntry) {
-	fmt.Printf("\nHUBS SPLICED (%d) - variants added to the EXISTING base model entry, nothing else touched\n", len(inserts))
-	for _, in := range inserts {
-		e := ix.Find(in.Entry.Name)
-		fmt.Printf("  %s (line %d, %d variant(s) already declared):\n", in.Entry.Name, in.Entry.StartLine+1, len(e.Variants))
-		for _, v := range in.Variants {
-			fmt.Printf("    + - model: %s\n", galleryedit.QuoteName(v))
-		}
-	}
-
-	fmt.Printf("\nHUBS CREATED (%d) - the gallery ships no base model entry, so one is emitted for it\n", len(newHubs))
-	for _, h := range newHubs {
-		fmt.Printf("  %s:\n", h.Name)
-		for _, v := range h.Variants {
-			fmt.Printf("    - model: %s\n", v.Model)
-		}
-	}
-}
-
-// reportSkipped names the counterpart repos HuggingFace would not describe, and
-// totals the other two silent-shortfall counters alongside them.
-//
-// A skipped repo is not the same as a clean 404. HuggingFace answers 401 for a
-// nonexistent repo to an unauthenticated client, so the overwhelmingly likely
-// reading is "there is no such counterpart", which is the normal case for the
-// community merges. But a private or gated repo answers 401 too, and that one
-// WOULD have quants worth shipping. Printing the list is what keeps that
-// possibility auditable instead of silently discarded.
-func reportSkipped(families []family) ([]string, fileCensus, int, int) {
-	var skipped []string
-	var census fileCensus
-	fullPrecisionRepos, unaccounted := 0, 0
-	for _, f := range families {
-		skipped = append(skipped, f.skippedRepos...)
-		census.add(f.census)
-		if f.census.fullPrecision > 0 {
-			fullPrecisionRepos++
-		}
-		unaccounted += f.unaccounted
-	}
-	sort.Strings(skipped)
-
-	fmt.Printf("\nREPOS SKIPPED AS UNAVAILABLE (%d) - HuggingFace answered 401/403, which is indistinguishable from absent without a token; check none of these is a real gated repo\n", len(skipped))
-	for _, r := range skipped {
-		fmt.Printf("  %s\n", r)
-	}
-	return skipped, census, fullPrecisionRepos, unaccounted
-}
-
-func hasName(ix *ExistingIndex, name string) bool {
-	_, ok := ix.ByName[name]
-	return ok
-}
-
-func orNone(s string) string {
-	if s == "" {
-		return "(no files)"
-	}
-	return s
-}
-
-// writeEntries emits the additions.
-//
-// -apply does two things in one pass: it writes back the spliced lines, which
-// differ from the original only by the variant lines galleryedit inserted, and
-// then appends the new entries. New entries are APPENDED rather than merged into
-// the structure, for the same reason the splice is textual: a YAML round trip
-// over 40,000 lines would reflow the whole file into an unreviewable diff.
-func writeEntries(add []GalleryEntry, lines []string, outPath string, apply bool, indexPath string) error {
-	if apply {
-		if err := os.WriteFile(indexPath, []byte(strings.Join(lines, "\n")), 0o644); err != nil {
-			return err
-		}
-		fmt.Printf("spliced %s\n", indexPath)
-	}
-
-	if len(add) == 0 {
-		fmt.Println("nothing to append")
-		return nil
-	}
-
-	blob, err := yaml.Marshal(add)
-	if err != nil {
-		return err
-	}
-
-	if outPath != "" {
-		if err := os.WriteFile(outPath, blob, 0o644); err != nil {
-			return err
-		}
-		fmt.Printf("wrote %d entries to %s\n", len(add), outPath)
-	}
-
-	if apply {
-		f, err := os.OpenFile(indexPath, os.O_APPEND|os.O_WRONLY, 0o644)
-		if err != nil {
-			return err
-		}
-		defer f.Close()
-		if _, err := f.Write(blob); err != nil {
-			return err
-		}
-		fmt.Printf("appended %d entries to %s\n", len(add), indexPath)
-	}
-	return nil
-}
-
-// listAPEXRepos returns the mudler repos whose name marks them as APEX builds.
-func listAPEXRepos(client *http.Client) ([]string, error) {
-	req, err := http.NewRequest(http.MethodGet, authorListURL, nil)
-	if err != nil {
-		return nil, err
-	}
-	req.Header.Set("User-Agent", "localai-apexentries/1.0")
-
-	resp, err := client.Do(req)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode != http.StatusOK {
-		return nil, fmt.Errorf("listing models: unexpected status %d", resp.StatusCode)
-	}
-
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return nil, err
-	}
-
-	var models []struct {
-		ID string `json:"id"`
-	}
-	if err := json.Unmarshal(body, &models); err != nil {
-		return nil, fmt.Errorf("decoding model list: %w", err)
-	}
-
-	var out []string
-	for _, m := range models {
-		if strings.Contains(m.ID, "APEX") {
-			out = append(out, m.ID)
-		}
-	}
-	sort.Strings(out)
-	return out, nil
-}
-
-func restrict(repos []string, only string) []string {
-	want := map[string]bool{}
-	for _, r := range strings.Split(only, ",") {
-		if r = strings.TrimSpace(r); r != "" {
-			want[r] = true
-		}
-	}
-
-	var out []string
-	for _, r := range repos {
-		if want[r] {
-			out = append(out, r)
-			delete(want, r)
-		}
-	}
-	// A name in -only that matched nothing is a typo, not an empty result.
-	for r := range want {
-		fmt.Fprintf(os.Stderr, "WARNING: -only names %s, which is not an APEX repo of this author\n", r)
-	}
-	return out
-}
-
-func sortTiers(tiers []Tier) {
-	sort.SliceStable(tiers, func(i, j int) bool { return rungRank[tiers[i].Label] < rungRank[tiers[j].Label] })
-}
-
-func tierLabels(tiers []Tier) string {
-	var out []string
-	for _, t := range tiers {
-		out = append(out, t.Label)
-	}
-	return strings.Join(out, ",")
-}
-
-func quantLabels(builds []QuantBuild) string {
-	var out []string
-	for _, b := range builds {
-		l := b.Quant
-		if b.Sharded {
-			l += fmt.Sprintf("(%d shards)", len(b.Files))
-		}
-		out = append(out, l)
-	}
-	return strings.Join(out, ",")
-}
-
-// slug turns a repo, tier or quant label into a gallery entry name component.
-func slug(s string) string {
-	return strings.ReplaceAll(strings.ToLower(s), "_", "-")
-}

.github/ci/apexentries/main_test.go

@@ -1,344 +0,0 @@
-package main
-
-import (
-	"strings"
-
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-
-	"github.com/mudler/LocalAI/.github/ci/galleryedit"
-)
-
-func mustIndex(text string) *IndexText {
-	ix, err := ParseIndexText(text)
-	ExpectWithOffset(1, err).ToNot(HaveOccurred())
-	return ix
-}
-
-// buildOf renders a realistic child so the specs exercise the payload a hub
-// actually inherits rather than a bare name.
-func buildOf(name, repo, file string, rank int) childBuild {
-	return childBuild{
-		rank: rank,
-		entry: RenderChild(ChildInput{
-			Name:     name,
-			Repo:     repo,
-			Template: entryTemplate,
-			Weights:  []GGUFFile{{Name: file, SHA256: "aa"}},
-			BaseTags: baseTags,
-		}),
-	}
-}
-
-var _ = Describe("ResolveHub", func() {
-	It("picks the base model name over the APEX name, even when both are in the gallery", func() {
-		// The hub is the entry a user searches for. If the *-apex entry were
-		// chosen the family would be gathered under a name nobody looks up, and
-		// the base entry would go on advertising only its own build.
-		ix := mustIndex("- name: qwen3.6-35b-a3b\n  url: u\n- name: qwen3.6-35b-a3b-apex\n  url: u\n")
-
-		name, exists := ResolveHub(ix, "Qwen3.6-35B-A3B-APEX", "Qwen3.6-35B-A3B-APEX")
-
-		Expect(name).To(Equal("qwen3.6-35b-a3b"))
-		Expect(exists).To(BeTrue())
-	})
-
-	It("falls back to the stem-derived candidate when the repo-derived one is absent", func() {
-		// gemma's repo says "-it" and its published files do not, so only one of
-		// the two candidates can match whatever the base entry was named after.
-		ix := mustIndex("- name: gemma-4-26b-a4b\n  url: u\n")
-
-		name, exists := ResolveHub(ix, "gemma-4-26B-A4B-it-APEX", "gemma-4-26B-A4B-APEX")
-
-		Expect(name).To(Equal("gemma-4-26b-a4b"))
-		Expect(exists).To(BeTrue())
-	})
-
-	It("reports the base name as absent rather than settling for the APEX entry", func() {
-		ix := mustIndex("- name: qwen3.5-35b-a3b-apex\n  url: u\n")
-
-		name, exists := ResolveHub(ix, "Qwen3.5-35B-A3B-APEX", "Qwen3.5-35B-A3B-APEX")
-
-		Expect(name).To(Equal("qwen3.5-35b-a3b"))
-		Expect(exists).To(BeFalse())
-	})
-
-	It("strips the MTP and TQ markers as well as APEX", func() {
-		ix := mustIndex("- name: qwen3.6-35b-a3b\n  url: u\n")
-
-		name, exists := ResolveHub(ix, "Qwen3.6-35B-A3B-APEX-MTP", "Qwen3.6-35B-A3B-APEX-MTP")
-
-		Expect(name).To(Equal("qwen3.6-35b-a3b"))
-		Expect(exists).To(BeTrue())
-	})
-})
-
-var _ = Describe("planHubs", func() {
-	noReuse := map[string]string{}
-	allAdded := func(names ...string) map[string]bool {
-		out := map[string]bool{}
-		for _, n := range names {
-			out[n] = true
-		}
-		return out
-	}
-
-	It("splices into the existing base entry instead of emitting an *-apex parent", func() {
-		ix := mustIndex("- name: step-3.7-flash\n  url: u\n- name: other\n  url: u\n")
-		fams := []family{{
-			repo:     "mudler/Step-3.7-Flash-APEX-GGUF",
-			repoBase: "Step-3.7-Flash-APEX",
-			stem:     "Step-3.7-Flash-APEX",
-			children: []childBuild{buildOf("step-3.7-flash-apex-i-quality", "mudler/Step-3.7-Flash-APEX-GGUF", "a.gguf", 0)},
-		}}
-
-		inserts, newHubs, err := planHubs(fams, ix, noReuse, allAdded("step-3.7-flash-apex-i-quality"))
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(newHubs).To(BeEmpty())
-		Expect(inserts).To(HaveLen(1))
-		Expect(inserts[0].Entry.Name).To(Equal("step-3.7-flash"))
-		Expect(inserts[0].Variants).To(Equal([]string{"step-3.7-flash-apex-i-quality"}))
-	})
-
-	It("merges into an entry that already declares variants, without repeating one", func() {
-		// The gallery's qwen3.6-35b-a3b already lists its APEX build. Re-adding it
-		// would put a duplicate key's worth of noise in the diff and a duplicate
-		// reference in the entry.
-		ix := mustIndex("- name: qwen3.6-35b-a3b\n  variants:\n    - model: qwen3.6-35b-a3b-apex\n  url: u\n" +
-			"- name: qwen3.6-35b-a3b-apex\n  url: u\n")
-		fams := []family{{
-			repo:     "mudler/Qwen3.6-35B-A3B-APEX-GGUF",
-			repoBase: "Qwen3.6-35B-A3B-APEX",
-			stem:     "Qwen3.6-35B-A3B-APEX",
-			children: []childBuild{buildOf("qwen3.6-35b-a3b-apex-i-quality", "mudler/Qwen3.6-35B-A3B-APEX-GGUF", "a.gguf", 0)},
-		}}
-
-		inserts, newHubs, err := planHubs(fams, ix, noReuse, allAdded("qwen3.6-35b-a3b-apex-i-quality"))
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(newHubs).To(BeEmpty())
-		Expect(inserts[0].Variants).To(Equal([]string{"qwen3.6-35b-a3b-apex-i-quality"}))
-
-		out, err := galleryedit.Apply(ix.Lines, inserts)
-		Expect(err).ToNot(HaveOccurred())
-		Expect(strings.Count(strings.Join(out, "\n"), "variants:")).To(Equal(1))
-		Expect(out).To(HaveLen(len(ix.Lines) + 1))
-	})
-
-	It("never lets the hub reference itself", func() {
-		// An unsloth rung whose weights the gallery already ships under the base
-		// name resolves, through Merge, straight back to the hub. The verifier
-		// reads a self reference as a variant that declares variants of its own.
-		ix := mustIndex("- name: step-3.7-flash\n  url: u\n")
-		fams := []family{{
-			repo:     "mudler/Step-3.7-Flash-APEX-GGUF",
-			repoBase: "Step-3.7-Flash-APEX",
-			stem:     "Step-3.7-Flash-APEX",
-			children: []childBuild{buildOf("step-3.7-flash-ud-q4-k-m", "unsloth/Step-3.7-Flash-GGUF", "a.gguf", 100)},
-		}}
-
-		inserts, _, err := planHubs(fams, ix, map[string]string{"step-3.7-flash-ud-q4-k-m": "step-3.7-flash"}, map[string]bool{})
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(inserts).To(BeEmpty())
-	})
-
-	It("emits a hub named for the base model when the gallery has none", func() {
-		ix := mustIndex("- name: qwen3.5-35b-a3b-apex\n  url: u\n")
-		fams := []family{{
-			repo:      "mudler/Qwen3.5-35B-A3B-APEX-GGUF",
-			repoBase:  "Qwen3.5-35B-A3B-APEX",
-			stem:      "Qwen3.5-35B-A3B-APEX",
-			hasMMProj: true,
-			children: []childBuild{
-				buildOf("qwen3.5-35b-a3b-apex-i-quality", "mudler/Qwen3.5-35B-A3B-APEX-GGUF", "a.gguf", 0),
-				buildOf("qwen3.5-35b-a3b-ud-q6-k", "unsloth/Qwen3.5-35B-A3B-GGUF", "b.gguf", 102),
-			},
-		}}
-
-		inserts, newHubs, err := planHubs(fams, ix, noReuse,
-			allAdded("qwen3.5-35b-a3b-apex-i-quality", "qwen3.5-35b-a3b-ud-q6-k"))
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(inserts).To(BeEmpty())
-		Expect(newHubs).To(HaveLen(1))
-
-		hub := newHubs[0]
-		Expect(hub.Name).To(Equal("qwen3.5-35b-a3b"))
-		Expect(hub.Name).ToNot(HaveSuffix("-apex"))
-
-		// A hand-written *-apex entry is an ordinary build, referenced like any
-		// other rung and never deleted or renamed.
-		Expect(hub.Variants).To(Equal([]VariantRef{
-			{Model: "qwen3.5-35b-a3b-apex"},
-			{Model: "qwen3.5-35b-a3b-apex-i-quality"},
-			{Model: "qwen3.5-35b-a3b-ud-q6-k"},
-		}))
-
-		// The verifier skips entries with no declared backend, so a hub without
-		// one would escape the tagging check in silence.
-		Expect(hub.Overrides).To(HaveKeyWithValue("backend", "llama-cpp"))
-		Expect(hub.Files).ToNot(BeEmpty())
-		Expect(hub.Tags).To(ContainElement("vision"))
-	})
-
-	It("gathers two APEX repos that share one base model under a single hub", func() {
-		ix := mustIndex("- name: unrelated\n  url: u\n")
-		fams := []family{
-			{
-				repo:     "mudler/Solo-APEX-GGUF",
-				repoBase: "Solo-APEX",
-				stem:     "Solo-APEX",
-				children: []childBuild{buildOf("solo-apex-i-quality", "mudler/Solo-APEX-GGUF", "a.gguf", 0)},
-			},
-			{
-				repo:     "mudler/Solo-APEX-MTP-GGUF",
-				repoBase: "Solo-APEX-MTP",
-				stem:     "Solo-APEX-MTP",
-				children: []childBuild{buildOf("solo-apex-mtp-i-quality", "mudler/Solo-APEX-MTP-GGUF", "b.gguf", 0)},
-			},
-		}
-
-		_, newHubs, err := planHubs(fams, ix, noReuse, allAdded("solo-apex-i-quality", "solo-apex-mtp-i-quality"))
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(newHubs).To(HaveLen(1))
-		Expect(newHubs[0].Name).To(Equal("solo"))
-		Expect(newHubs[0].Variants).To(Equal([]VariantRef{
-			{Model: "solo-apex-i-quality"},
-			{Model: "solo-apex-mtp-i-quality"},
-		}))
-	})
-})
-
-var _ = Describe("hubVariants", func() {
-	It("orders builds by quality rung rather than discovery order", func() {
-		// DiscoverAPEXTiers preserves input order and the HF API returns siblings
-		// alphabetically, so an unsorted list reads I-Balanced, I-Compact, I-Mini,
-		// I-Nano, I-Quality. Selection ignores authored order; this is for the
-		// human reading the file.
-		f := family{repoBase: "X-APEX", stem: "X-APEX", children: []childBuild{
-			{rank: rungRank["I-Nano"], entry: GalleryEntry{Name: "x-i-nano"}},
-			{rank: 100, entry: GalleryEntry{Name: "x-ud-q4-k-m"}},
-			{rank: rungRank["I-Quality"], entry: GalleryEntry{Name: "x-i-quality"}},
-			{rank: rungRank["I-Compact"], entry: GalleryEntry{Name: "x-i-compact"}},
-		}}
-
-		got := hubVariants(&f, mustIndex("- name: x\n  url: u\n"), map[string]string{}, map[string]bool{})
-
-		Expect(got).To(Equal([]string{"x-i-quality", "x-i-compact", "x-i-nano", "x-ud-q4-k-m"}))
-	})
-})
-
-var _ = Describe("ParseIndexText", func() {
-	It("refuses to edit by line number when the two views of the file disagree", func() {
-		_, err := ParseIndexText("- name: one\n  url: u\n-\n")
-		Expect(err).To(MatchError(ContainSubstring("empty")))
-	})
-
-	It("records the line range of each entry", func() {
-		ix := mustIndex("- name: first\n  url: u\n- name: second\n  url: u\n")
-
-		Expect(ix.Find("FIRST").Pos.StartLine).To(Equal(0))
-		Expect(ix.Find("first").Pos.EndLine).To(Equal(2))
-		Expect(ix.Find("second").Pos.StartLine).To(Equal(2))
-	})
-})
-
-var _ = Describe("resolveVariant", func() {
-	It("keeps an entry that was emitted even when it is also in reused", func() {
-		// A within-batch name collision records reused[name] = name while the
-		// FIRST entry of that name is still in add. Treating presence in reused as
-		// "dropped" would emit nothing for it.
-		added := map[string]bool{"dup": true}
-		reused := map[string]string{"dup": "dup"}
-
-		Expect(resolveVariant("dup", reused, added)).To(Equal("dup"))
-	})
-
-	It("redirects a reused name at the entry that stands in for it", func() {
-		added := map[string]bool{}
-		reused := map[string]string{"generated": "already-in-gallery"}
-
-		Expect(resolveVariant("generated", reused, added)).To(Equal("already-in-gallery"))
-	})
-})
-
-var _ = Describe("slug", func() {
-	It("lowercases and turns quant underscores into hyphens", func() {
-		Expect(slug("UD-Q4_K_M")).To(Equal("ud-q4-k-m"))
-		Expect(slug("gemma-4-26B-A4B-it-APEX")).To(Equal("gemma-4-26b-a4b-it-apex"))
-		Expect(slug("I-Nano")).To(Equal("i-nano"))
-	})
-})
-
-var _ = Describe("sortTiers", func() {
-	It("puts the imatrix ladder in descending quality order", func() {
-		tiers := []Tier{
-			{Label: "I-Balanced"}, {Label: "I-Compact"}, {Label: "I-Mini"},
-			{Label: "I-Nano"}, {Label: "I-Quality"},
-		}
-		sortTiers(tiers)
-		Expect(tierLabels(tiers)).To(Equal("I-Quality,I-Balanced,I-Compact,I-Mini,I-Nano"))
-	})
-})
-
-var _ = Describe("restrict", func() {
-	It("keeps only the named repos", func() {
-		got := restrict([]string{"mudler/A-APEX-GGUF", "mudler/B-APEX-GGUF"}, "mudler/B-APEX-GGUF")
-		Expect(got).To(Equal([]string{"mudler/B-APEX-GGUF"}))
-	})
-
-	It("returns nothing when the filter matches nothing", func() {
-		Expect(restrict([]string{"mudler/A-APEX-GGUF"}, "mudler/typo")).To(BeEmpty())
-	})
-})
-
-var _ = Describe("reportUnclassified", func() {
-	// One real imatrix rung is always present so the specs measure how the
-	// remaining files are bucketed, not an empty-repo edge case.
-	tier := Tier{Label: "I-Quality", File: GGUFFile{Name: "Model-APEX-I-Quality.gguf"}}
-
-	censusOf := func(names ...string) fileCensus {
-		files := []GGUFFile{tier.File}
-		for _, n := range names {
-			files = append(files, GGUFFile{Name: n})
-		}
-		return reportUnclassified("mudler/Model-APEX-GGUF", files, []Tier{tier}, nil)
-	}
-
-	It("counts a flat full-precision source as excluded, not unclassified", func() {
-		got := censusOf("Carnice-MoE-35B-A3B-F16.gguf")
-		Expect(got.fullPrecision).To(Equal(1))
-		Expect(got.unclassified).To(Equal(0))
-	})
-
-	It("counts every shard of a sharded full-precision source as excluded", func() {
-		got := censusOf(
-			"MiniMax-M2.7-APEX-F16-00001-of-00003.gguf",
-			"MiniMax-M2.7-APEX-F16-00002-of-00003.gguf",
-			"MiniMax-M2.7-APEX-F16-00003-of-00003.gguf",
-		)
-		Expect(got.fullPrecision).To(Equal(3))
-		Expect(got.unclassified).To(Equal(0))
-	})
-
-	It("treats bf16 the same as f16, in either case", func() {
-		got := censusOf("Model-APEX-BF16.gguf", "Model-APEX-bf16-00001-of-00002.gguf", "Model-APEX-f16.gguf")
-		Expect(got.fullPrecision).To(Equal(3))
-		Expect(got.unclassified).To(Equal(0))
-	})
-
-	It("still reports a genuinely unknown filename as unclassified", func() {
-		got := censusOf("Model-APEX-Turbo.gguf")
-		Expect(got.unclassified).To(Equal(1))
-		Expect(got.fullPrecision).To(Equal(0))
-	})
-
-	It("separates the two kinds when a repo publishes both", func() {
-		got := censusOf("Model-APEX-F16.gguf", "Model-APEX-Turbo.gguf")
-		Expect(got.fullPrecision).To(Equal(1))
-		Expect(got.unclassified).To(Equal(1))
-	})
-})

.github/ci/apexentries/merge.go

@@ -1,143 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"os"
-	"strings"
-
-	"gopkg.in/yaml.v3"
-)
-
-const (
-	hfShorthandPrefix = "huggingface://"
-	hfResolvePrefix   = "https://huggingface.co/"
-	hfResolveInfix    = "/resolve/main/"
-)
-
-// canonicalURI reduces the two interchangeable spellings of a HuggingFace file
-// to one key, so a generated resolve/main URI dedups against the shorthand the
-// gallery uses for the majority of its entries.
-//
-// The repo is exactly the first two path segments; everything after is the file
-// path, which may itself contain slashes because sharded quants live in a
-// subdirectory. Anything that is not recognisably one of the two forms is
-// returned unchanged rather than guessed at, so mirrors and other hosts still
-// dedup on their literal string.
-func canonicalURI(uri string) string {
-	switch {
-	case strings.HasPrefix(uri, hfShorthandPrefix):
-		rest := strings.TrimPrefix(uri, hfShorthandPrefix)
-		owner, after, ok := strings.Cut(rest, "/")
-		if !ok {
-			return uri
-		}
-		name, file, ok := strings.Cut(after, "/")
-		if !ok || owner == "" || name == "" || file == "" {
-			return uri
-		}
-		return hfShorthandPrefix + owner + "/" + name + "/" + file
-
-	case strings.HasPrefix(uri, hfResolvePrefix):
-		rest := strings.TrimPrefix(uri, hfResolvePrefix)
-		repo, file, ok := strings.Cut(rest, hfResolveInfix)
-		if !ok || file == "" {
-			return uri
-		}
-		// A repo is owner/name and nothing more; a longer prefix means this is
-		// some other huggingface.co URL that must not be rewritten.
-		owner, name, ok := strings.Cut(repo, "/")
-		if !ok || owner == "" || name == "" || strings.Contains(name, "/") {
-			return uri
-		}
-		return hfShorthandPrefix + repo + "/" + file
-
-	default:
-		return uri
-	}
-}
-
-// ExistingIndex is the lookup built from the current gallery: entry names, and
-// which entry claims each weight URI.
-type ExistingIndex struct {
-	ByName map[string]int
-	ByURI  map[string]string
-}
-
-// LoadExisting reads the gallery index for dedup purposes only. It is
-// deliberately not used to rewrite the file: the index is 40,000 lines, and a
-// YAML round trip would reflow the whole thing into an unreviewable diff.
-func LoadExisting(path string) (*ExistingIndex, error) {
-	raw, err := os.ReadFile(path)
-	if err != nil {
-		return nil, err
-	}
-
-	var entries []struct {
-		Name  string `yaml:"name"`
-		Files []struct {
-			URI string `yaml:"uri"`
-		} `yaml:"files"`
-	}
-	if err := yaml.Unmarshal(raw, &entries); err != nil {
-		return nil, fmt.Errorf("parsing %s: %w", path, err)
-	}
-
-	ix := &ExistingIndex{ByName: map[string]int{}, ByURI: map[string]string{}}
-	for i, e := range entries {
-		ix.ByName[e.Name] = i
-		for _, f := range e.Files {
-			if f.URI != "" {
-				ix.ByURI[canonicalURI(f.URI)] = e.Name
-			}
-		}
-	}
-	return ix, nil
-}
-
-// Merge splits generated entries into those to add and those already covered.
-// reused maps a generated name to the existing entry that stands in for it, so
-// a parent can reference what is already there instead of duplicating weights.
-// Several APEX repos share one base model, so the same counterpart rungs are
-// generated more than once in a batch. The batch has to dedup against itself as
-// well as against the gallery, tracked locally because the caller may reuse the
-// ExistingIndex it passed in.
-func Merge(existing *ExistingIndex, generated []GalleryEntry) (add []GalleryEntry, reused map[string]string) {
-	reused = map[string]string{}
-	batchNames := map[string]string{}
-	batchURIs := map[string]string{}
-
-	// Canonicalized into a local copy rather than in place: an ExistingIndex may
-	// be hand-built or reused by the caller, so Merge must not rewrite it.
-	existingURIs := make(map[string]string, len(existing.ByURI))
-	for uri, owner := range existing.ByURI {
-		existingURIs[canonicalURI(uri)] = owner
-	}
-
-	for _, e := range generated {
-		// Name is checked before URI: a name collision must block the add
-		// whatever the weights say, since duplicate names corrupt the index.
-		if _, clash := existing.ByName[e.Name]; clash {
-			reused[e.Name] = e.Name
-			continue
-		}
-		if claimant, clash := batchNames[e.Name]; clash {
-			reused[e.Name] = claimant
-			continue
-		}
-		if len(e.Files) > 0 {
-			uri := canonicalURI(e.Files[0].URI)
-			if owner, ok := existingURIs[uri]; ok {
-				reused[e.Name] = owner
-				continue
-			}
-			if claimant, ok := batchURIs[uri]; ok {
-				reused[e.Name] = claimant
-				continue
-			}
-			batchURIs[uri] = e.Name
-		}
-		batchNames[e.Name] = e.Name
-		add = append(add, e)
-	}
-	return add, reused
-}

.github/ci/apexentries/merge_test.go

@@ -1,183 +0,0 @@
-package main
-
-import (
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("Merge", func() {
-	It("drops a generated entry whose weight URI already exists and reports the existing name", func() {
-		existing := &ExistingIndex{
-			ByName: map[string]int{"qwen3.6-35b-a3b-apex": 0},
-			ByURI: map[string]string{
-				"https://huggingface.co/mudler/X-APEX-GGUF/resolve/main/X-APEX-I-Quality.gguf": "qwen3.6-35b-a3b-apex",
-			},
-		}
-		gen := []GalleryEntry{{
-			Name:  "x-apex-i-quality",
-			Files: []EntryFile{{URI: "https://huggingface.co/mudler/X-APEX-GGUF/resolve/main/X-APEX-I-Quality.gguf"}},
-		}}
-
-		add, reused := Merge(existing, gen)
-
-		Expect(add).To(BeEmpty())
-		Expect(reused).To(HaveKeyWithValue("x-apex-i-quality", "qwen3.6-35b-a3b-apex"))
-	})
-
-	It("keeps a generated entry whose weights are new", func() {
-		existing := &ExistingIndex{ByName: map[string]int{}, ByURI: map[string]string{}}
-		gen := []GalleryEntry{{
-			Name:  "x-apex-i-mini",
-			Files: []EntryFile{{URI: "https://huggingface.co/mudler/X-APEX-GGUF/resolve/main/X-APEX-I-Mini.gguf"}},
-		}}
-
-		add, reused := Merge(existing, gen)
-
-		Expect(add).To(HaveLen(1))
-		Expect(reused).To(BeEmpty())
-	})
-
-	It("refuses to add an entry whose name collides with an existing one", func() {
-		existing := &ExistingIndex{
-			ByName: map[string]int{"x-apex-i-mini": 0},
-			ByURI:  map[string]string{},
-		}
-		gen := []GalleryEntry{{
-			Name:  "x-apex-i-mini",
-			Files: []EntryFile{{URI: "https://huggingface.co/mudler/X-APEX-GGUF/resolve/main/other.gguf"}},
-		}}
-
-		add, reused := Merge(existing, gen)
-
-		Expect(add).To(BeEmpty())
-		Expect(reused).To(HaveKeyWithValue("x-apex-i-mini", "x-apex-i-mini"))
-	})
-
-	// The gallery records most of its URIs in huggingface:// shorthand while
-	// render.go only ever emits the resolve/main form, so without
-	// canonicalization the majority of the file is invisible to the dedup.
-	It("matches a generated https URI against the shorthand form recorded in the gallery", func() {
-		existing := &ExistingIndex{
-			ByName: map[string]int{"foo-gguf-q8-0": 0},
-			ByURI: map[string]string{
-				"huggingface://unsloth/Foo-GGUF/Foo-Q8_0.gguf": "foo-gguf-q8-0",
-			},
-		}
-		gen := []GalleryEntry{{
-			Name:  "foo-apex-q8-0",
-			Files: []EntryFile{{URI: "https://huggingface.co/unsloth/Foo-GGUF/resolve/main/Foo-Q8_0.gguf"}},
-		}}
-
-		add, reused := Merge(existing, gen)
-
-		Expect(add).To(BeEmpty())
-		Expect(reused).To(HaveKeyWithValue("foo-apex-q8-0", "foo-gguf-q8-0"))
-	})
-
-	It("matches a generated shorthand URI against the https form recorded in the gallery", func() {
-		existing := &ExistingIndex{
-			ByName: map[string]int{"foo-gguf-q8-0": 0},
-			ByURI: map[string]string{
-				"https://huggingface.co/unsloth/Foo-GGUF/resolve/main/Foo-Q8_0.gguf": "foo-gguf-q8-0",
-			},
-		}
-		gen := []GalleryEntry{{
-			Name:  "foo-apex-q8-0",
-			Files: []EntryFile{{URI: "huggingface://unsloth/Foo-GGUF/Foo-Q8_0.gguf"}},
-		}}
-
-		add, reused := Merge(existing, gen)
-
-		Expect(add).To(BeEmpty())
-		Expect(reused).To(HaveKeyWithValue("foo-apex-q8-0", "foo-gguf-q8-0"))
-	})
-
-	// Sharded quants live under a subdirectory, so the file path carries slashes
-	// of its own and only the first two segments are the repo.
-	It("matches across both forms when the file path has a subdirectory", func() {
-		existing := &ExistingIndex{
-			ByName: map[string]int{"model-ud-q4-k-m": 0},
-			ByURI: map[string]string{
-				"huggingface://unsloth/Model-GGUF/UD-Q4_K_M/Model-UD-Q4_K_M-00001-of-00002.gguf": "model-ud-q4-k-m",
-			},
-		}
-		gen := []GalleryEntry{{
-			Name:  "model-apex-ud-q4-k-m",
-			Files: []EntryFile{{URI: "https://huggingface.co/unsloth/Model-GGUF/resolve/main/UD-Q4_K_M/Model-UD-Q4_K_M-00001-of-00002.gguf"}},
-		}}
-
-		add, reused := Merge(existing, gen)
-
-		Expect(add).To(BeEmpty())
-		Expect(reused).To(HaveKeyWithValue("model-apex-ud-q4-k-m", "model-ud-q4-k-m"))
-	})
-
-	// Several APEX repos share one base model, so the same unsloth rungs are
-	// generated more than once in a single batch.
-	It("adds only the first of two generated entries sharing a name", func() {
-		existing := &ExistingIndex{ByName: map[string]int{}, ByURI: map[string]string{}}
-		gen := []GalleryEntry{
-			{
-				Name:  "shared-rung-q8-0",
-				Files: []EntryFile{{URI: "https://huggingface.co/unsloth/Shared-GGUF/resolve/main/Shared-Q8_0.gguf"}},
-			},
-			{
-				Name:  "shared-rung-q8-0",
-				Files: []EntryFile{{URI: "https://huggingface.co/unsloth/Other-GGUF/resolve/main/Other-Q8_0.gguf"}},
-			},
-		}
-
-		add, reused := Merge(existing, gen)
-
-		Expect(add).To(HaveLen(1))
-		Expect(add[0].Files[0].URI).To(Equal("https://huggingface.co/unsloth/Shared-GGUF/resolve/main/Shared-Q8_0.gguf"))
-		Expect(reused).To(HaveKeyWithValue("shared-rung-q8-0", "shared-rung-q8-0"))
-	})
-
-	It("adds only the first of two generated entries sharing a primary URI", func() {
-		existing := &ExistingIndex{ByName: map[string]int{}, ByURI: map[string]string{}}
-		gen := []GalleryEntry{
-			{
-				Name:  "shared-rung-from-apex",
-				Files: []EntryFile{{URI: "https://huggingface.co/unsloth/Shared-GGUF/resolve/main/Shared-Q8_0.gguf"}},
-			},
-			{
-				Name:  "shared-rung-from-apex-mtp",
-				Files: []EntryFile{{URI: "huggingface://unsloth/Shared-GGUF/Shared-Q8_0.gguf"}},
-			},
-		}
-
-		add, reused := Merge(existing, gen)
-
-		Expect(add).To(HaveLen(1))
-		Expect(add[0].Name).To(Equal("shared-rung-from-apex"))
-		Expect(reused).To(HaveKeyWithValue("shared-rung-from-apex-mtp", "shared-rung-from-apex"))
-	})
-
-	// Anything that is not a HuggingFace URI must survive untouched, so an
-	// unrecognised scheme still dedups against the very same string.
-	It("leaves a URI in neither recognised form alone and still dedups it exactly", func() {
-		existing := &ExistingIndex{
-			ByName: map[string]int{"mirrored-model": 0},
-			ByURI: map[string]string{
-				"https://mirror.example.com/weights/Model-Q8_0.gguf": "mirrored-model",
-			},
-		}
-		gen := []GalleryEntry{
-			{
-				Name:  "mirrored-apex",
-				Files: []EntryFile{{URI: "https://mirror.example.com/weights/Model-Q8_0.gguf"}},
-			},
-			{
-				Name:  "elsewhere-apex",
-				Files: []EntryFile{{URI: "https://mirror.example.com/weights/Other-Q8_0.gguf"}},
-			},
-		}
-
-		add, reused := Merge(existing, gen)
-
-		Expect(add).To(HaveLen(1))
-		Expect(add[0].Name).To(Equal("elsewhere-apex"))
-		Expect(reused).To(HaveKeyWithValue("mirrored-apex", "mirrored-model"))
-	})
-})

.github/ci/apexentries/render.go

@@ -1,175 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"path"
-	"strings"
-)
-
-// EntryFile is one downloadable file of a gallery entry.
-type EntryFile struct {
-	Filename string `yaml:"filename"`
-	SHA256   string `yaml:"sha256"`
-	URI      string `yaml:"uri"`
-}
-
-// GalleryEntry is the subset of a gallery entry this generator writes.
-//
-// Named GalleryEntry rather than Entry because the test files dot-import
-// Ginkgo, whose table DSL exports an Entry that a package-level Entry would
-// collide with. The yaml tags are what the gallery index sees, so the Go
-// identifier is free to differ.
-type GalleryEntry struct {
-	Name        string         `yaml:"name"`
-	URL         string         `yaml:"url"`
-	Description string         `yaml:"description,omitempty"`
-	Tags        []string       `yaml:"tags,omitempty"`
-	Overrides   map[string]any `yaml:"overrides,omitempty"`
-	Files       []EntryFile    `yaml:"files,omitempty"`
-	Variants    []VariantRef   `yaml:"variants,omitempty"`
-}
-
-// VariantRef mirrors the gallery's variant reference: a name and nothing else.
-type VariantRef struct {
-	Model string `yaml:"model"`
-}
-
-// ChildInput is everything needed to render one non-parent entry.
-type ChildInput struct {
-	Name string
-	Repo string
-	// DraftRepo is the repo publishing the drafter, when it is not the repo
-	// publishing the weights. Speculative pairings routinely cross repos, so
-	// the drafter cannot be assumed to sit next to the weights. Empty means
-	// same-repo, which is how the *-APEX-MTP-GGUF repos ship.
-	DraftRepo string
-	Template  string
-	Weights   []GGUFFile
-	MMProj    *GGUFFile
-	SpecType  string
-	DraftFile *GGUFFile
-	BaseTags  []string
-}
-
-// specTuning is the acceptance-window tuning each spec type ships with, copied
-// from the hand-written entries that already run these two mechanisms rather
-// than invented here. The two differ because the drafters differ: self-drafted
-// MTP heads produce a short, high-confidence proposal (15+ hand-written entries
-// use 6 with a 0.75 floor), while a separate DFlash drafter is cheap enough to
-// run far ahead unconditionally (the five hand-written dflash entries use 15 and
-// set no floor).
-var specTuning = map[string][]string{
-	"draft-mtp":    {"spec_n_max:6", "spec_p_min:0.75"},
-	"draft-dflash": {"spec_n_max:15"},
-}
-
-func hfURI(repo, file string) string {
-	return fmt.Sprintf("https://huggingface.co/%s/resolve/main/%s", repo, file)
-}
-
-// localPath is where a downloaded file lands.
-//
-// The hand-written entries namespace by the repo's BARE name
-// (llama-cpp/models/<repo>/<file>), which is not unique. LiquidAI/LFM2.5-8B-A1B-GGUF
-// and unsloth/LFM2.5-8B-A1B-GGUF share a basename, so both claim
-// llama-cpp/models/LFM2.5-8B-A1B-GGUF/, and installing the second after the first
-// either overwrites weights whose recorded sha256 belongs to the other file or is
-// skipped as already present. Two owners publishing the same model name is the
-// normal case for quantizers, not an edge case, so the owner has to be in the path.
-//
-// The owner becomes its own path segment rather than being folded into the
-// directory name: owner/repo is unique on HuggingFace and "/" cannot occur inside
-// either half, so this is the only form that is collision-proof by construction.
-// It still reads as the hand-written convention with the owner restored, and the
-// extra depth is already present in the index for sharded builds.
-func localPath(kind, repo, file string) string {
-	// path.Dir yields "." for a repo named without an owner, which path.Join
-	// drops, so such a caller keeps the historical two-segment layout.
-	return path.Join("llama-cpp", kind, path.Dir(repo), path.Base(repo), file)
-}
-
-// RenderChild builds one child entry.
-//
-// The dflash/mtp tag is added if and only if this entry sets a spec_type,
-// because variant ranking reads tags and nothing else, and a tag that does not
-// match what the entry configures either promotes a build that is no faster or
-// hides one that is.
-func RenderChild(in ChildInput) GalleryEntry {
-	e := GalleryEntry{
-		Name:      in.Name,
-		URL:       fmt.Sprintf("github:mudler/LocalAI/gallery/%s@master", in.Template),
-		Tags:      append([]string{}, in.BaseTags...),
-		Overrides: map[string]any{},
-	}
-
-	// gallery/virtual.yaml carries no backend, so nothing else would name an
-	// engine for these entries. Matching the hand-written entries on
-	// known_usecases too: LocalAI would fall back to the backend defaults, but
-	// generated entries should not read differently from their neighbours.
-	e.Overrides["backend"] = "llama-cpp"
-	e.Overrides["known_usecases"] = []string{"chat"}
-
-	options := []string{"use_jinja:true"}
-
-	for _, w := range in.Weights {
-		e.Files = append(e.Files, EntryFile{
-			Filename: localPath("models", in.Repo, w.Name),
-			SHA256:   w.SHA256,
-			URI:      hfURI(in.Repo, w.Name),
-		})
-	}
-	e.Overrides["parameters"] = map[string]any{
-		"model": localPath("models", in.Repo, in.Weights[0].Name),
-	}
-
-	if in.MMProj != nil {
-		// An explicit known_usecases SUPPRESSES the backend-default fallback in
-		// core/gallery/models_types.go, so a multimodal entry left at chat-only
-		// never matches FilterGalleryModelsByUsecase(FLAG_VISION) or
-		// FilterGalleryModelsByMultimodal and vanishes from the UI's vision and
-		// multimodal filters. 19 of the 45 APEX repos ship an mmproj.
-		e.Overrides["known_usecases"] = []string{"chat", "vision"}
-		e.Overrides["mmproj"] = localPath("mmproj", in.Repo, in.MMProj.Name)
-		e.Files = append(e.Files, EntryFile{
-			Filename: localPath("mmproj", in.Repo, in.MMProj.Name),
-			SHA256:   in.MMProj.SHA256,
-			URI:      hfURI(in.Repo, in.MMProj.Name),
-		})
-	}
-
-	// A spec type is configured independently of a drafter FILE. Weights that
-	// carry their own MTP heads need no second download, and requiring one left
-	// the *-APEX-MTP-GGUF builds shipping the larger heads-bearing weights with
-	// the heads switched off: a strictly bigger download at the same speed,
-	// ranked identically to the plain rung at the same tier.
-	if in.SpecType != "" {
-		options = append(options, "spec_type:"+in.SpecType)
-		options = append(options, specTuning[in.SpecType]...)
-		// The tag is derived from the spec type this entry sets and from nothing
-		// else. Variant ranking reads tags only, so a tag taken from a repo or
-		// entry NAME would promote a build that is no faster whenever the name
-		// and the configuration disagree.
-		e.Tags = append(e.Tags, strings.TrimPrefix(in.SpecType, "draft-"))
-	}
-
-	if in.SpecType != "" && in.DraftFile != nil {
-		// Fall back to the weights repo so pairings that publish the drafter
-		// alongside the weights keep working without restating the repo.
-		draftRepo := in.DraftRepo
-		if draftRepo == "" {
-			draftRepo = in.Repo
-		}
-		draftPath := localPath("models", draftRepo, in.DraftFile.Name)
-
-		e.Overrides["draft_model"] = draftPath
-		e.Overrides["flash_attention"] = "on"
-		e.Files = append(e.Files, EntryFile{
-			Filename: draftPath,
-			SHA256:   in.DraftFile.SHA256,
-			URI:      hfURI(draftRepo, in.DraftFile.Name),
-		})
-	}
-
-	e.Overrides["options"] = options
-	return e
-}

.github/ci/apexentries/render_test.go

@@ -1,249 +0,0 @@
-package main
-
-import (
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("RenderChild", func() {
-	It("tags an entry that configures draft-dflash", func() {
-		e := RenderChild(ChildInput{
-			Name:      "qwen3.5-9b-dflash",
-			Repo:      "mudler/Example-APEX-GGUF",
-			Template:  "virtual.yaml",
-			Weights:   []GGUFFile{{Name: "Example-APEX-I-Quality.gguf", SHA256: "a"}},
-			SpecType:  "draft-dflash",
-			DraftFile: &GGUFFile{Name: "Example-DFlash.Q8_0.gguf", SHA256: "b"},
-			BaseTags:  []string{"llm", "gguf"},
-		})
-
-		Expect(e.Tags).To(ContainElement("dflash"))
-		Expect(e.Tags).ToNot(ContainElement("mtp"))
-		Expect(e.Overrides["options"]).To(ContainElement("spec_type:draft-dflash"))
-		Expect(e.Overrides["draft_model"]).ToNot(BeNil())
-	})
-
-	It("does not tag an MTP-named repo that configures no speculation", func() {
-		// mudler/Qwen3.6-35B-A3B-APEX-MTP-GGUF ships MTP-bearing weights. Weights
-		// that carry the heads are not an entry that enables them, and tagging it
-		// would win the feature axis without being any faster.
-		e := RenderChild(ChildInput{
-			Name:     "qwen3.6-35b-a3b-apex-mtp-i-quality",
-			Repo:     "mudler/Qwen3.6-35B-A3B-APEX-MTP-GGUF",
-			Template: "virtual.yaml",
-			Weights:  []GGUFFile{{Name: "Qwen3.6-35B-A3B-APEX-MTP-I-Quality.gguf", SHA256: "a"}},
-			BaseTags: []string{"llm", "gguf"},
-		})
-
-		Expect(e.Tags).ToNot(ContainElement("mtp"))
-		Expect(e.Tags).ToNot(ContainElement("dflash"))
-		Expect(e.Overrides).ToNot(HaveKey("draft_model"))
-	})
-
-	It("lists every shard of a sharded build and points the model at the first", func() {
-		e := RenderChild(ChildInput{
-			Name:     "step-3.7-flash-ud-q4-k-m",
-			Repo:     "unsloth/Step-3.7-Flash-GGUF",
-			Template: "virtual.yaml",
-			Weights: []GGUFFile{
-				{Name: "UD-Q4_K_M/Step-3.7-Flash-UD-Q4_K_M-00001-of-00002.gguf", SHA256: "a"},
-				{Name: "UD-Q4_K_M/Step-3.7-Flash-UD-Q4_K_M-00002-of-00002.gguf", SHA256: "b"},
-			},
-			BaseTags: []string{"llm", "gguf"},
-		})
-
-		Expect(e.Files).To(HaveLen(2))
-		params, ok := e.Overrides["parameters"].(map[string]any)
-		Expect(ok).To(BeTrue())
-		Expect(params["model"]).To(HaveSuffix("00001-of-00002.gguf"))
-		Expect(e.Files[0].URI).To(Equal(
-			"https://huggingface.co/unsloth/Step-3.7-Flash-GGUF/resolve/main/UD-Q4_K_M/Step-3.7-Flash-UD-Q4_K_M-00001-of-00002.gguf"))
-	})
-
-	It("wires mmproj when the repo publishes one", func() {
-		e := RenderChild(ChildInput{
-			Name:     "example-i-mini",
-			Repo:     "mudler/Example-APEX-GGUF",
-			Template: "virtual.yaml",
-			Weights:  []GGUFFile{{Name: "Example-APEX-I-Mini.gguf", SHA256: "a"}},
-			MMProj:   &GGUFFile{Name: "mmproj-F16.gguf", SHA256: "c"},
-			BaseTags: []string{"llm", "gguf"},
-		})
-
-		Expect(e.Overrides["mmproj"]).ToNot(BeNil())
-		Expect(e.Files).To(HaveLen(2))
-	})
-
-	It("names the engine and the usecases the hand-written entries name", func() {
-		// gallery/virtual.yaml supplies no backend, so an entry that omits one
-		// names no engine at all and cannot load.
-		e := RenderChild(ChildInput{
-			Name:     "example-i-mini",
-			Repo:     "mudler/Example-APEX-GGUF",
-			Template: "virtual.yaml",
-			Weights:  []GGUFFile{{Name: "Example-APEX-I-Mini.gguf", SHA256: "a"}},
-			BaseTags: []string{"llm", "gguf"},
-		})
-
-		Expect(e.Overrides["backend"]).To(Equal("llama-cpp"))
-		Expect(e.Overrides["known_usecases"]).To(ContainElement("chat"))
-	})
-
-	It("draws the drafter from DraftRepo when the pairing spans two repos", func() {
-		// unsloth/Qwen3-4B-GGUF pairs with a drafter published separately by
-		// AtomicChat, so a drafter URI built from the weights repo 404s.
-		e := RenderChild(ChildInput{
-			Name:      "qwen3-4b-dflash",
-			Repo:      "unsloth/Qwen3-4B-GGUF",
-			DraftRepo: "AtomicChat/Qwen3-4B-DFlash-GGUF",
-			Template:  "virtual.yaml",
-			Weights:   []GGUFFile{{Name: "Qwen3-4B-Q4_K_M.gguf", SHA256: "a"}},
-			SpecType:  "draft-dflash",
-			DraftFile: &GGUFFile{Name: "Qwen3-4B-DFlash.Q8_0.gguf", SHA256: "b"},
-			BaseTags:  []string{"llm", "gguf"},
-		})
-
-		Expect(e.Files[0].URI).To(Equal(
-			"https://huggingface.co/unsloth/Qwen3-4B-GGUF/resolve/main/Qwen3-4B-Q4_K_M.gguf"))
-		Expect(e.Files[1].URI).To(Equal(
-			"https://huggingface.co/AtomicChat/Qwen3-4B-DFlash-GGUF/resolve/main/Qwen3-4B-DFlash.Q8_0.gguf"))
-		Expect(e.Files[1].Filename).To(Equal(
-			"llama-cpp/models/AtomicChat/Qwen3-4B-DFlash-GGUF/Qwen3-4B-DFlash.Q8_0.gguf"))
-		Expect(e.Overrides["draft_model"]).To(Equal(
-			"llama-cpp/models/AtomicChat/Qwen3-4B-DFlash-GGUF/Qwen3-4B-DFlash.Q8_0.gguf"))
-	})
-
-	It("falls back to the weights repo for the drafter when DraftRepo is empty", func() {
-		// The *-APEX-MTP-GGUF repos ship the drafter alongside the weights.
-		e := RenderChild(ChildInput{
-			Name:      "example-apex-dflash",
-			Repo:      "mudler/Example-APEX-GGUF",
-			Template:  "virtual.yaml",
-			Weights:   []GGUFFile{{Name: "Example-APEX-I-Quality.gguf", SHA256: "a"}},
-			SpecType:  "draft-dflash",
-			DraftFile: &GGUFFile{Name: "Example-DFlash.Q8_0.gguf", SHA256: "b"},
-			BaseTags:  []string{"llm", "gguf"},
-		})
-
-		Expect(e.Files[1].URI).To(Equal(
-			"https://huggingface.co/mudler/Example-APEX-GGUF/resolve/main/Example-DFlash.Q8_0.gguf"))
-		Expect(e.Files[1].Filename).To(Equal(
-			"llama-cpp/models/mudler/Example-APEX-GGUF/Example-DFlash.Q8_0.gguf"))
-	})
-})
-
-var _ = Describe("RenderChild known_usecases", func() {
-	It("declares vision alongside chat when the entry carries an mmproj", func() {
-		// An explicit known_usecases suppresses the backend-default fallback, so a
-		// chat-only multimodal entry disappears from the UI's vision filter.
-		e := RenderChild(ChildInput{
-			Name:     "example-i-quality",
-			Repo:     "mudler/Example-APEX-GGUF",
-			Template: "virtual.yaml",
-			Weights:  []GGUFFile{{Name: "Example-APEX-I-Quality.gguf", SHA256: "a"}},
-			MMProj:   &GGUFFile{Name: "mmproj-F16.gguf", SHA256: "c"},
-			BaseTags: []string{"llm", "gguf"},
-		})
-
-		Expect(e.Overrides["known_usecases"]).To(ConsistOf("chat", "vision"))
-	})
-
-	It("leaves a text-only entry at chat", func() {
-		e := RenderChild(ChildInput{
-			Name:     "example-i-quality",
-			Repo:     "mudler/Example-APEX-GGUF",
-			Template: "virtual.yaml",
-			Weights:  []GGUFFile{{Name: "Example-APEX-I-Quality.gguf", SHA256: "a"}},
-			BaseTags: []string{"llm", "gguf"},
-		})
-
-		Expect(e.Overrides["known_usecases"]).To(ConsistOf("chat"))
-	})
-})
-
-var _ = Describe("localPath", func() {
-	It("keeps two repos with the same basename but different owners apart", func() {
-		// LiquidAI and unsloth both publish LFM2.5-8B-A1B-GGUF. A path built from
-		// the bare repo name gives both the same local file, so installing the
-		// second overwrites or skips the first and one of them then serves bytes
-		// that do not match its recorded sha256.
-		liquid := RenderChild(ChildInput{
-			Name:     "lfm2.5-8b-a1b-i-quality",
-			Repo:     "LiquidAI/LFM2.5-8B-A1B-GGUF",
-			Template: "virtual.yaml",
-			Weights:  []GGUFFile{{Name: "LFM2.5-8B-A1B-Q8_0.gguf", SHA256: "33ab3b8c"}},
-			BaseTags: []string{"llm", "gguf"},
-		})
-		unsloth := RenderChild(ChildInput{
-			Name:     "lfm2.5-8b-a1b-q8-0",
-			Repo:     "unsloth/LFM2.5-8B-A1B-GGUF",
-			Template: "virtual.yaml",
-			Weights:  []GGUFFile{{Name: "LFM2.5-8B-A1B-Q8_0.gguf", SHA256: "ec11666b"}},
-			BaseTags: []string{"llm", "gguf"},
-		})
-
-		Expect(liquid.Files[0].Filename).ToNot(Equal(unsloth.Files[0].Filename))
-		Expect(unsloth.Files[0].Filename).To(Equal(
-			"llama-cpp/models/unsloth/LFM2.5-8B-A1B-GGUF/LFM2.5-8B-A1B-Q8_0.gguf"))
-	})
-
-	It("namespaces the mmproj by owner too", func() {
-		e := RenderChild(ChildInput{
-			Name:     "example-i-quality",
-			Repo:     "mudler/Example-APEX-GGUF",
-			Template: "virtual.yaml",
-			Weights:  []GGUFFile{{Name: "Example-APEX-I-Quality.gguf", SHA256: "a"}},
-			MMProj:   &GGUFFile{Name: "mmproj-F16.gguf", SHA256: "c"},
-			BaseTags: []string{"llm", "gguf"},
-		})
-
-		Expect(e.Overrides["mmproj"]).To(Equal(
-			"llama-cpp/mmproj/mudler/Example-APEX-GGUF/mmproj-F16.gguf"))
-	})
-})
-
-var _ = Describe("MTP builds", func() {
-	renderTier := func(repo string) GalleryEntry {
-		return RenderChild(ChildInput{
-			Name:     "example-i-quality",
-			Repo:     repo,
-			Template: "virtual.yaml",
-			SpecType: SpecTypeForRepo(repo),
-			Weights:  []GGUFFile{{Name: "Example-I-Quality.gguf", SHA256: "a"}},
-			BaseTags: []string{"llm", "gguf"},
-		})
-	}
-
-	It("turns MTP on for a build off an APEX-MTP repo", func() {
-		// These weights retain the model's own MTP heads, so shipping them with
-		// speculation off is a strictly larger download at the same speed,
-		// ranked identically to the plain rung at the same tier.
-		e := renderTier("mudler/Qwen3.6-35B-A3B-APEX-MTP-GGUF")
-
-		Expect(e.Overrides["options"]).To(ContainElements(
-			"spec_type:draft-mtp", "spec_n_max:6", "spec_p_min:0.75"))
-		Expect(e.Tags).To(ContainElement("mtp"))
-	})
-
-	It("needs no drafter file, because the heads travel with the weights", func() {
-		e := renderTier("mudler/Qwen3.6-35B-A3B-APEX-MTP-GGUF")
-
-		Expect(e.Overrides).ToNot(HaveKey("draft_model"))
-		Expect(e.Files).To(HaveLen(1))
-	})
-
-	It("leaves a build off a plain APEX repo alone", func() {
-		e := renderTier("mudler/Qwen3.6-35B-A3B-APEX-GGUF")
-
-		Expect(e.Tags).ToNot(ContainElement("mtp"))
-		Expect(e.Overrides["options"]).To(ConsistOf("use_jinja:true"))
-	})
-
-	It("leaves an unsloth counterpart rung alone", func() {
-		// The counterpart quantizes the plain weights; nothing there carries heads.
-		e := renderTier("unsloth/Qwen3.6-35B-A3B-GGUF")
-
-		Expect(e.Tags).ToNot(ContainElement("mtp"))
-		Expect(e.Overrides["options"]).To(ConsistOf("use_jinja:true"))
-	})
-})

.github/ci/apexentries/unsloth.go

@@ -1,71 +0,0 @@
-package main
-
-import (
-	"regexp"
-	"sort"
-	"strings"
-)
-
-// WantedQuants is the fixed unsloth subset this generator emits. It is a
-// deliberate subset: unsloth publishes north of 20 quants per repo, and the
-// selector needs useful fitness points rather than every rung.
-var WantedQuants = []string{"UD-Q4_K_M", "UD-Q5_K_M", "UD-Q6_K", "Q8_0"}
-
-var shardRE = regexp.MustCompile(`-(\d{5})-of-(\d{5})\.gguf$`)
-
-// QuantBuild is one unsloth quantization, which may be a single file or an
-// ordered set of shards.
-type QuantBuild struct {
-	Quant   string
-	Files   []GGUFFile
-	Sharded bool
-}
-
-// CounterpartCandidates returns the unsloth repo base names worth probing, most
-// likely first. Both derivations are needed: the repo name finds
-// unsloth/gemma-4-26B-A4B-it-GGUF, while the file stem is what matches for
-// repos whose stem is the canonical model name.
-func CounterpartCandidates(repoName, fileStem string) []string {
-	clean := func(s string) string {
-		s = strings.TrimSuffix(s, "-GGUF")
-		s = regexp.MustCompile(`-(MTP|TQ)$`).ReplaceAllString(s, "")
-		s = strings.TrimSuffix(s, "-APEX")
-		return regexp.MustCompile(`-(MTP|TQ)$`).ReplaceAllString(s, "")
-	}
-
-	out := []string{clean(repoName)}
-	if stem := clean(fileStem); stem != out[0] {
-		out = append(out, stem)
-	}
-	return out
-}
-
-// DiscoverUnslothQuants returns the wanted quants a repo publishes, handling
-// both the flat single-file layout and the sharded layout where a quant lives
-// in its own subdirectory.
-func DiscoverUnslothQuants(files []GGUFFile) []QuantBuild {
-	var out []QuantBuild
-
-	for _, q := range WantedQuants {
-		var flat []GGUFFile
-		var shards []GGUFFile
-
-		for _, f := range files {
-			switch {
-			case !strings.Contains(f.Name, "/") && strings.HasSuffix(f.Name, "-"+q+".gguf"):
-				flat = append(flat, f)
-			case strings.HasPrefix(f.Name, q+"/") && shardRE.MatchString(f.Name):
-				shards = append(shards, f)
-			}
-		}
-
-		switch {
-		case len(flat) > 0:
-			out = append(out, QuantBuild{Quant: q, Files: flat})
-		case len(shards) > 0:
-			sort.Slice(shards, func(i, j int) bool { return shards[i].Name < shards[j].Name })
-			out = append(out, QuantBuild{Quant: q, Files: shards, Sharded: true})
-		}
-	}
-	return out
-}

.github/ci/apexentries/unsloth_test.go

@@ -1,75 +0,0 @@
-package main
-
-import (
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("CounterpartCandidates", func() {
-	It("offers both the repo-derived and stem-derived names", func() {
-		// mudler/gemma-4-26B-A4B-it-APEX-GGUF ships gemma-4-26B-A4B-APEX-*.gguf,
-		// and only the repo-derived name finds unsloth/gemma-4-26B-A4B-it-GGUF.
-		got := CounterpartCandidates("gemma-4-26B-A4B-it-APEX-GGUF", "gemma-4-26B-A4B-APEX")
-
-		Expect(got).To(Equal([]string{"gemma-4-26B-A4B-it", "gemma-4-26B-A4B"}))
-	})
-
-	It("strips the MTP marker", func() {
-		got := CounterpartCandidates("Qwopus3.6-35B-A3B-v1-APEX-MTP-GGUF", "Qwopus3.6-35B-A3B-v1-APEX-MTP")
-
-		Expect(got[0]).To(Equal("Qwopus3.6-35B-A3B-v1"))
-	})
-
-	It("strips the TQ marker", func() {
-		// This is the branch that folds mudler/Qwen3.5-35B-A3B-APEX-TQ-GGUF into
-		// the qwen3.5-35b-a3b hub. Without it the probe is
-		// unsloth/Qwen3.5-35B-A3B-TQ-GGUF, which does not exist, so the family
-		// silently loses every unsloth rung.
-		got := CounterpartCandidates("Qwen3.5-35B-A3B-APEX-TQ-GGUF", "Qwen3.5-35B-A3B-APEX-TQ")
-
-		Expect(got).To(Equal([]string{"Qwen3.5-35B-A3B"}))
-	})
-
-	It("does not repeat a candidate when both derivations agree", func() {
-		got := CounterpartCandidates("Qwen3.6-35B-A3B-APEX-GGUF", "Qwen3.6-35B-A3B-APEX")
-
-		Expect(got).To(Equal([]string{"Qwen3.6-35B-A3B"}))
-	})
-})
-
-var _ = Describe("DiscoverUnslothQuants", func() {
-	It("finds flat single-file quants", func() {
-		files := []GGUFFile{
-			{Name: "Qwen3.6-35B-A3B-UD-Q4_K_M.gguf", SHA256: "a"},
-			{Name: "Qwen3.6-35B-A3B-UD-IQ1_M.gguf", SHA256: "b"},
-		}
-
-		got := DiscoverUnslothQuants(files)
-
-		Expect(got).To(HaveLen(1))
-		Expect(got[0].Quant).To(Equal("UD-Q4_K_M"))
-		Expect(got[0].Sharded).To(BeFalse())
-		Expect(got[0].Files).To(HaveLen(1))
-	})
-
-	It("collects a sharded quant from its subdirectory in shard order", func() {
-		files := []GGUFFile{
-			{Name: "UD-Q4_K_M/Step-3.7-Flash-UD-Q4_K_M-00002-of-00002.gguf", SHA256: "b"},
-			{Name: "UD-Q4_K_M/Step-3.7-Flash-UD-Q4_K_M-00001-of-00002.gguf", SHA256: "a"},
-		}
-
-		got := DiscoverUnslothQuants(files)
-
-		Expect(got).To(HaveLen(1))
-		Expect(got[0].Quant).To(Equal("UD-Q4_K_M"))
-		Expect(got[0].Sharded).To(BeTrue())
-		Expect(got[0].Files).To(HaveLen(2))
-		Expect(got[0].Files[0].Name).To(HaveSuffix("00001-of-00002.gguf"))
-	})
-
-	It("ignores quants outside the wanted subset", func() {
-		files := []GGUFFile{{Name: "Model-UD-IQ2_XXS.gguf", SHA256: "a"}}
-
-		Expect(DiscoverUnslothQuants(files)).To(BeEmpty())
-	})
-})

.github/ci/apexentries/verify.go

@@ -1,312 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"os"
-	"strings"
-
-	"gopkg.in/yaml.v3"
-)
-
-type verifyEntry struct {
-	Name      string       `yaml:"name"`
-	Tags      []string     `yaml:"tags"`
-	Variants  []VariantRef `yaml:"variants"`
-	Overrides struct {
-		// Backend scopes the checks that only hold for one engine. An entry that
-		// declares none takes its configuration from the referenced url: template,
-		// which this verifier never reads, so it cannot be judged either way.
-		Backend string   `yaml:"backend"`
-		Options []string `yaml:"options"`
-		// MMProj and DraftModel name the files that are not weights. They are
-		// the only signal for it: a drafter lands in the same models/ prefix as
-		// the weights, so the path alone cannot tell them apart.
-		MMProj     string `yaml:"mmproj"`
-		DraftModel string `yaml:"draft_model"`
-	} `yaml:"overrides"`
-	Files []struct {
-		Filename string `yaml:"filename"`
-		SHA256   string `yaml:"sha256"`
-		URI      string `yaml:"uri"`
-	} `yaml:"files"`
-}
-
-// Verify checks the invariants the variants schema and the tagging rule
-// require. It returns every problem rather than the first, so one run tells the
-// author everything that needs fixing.
-func Verify(path string) []string {
-	raw, err := os.ReadFile(path)
-	if err != nil {
-		return []string{fmt.Sprintf("reading %s: %v", path, err)}
-	}
-
-	var entries []verifyEntry
-	if err := yaml.Unmarshal(raw, &entries); err != nil {
-		return []string{fmt.Sprintf("parsing %s: %v", path, err)}
-	}
-
-	var problems []string
-
-	byName := map[string]verifyEntry{}
-	for _, e := range entries {
-		if _, seen := byName[e.Name]; seen {
-			problems = append(problems, fmt.Sprintf("duplicate entry name: %s", e.Name))
-			continue
-		}
-		byName[e.Name] = e
-	}
-
-	for _, e := range entries {
-		for _, v := range e.Variants {
-			target, ok := byName[v.Model]
-			if !ok {
-				problems = append(problems, fmt.Sprintf("%s: variant %q does not exist", e.Name, v.Model))
-				continue
-			}
-			if len(target.Variants) > 0 {
-				problems = append(problems, fmt.Sprintf("%s: variant %q declares variants of its own", e.Name, v.Model))
-			}
-		}
-
-		for _, f := range e.Files {
-			if requiresSHA256(f.Filename) && f.SHA256 == "" {
-				problems = append(problems, fmt.Sprintf("%s: file %s has no sha256", e.Name, f.Filename))
-			}
-		}
-
-		problems = append(problems, checkWeightCount(e)...)
-		problems = append(problems, checkFeatureTag(e, "dflash")...)
-		problems = append(problems, checkFeatureTag(e, "mtp")...)
-	}
-
-	problems = append(problems, checkPathCollisions(entries)...)
-
-	return problems
-}
-
-// checkPathCollisions catches two different upstream files claiming one local
-// path. The install layer keys on the local filename, so whichever entry is
-// installed second either overwrites weights the first entry recorded a
-// different sha256 for or is skipped as already present. Either way some entry
-// afterwards serves bytes that do not match its own checksum, and nothing at
-// install time says so.
-//
-// This is an index-wide invariant rather than a per-entry one: neither entry is
-// wrong on its own and the collision exists only in their pairing. The usual
-// source is a path scheme built from the repo's BARE name, because two owners
-// publishing the same model name is routine for quantizers.
-//
-// Sharing a path is fine when the uri is the same, which is how several entries
-// legitimately reuse one projector. Files with no uri are skipped: there is
-// nothing to compare.
-func checkPathCollisions(entries []verifyEntry) []string {
-	type source struct{ uri, entry string }
-
-	first := map[string]source{}
-	reported := map[string]bool{}
-
-	var problems []string
-	for _, e := range entries {
-		for _, f := range e.Files {
-			if f.Filename == "" || f.URI == "" {
-				continue
-			}
-			prev, seen := first[f.Filename]
-			if !seen {
-				first[f.Filename] = source{uri: f.URI, entry: e.Name}
-				continue
-			}
-			if prev.uri == f.URI || reported[f.Filename] {
-				continue
-			}
-			// Reported once per path however many entries pile onto it, so one
-			// heavily reused filename cannot bury the rest of the report.
-			reported[f.Filename] = true
-			problems = append(problems, fmt.Sprintf(
-				"local path %s is claimed by two different uris: %s (%s) and %s (%s)",
-				f.Filename, prev.uri, prev.entry, f.URI, e.Name))
-		}
-	}
-	return problems
-}
-
-// auxiliaryExtensions are the metadata formats an entry ships beside its
-// weights, where an unverified download is a nuisance rather than a hole.
-//
-// The exclusion is stated as a list of metadata formats on purpose. Requiring
-// the checksum only on a blessed list of weight formats would silently exempt
-// every format nobody has shipped yet, and it already exempted safetensors
-// weights, which are downloaded and loaded exactly like GGUF ones.
-var auxiliaryExtensions = []string{".json", ".txt", ".md"}
-
-// requiresSHA256 reports whether an unverified download of this file would be
-// a supply-chain hole rather than a cosmetic gap.
-func requiresSHA256(filename string) bool {
-	for _, ext := range auxiliaryExtensions {
-		if strings.HasSuffix(filename, ext) {
-			return false
-		}
-	}
-	return true
-}
-
-// checkWeightCount catches an entry carrying two whole models. The flat-match
-// branch in DiscoverUnslothQuants appends every match, so a quant label that is
-// a suffix of another one (Q8_0 of UD-Q8_0) collects both files into one build
-// while the rendered model: points at only the first. The result downloads
-// twice the bytes and serves whichever file sorted first, silently.
-//
-// Shards are exempt because a sharded build is legitimately many files.
-//
-// The collision is a property of llama-cpp quant discovery, so the check is
-// scoped to that backend. Multi-component TTS, ASR and diffusion engines ship an
-// encoder, a decoder and a vocoder as one model, and there the second GGUF is
-// the design rather than a bug.
-func checkWeightCount(e verifyEntry) []string {
-	if e.Overrides.Backend != "llama-cpp" {
-		return nil
-	}
-
-	var weights []string
-	for _, f := range e.Files {
-		switch {
-		case !strings.HasSuffix(f.Filename, ".gguf"):
-		case shardRE.MatchString(f.Filename):
-		case f.Filename == e.Overrides.MMProj:
-		case f.Filename == e.Overrides.DraftModel:
-		default:
-			weights = append(weights, f.Filename)
-		}
-	}
-
-	if len(weights) > 1 {
-		return []string{fmt.Sprintf("%s: more than one weight file: %s", e.Name, strings.Join(weights, ", "))}
-	}
-	return nil
-}
-
-// checkFeatureTag enforces the rule in both directions. A tag without the
-// configuration promotes a build that is no faster; configuration without the
-// tag leaves a genuinely faster build ranked as plain.
-//
-// It only speaks about backends whose declaration it can actually read, because
-// a rule applied where the evidence is invisible reports noise rather than bugs.
-func checkFeatureTag(e verifyEntry, feature string) []string {
-	decl, configured, judgeable := featureDeclaration(e, feature)
-	if !judgeable {
-		return nil
-	}
-
-	tagged := false
-	for _, t := range e.Tags {
-		if t == feature {
-			tagged = true
-			break
-		}
-	}
-
-	switch {
-	case tagged && !configured:
-		return []string{fmt.Sprintf("%s: tagged %s but sets no %s", e.Name, feature, decl)}
-	case configured && !tagged:
-		return []string{fmt.Sprintf("%s: sets %s but is not tagged %s", e.Name, decl, feature)}
-	}
-	return nil
-}
-
-// featureDeclaration implements the per-backend table in
-// .agents/adding-gallery-models.md. It returns the declaration the backend uses
-// to configure the feature, whether the entry carries it, and whether this
-// verifier is in a position to answer at all.
-func featureDeclaration(e verifyEntry, feature string) (decl string, configured, judgeable bool) {
-	switch e.Overrides.Backend {
-	case "llama-cpp":
-		decl = "spec_type:draft-" + feature
-		for _, o := range e.Overrides.Options {
-			if strings.TrimSpace(o) == decl {
-				return decl, true, true
-			}
-		}
-		return decl, false, true
-
-	case "ds4":
-		// ds4 carries the MTP heads in the weights and turns them on with
-		// mtp_path / mtp_draft. It has no dflash counterpart, so dflash is not a
-		// question that can be asked of a ds4 entry.
-		if feature != "mtp" {
-			return "", false, false
-		}
-		decl = "mtp_path:"
-		for _, o := range e.Overrides.Options {
-			o = strings.TrimSpace(o)
-			if strings.HasPrefix(o, "mtp_path:") || strings.HasPrefix(o, "mtp_draft:") {
-				return decl, true, true
-			}
-		}
-		return decl, false, true
-
-	default:
-		// sglang configures the feature with speculative_algorithm: in the
-		// referenced gallery/*.yaml, and an entry that declares no backend takes
-		// its whole configuration from its url: template. Verify reads one index
-		// file and follows neither, so it must not judge these in either
-		// direction.
-		return "", false, false
-	}
-}
-
-// UnaccountedQuants reports a wanted quant the repo demonstrably publishes but
-// that discovery produced no build for. The layout that triggers it today is
-// root-level shards, which match neither branch of DiscoverUnslothQuants; no
-// counterpart ships that way yet, but a batch generator must not drop a build
-// with nothing said about it.
-func UnaccountedQuants(files []GGUFFile, builds []QuantBuild) []string {
-	built := map[string]bool{}
-	for _, b := range builds {
-		built[b.Quant] = true
-	}
-
-	var problems []string
-	for _, q := range WantedQuants {
-		if built[q] {
-			continue
-		}
-		for _, f := range files {
-			if filePublishesQuant(f.Name, q) {
-				problems = append(problems, fmt.Sprintf("quant %s is published upstream (%s) but produced no build", q, f.Name))
-				break
-			}
-		}
-	}
-	return problems
-}
-
-// filePublishesQuant reports whether an upstream file is a publication of
-// quant q. It anchors on the quant label the way DiscoverUnslothQuants does,
-// as the trailing token of the base name or as the sharding subdirectory, so
-// the diagnostic and the discovery it audits cannot disagree about what a file
-// is.
-//
-// An unanchored match would reproduce the very collision this diagnostic warns
-// about: Q8_0 is a substring of UD-Q8_0, so a repo publishing only UD-Q8_0
-// would be reported as publishing an unbuilt Q8_0, which it does not, and
-// UD-Q8_0 is not a wanted quant at all.
-func filePublishesQuant(name, q string) bool {
-	if strings.HasPrefix(name, q+"/") {
-		return true
-	}
-
-	base := name[strings.LastIndex(name, "/")+1:]
-	// Shard numbering sits between the quant label and the extension, so it has
-	// to come off before the label can be read as the trailing token. Root-level
-	// shards are the layout that matches neither branch of
-	// DiscoverUnslothQuants, and so the layout this diagnostic mainly catches.
-	base = shardRE.ReplaceAllString(base, ".gguf")
-
-	if !strings.HasSuffix(base, "-"+q+".gguf") {
-		return false
-	}
-	// UD- is unsloth's dynamic-quant modifier, and UD-<q> is a distinct quant
-	// label rather than a publication of <q>.
-	return !strings.HasSuffix(base, "-UD-"+q+".gguf")
-}

.github/ci/apexentries/verify_test.go

@@ -1,480 +0,0 @@
-package main
-
-import (
-	"os"
-	"path/filepath"
-	"strings"
-
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("Verify", func() {
-	write := func(body string) string {
-		dir := GinkgoT().TempDir()
-		p := filepath.Join(dir, "index.yaml")
-		Expect(os.WriteFile(p, []byte(body), 0o600)).To(Succeed())
-		return p
-	}
-
-	It("passes a sound index", func() {
-		Expect(Verify(write(`
-- name: parent
-  variants:
-    - model: child
-  files:
-    - filename: a.gguf
-      sha256: aa
-      uri: https://example.com/a.gguf
-- name: child
-  files:
-    - filename: b.gguf
-      sha256: bb
-      uri: https://example.com/b.gguf
-`))).To(BeEmpty())
-	})
-
-	It("reports a variant pointing at a missing entry", func() {
-		Expect(Verify(write(`
-- name: parent
-  variants:
-    - model: ghost
-  files:
-    - filename: a.gguf
-      sha256: aa
-      uri: https://example.com/a.gguf
-`))).To(ContainElement(ContainSubstring("ghost")))
-	})
-
-	It("reports a variant that itself declares variants", func() {
-		Expect(Verify(write(`
-- name: parent
-  variants:
-    - model: child
-  files:
-    - filename: a.gguf
-      sha256: aa
-      uri: https://example.com/a.gguf
-- name: child
-  variants:
-    - model: grandchild
-  files:
-    - filename: b.gguf
-      sha256: bb
-      uri: https://example.com/b.gguf
-- name: grandchild
-  files:
-    - filename: c.gguf
-      sha256: cc
-      uri: https://example.com/c.gguf
-`))).To(ContainElement(ContainSubstring("declares variants of its own")))
-	})
-
-	It("reports duplicate entry names", func() {
-		Expect(Verify(write(`
-- name: dup
-  files:
-    - filename: a.gguf
-      sha256: aa
-      uri: https://example.com/a.gguf
-- name: dup
-  files:
-    - filename: b.gguf
-      sha256: bb
-      uri: https://example.com/b.gguf
-`))).To(ContainElement(ContainSubstring("duplicate entry name")))
-	})
-
-	It("reports a file with no sha256", func() {
-		Expect(Verify(write(`
-- name: one
-  files:
-    - filename: a.gguf
-      uri: https://example.com/a.gguf
-`))).To(ContainElement(ContainSubstring("no sha256")))
-	})
-
-	It("reports an entry tagged dflash without a matching spec_type", func() {
-		Expect(Verify(write(`
-- name: liar
-  tags:
-    - dflash
-  overrides:
-    backend: llama-cpp
-    options:
-      - use_jinja:true
-  files:
-    - filename: a.gguf
-      sha256: aa
-      uri: https://example.com/a.gguf
-`))).To(ContainElement(ContainSubstring("tagged dflash")))
-	})
-
-	It("reports an entry configuring spec_type without the tag", func() {
-		Expect(Verify(write(`
-- name: shy
-  overrides:
-    backend: llama-cpp
-    options:
-      - spec_type:draft-mtp
-  files:
-    - filename: a.gguf
-      sha256: aa
-      uri: https://example.com/a.gguf
-`))).To(ContainElement(ContainSubstring("not tagged mtp")))
-	})
-
-	// ds4 carries the MTP heads in the weights and names them with mtp_path, so
-	// the rule holds there in a different vocabulary rather than not at all.
-	It("reports a ds4 entry configuring mtp_path without the tag", func() {
-		Expect(Verify(write(`
-- name: ds4-shy
-  overrides:
-    backend: ds4
-    options:
-      - mtp_path:model-mtp.gguf
-      - mtp_draft:2
-  files:
-    - filename: a.gguf
-      sha256: aa
-      uri: https://example.com/a.gguf
-`))).To(ContainElement(ContainSubstring("not tagged mtp")))
-	})
-
-	It("reports a ds4 entry tagged mtp that configures no mtp_path", func() {
-		Expect(Verify(write(`
-- name: ds4-liar
-  tags:
-    - mtp
-  overrides:
-    backend: ds4
-    options:
-      - context_size:4096
-  files:
-    - filename: a.gguf
-      sha256: aa
-      uri: https://example.com/a.gguf
-`))).To(ContainElement(ContainSubstring("tagged mtp")))
-	})
-
-	It("accepts a ds4 entry that both configures mtp_path and carries the tag", func() {
-		Expect(Verify(write(`
-- name: ds4-honest
-  tags:
-    - mtp
-  overrides:
-    backend: ds4
-    options:
-      - mtp_path:model-mtp.gguf
-  files:
-    - filename: a.gguf
-      sha256: aa
-      uri: https://example.com/a.gguf
-`))).To(BeEmpty())
-	})
-
-	// sglang declares speculative_algorithm in the referenced gallery/*.yaml,
-	// which Verify never reads, so it may not judge such an entry either way.
-	It("says nothing about an sglang entry tagged mtp", func() {
-		Expect(Verify(write(`
-- name: sglang-mtp
-  tags:
-    - mtp
-  overrides:
-    backend: sglang
-  files: []
-`))).To(BeEmpty())
-	})
-
-	It("says nothing about the tag on an entry with no declared backend", func() {
-		Expect(Verify(write(`
-- name: templated
-  tags:
-    - mtp
-  files:
-    - filename: a.gguf
-      sha256: aa
-      uri: https://example.com/a.gguf
-`))).To(BeEmpty())
-	})
-
-	// The flat-match branch in unsloth.go appends every match, so a repo
-	// publishing both a plain and a UD Q8_0 renders one entry holding two full
-	// models while model: points at only the first.
-	It("reports an entry holding more than one non-shard weight file", func() {
-		Expect(Verify(write(`
-- name: greedy
-  overrides:
-    backend: llama-cpp
-    options:
-      - use_jinja:true
-    parameters:
-      model: llama-cpp/models/repo/Model-Q8_0.gguf
-  files:
-    - filename: llama-cpp/models/repo/Model-Q8_0.gguf
-      sha256: aa
-      uri: https://example.com/a.gguf
-    - filename: llama-cpp/models/repo/Model-UD-Q8_0.gguf
-      sha256: bb
-      uri: https://example.com/b.gguf
-`))).To(ContainElement(ContainSubstring("more than one weight file")))
-	})
-
-	It("accepts many shards alongside an mmproj and a drafter", func() {
-		Expect(Verify(write(`
-- name: sharded
-  tags:
-    - mtp
-  overrides:
-    backend: llama-cpp
-    options:
-      - spec_type:draft-mtp
-    mmproj: llama-cpp/mmproj/repo/mm.gguf
-    draft_model: llama-cpp/models/repo/Model-draft.gguf
-  files:
-    - filename: llama-cpp/models/repo/Model-00001-of-00002.gguf
-      sha256: aa
-      uri: https://example.com/a.gguf
-    - filename: llama-cpp/models/repo/Model-00002-of-00002.gguf
-      sha256: bb
-      uri: https://example.com/b.gguf
-    - filename: llama-cpp/mmproj/repo/mm.gguf
-      sha256: cc
-      uri: https://example.com/c.gguf
-    - filename: llama-cpp/models/repo/Model-draft.gguf
-      sha256: dd
-      uri: https://example.com/d.gguf
-`))).To(BeEmpty())
-	})
-
-	// Multi-component TTS and ASR engines legitimately ship an encoder, a
-	// tokenizer, a vocoder and so on as one model, so the collision the weight
-	// count catches does not exist for them.
-	It("accepts a multi-component non-llama-cpp entry declaring five weights", func() {
-		Expect(Verify(write(`
-- name: multi
-  overrides:
-    backend: qwen3-tts-cpp
-  files:
-    - filename: talker.gguf
-      sha256: aa
-      uri: https://example.com/a.gguf
-    - filename: tokenizer.gguf
-      sha256: bb
-      uri: https://example.com/b.gguf
-    - filename: vocoder.gguf
-      sha256: cc
-      uri: https://example.com/c.gguf
-    - filename: encoder.gguf
-      sha256: dd
-      uri: https://example.com/d.gguf
-    - filename: vae.gguf
-      sha256: ee
-      uri: https://example.com/e.gguf
-`))).To(BeEmpty())
-	})
-
-	It("says nothing about the weight count of an entry with no declared backend", func() {
-		Expect(Verify(write(`
-- name: templated-weights
-  files:
-    - filename: model-Q4_K_M.gguf
-      sha256: aa
-      uri: https://example.com/a.gguf
-    - filename: model-mmproj-f16.gguf
-      sha256: bb
-      uri: https://example.com/b.gguf
-`))).To(BeEmpty())
-	})
-
-	It("says nothing about an auxiliary metadata file carrying no sha256", func() {
-		Expect(Verify(write(`
-- name: aux
-  files:
-    - filename: a.gguf
-      sha256: aa
-      uri: https://example.com/a.gguf
-    - filename: params.json
-      sha256: ""
-      uri: https://example.com/params.json
-`))).To(BeEmpty())
-	})
-
-	// safetensors weights are downloaded and loaded exactly like GGUF weights,
-	// so an unverified one is the same supply-chain hole.
-	It("reports a safetensors weight carrying no sha256", func() {
-		Expect(Verify(write(`
-- name: vae
-  files:
-    - filename: wan_2.1_vae.safetensors
-      sha256: ""
-      uri: https://example.com/vae.safetensors
-`))).To(ContainElement(ContainSubstring("no sha256")))
-	})
-
-	It("says nothing about a txt or md file carrying no sha256", func() {
-		Expect(Verify(write(`
-- name: docs
-  files:
-    - filename: notes.txt
-      sha256: ""
-      uri: https://example.com/notes.txt
-    - filename: README.md
-      sha256: ""
-      uri: https://example.com/README.md
-`))).To(BeEmpty())
-	})
-})
-
-var _ = Describe("UnaccountedQuants", func() {
-	// A quant published only as root-level shards matches neither branch in
-	// DiscoverUnslothQuants, so without this diagnostic the build would vanish
-	// from a batch run with nothing said about it.
-	It("reports a wanted quant upstream publishes but discovery dropped", func() {
-		files := []GGUFFile{
-			{Name: "Model-UD-Q4_K_M-00001-of-00003.gguf", SHA256: "aa"},
-			{Name: "Model-UD-Q4_K_M-00002-of-00003.gguf", SHA256: "bb"},
-			{Name: "Model-UD-Q4_K_M-00003-of-00003.gguf", SHA256: "cc"},
-		}
-
-		Expect(UnaccountedQuants(files, DiscoverUnslothQuants(files))).
-			To(ContainElement(ContainSubstring("UD-Q4_K_M")))
-	})
-
-	It("says nothing when every published wanted quant produced a build", func() {
-		files := []GGUFFile{
-			{Name: "Model-UD-Q4_K_M.gguf", SHA256: "aa"},
-			{Name: "UD-Q6_K/Model-UD-Q6_K-00001-of-00002.gguf", SHA256: "bb"},
-			{Name: "UD-Q6_K/Model-UD-Q6_K-00002-of-00002.gguf", SHA256: "cc"},
-		}
-
-		Expect(UnaccountedQuants(files, DiscoverUnslothQuants(files))).To(BeEmpty())
-	})
-
-	It("says nothing about a wanted quant the repo does not publish at all", func() {
-		files := []GGUFFile{{Name: "Model-UD-Q4_K_M.gguf", SHA256: "aa"}}
-
-		Expect(UnaccountedQuants(files, DiscoverUnslothQuants(files))).To(BeEmpty())
-	})
-
-	// UD-Q8_0 is its own quant label and is not a wanted one. Reading it as a
-	// publication of Q8_0 is the substring collision this diagnostic exists to
-	// warn about, and subdirectory-sharded UD quants are the normal unsloth
-	// layout for large repos, so the false positive would fire on every batch.
-	It("does not read a subdirectory-sharded UD-Q8_0 as a published Q8_0", func() {
-		files := []GGUFFile{
-			{Name: "UD-Q8_0/Model-UD-Q8_0-00001-of-00002.gguf", SHA256: "aa"},
-			{Name: "UD-Q8_0/Model-UD-Q8_0-00002-of-00002.gguf", SHA256: "bb"},
-		}
-
-		Expect(UnaccountedQuants(files, DiscoverUnslothQuants(files))).To(BeEmpty())
-	})
-
-	// A quant in its own subdirectory but not shard-numbered matches neither
-	// branch of DiscoverUnslothQuants, so it is genuinely published and
-	// genuinely undiscovered.
-	It("reports a wanted quant published in its own subdirectory without shard numbering", func() {
-		files := []GGUFFile{{Name: "Q8_0/Model-Q8_0.gguf", SHA256: "aa"}}
-
-		Expect(UnaccountedQuants(files, DiscoverUnslothQuants(files))).
-			To(ContainElement(ContainSubstring("quant Q8_0 is published upstream")))
-	})
-
-	// builds is empty on purpose: it isolates the file-to-quant match from
-	// whatever DiscoverUnslothQuants would have made of the same file.
-	It("matches the flat single-file layout", func() {
-		files := []GGUFFile{{Name: "Model-Q8_0.gguf", SHA256: "aa"}}
-
-		Expect(UnaccountedQuants(files, nil)).
-			To(ConsistOf(ContainSubstring("quant Q8_0 is published upstream")))
-	})
-})
-
-var _ = Describe("Verify local path collisions", func() {
-	write := func(body string) string {
-		dir := GinkgoT().TempDir()
-		p := filepath.Join(dir, "index.yaml")
-		Expect(os.WriteFile(p, []byte(body), 0o600)).To(Succeed())
-		return p
-	}
-
-	It("reports one local path claimed by two different uris", func() {
-		// The shape that shipped: LiquidAI and unsloth both publish
-		// LFM2.5-8B-A1B-GGUF, so a path built from the bare repo name gives both
-		// entries the same local file under two different checksums.
-		Expect(Verify(write(`
-- name: lfm2.5-8b-a1b
-  files:
-    - filename: llama-cpp/models/LFM2.5-8B-A1B-GGUF/LFM2.5-8B-A1B-Q8_0.gguf
-      sha256: 33ab3b8c
-      uri: https://huggingface.co/LiquidAI/LFM2.5-8B-A1B-GGUF/resolve/main/LFM2.5-8B-A1B-Q8_0.gguf
-- name: lfm2.5-8b-a1b-q8-0
-  files:
-    - filename: llama-cpp/models/LFM2.5-8B-A1B-GGUF/LFM2.5-8B-A1B-Q8_0.gguf
-      sha256: ec11666b
-      uri: https://huggingface.co/unsloth/LFM2.5-8B-A1B-GGUF/resolve/main/LFM2.5-8B-A1B-Q8_0.gguf
-`))).To(ContainElement(SatisfyAll(
-			ContainSubstring("claimed by two different uris"),
-			ContainSubstring("lfm2.5-8b-a1b-q8-0"),
-		)))
-	})
-
-	It("accepts two entries reusing one file from the same uri", func() {
-		// Sibling builds of one repo legitimately share a projector.
-		Expect(Verify(write(`
-- name: a
-  files:
-    - filename: llama-cpp/mmproj/mudler/Example-GGUF/mmproj-F16.gguf
-      sha256: cc
-      uri: https://huggingface.co/mudler/Example-GGUF/resolve/main/mmproj-F16.gguf
-- name: b
-  files:
-    - filename: llama-cpp/mmproj/mudler/Example-GGUF/mmproj-F16.gguf
-      sha256: cc
-      uri: https://huggingface.co/mudler/Example-GGUF/resolve/main/mmproj-F16.gguf
-`))).To(BeEmpty())
-	})
-
-	It("reports a collision once however many entries pile onto the path", func() {
-		problems := Verify(write(`
-- name: a
-  files:
-    - filename: shared.gguf
-      sha256: aa
-      uri: https://example.com/a.gguf
-- name: b
-  files:
-    - filename: shared.gguf
-      sha256: bb
-      uri: https://example.com/b.gguf
-- name: c
-  files:
-    - filename: shared.gguf
-      sha256: cc
-      uri: https://example.com/c.gguf
-`))
-
-		var collisions int
-		for _, p := range problems {
-			if strings.Contains(p, "claimed by two different uris") {
-				collisions++
-			}
-		}
-		Expect(collisions).To(Equal(1))
-	})
-
-	It("says nothing about files that carry no uri", func() {
-		// A hand-written entry may record only a checksum. There is no upstream
-		// to compare, so the check cannot conclude anything either way.
-		Expect(Verify(write(`
-- name: a
-  files:
-    - filename: shared.gguf
-      sha256: aa
-- name: b
-  files:
-    - filename: shared.gguf
-      sha256: bb
-`))).To(BeEmpty())
-	})
-})

.github/ci/galleryedit/edit.go

@@ -1,152 +0,0 @@
-// Package galleryedit splices variant references into the LocalAI gallery index
-// as TEXT.
-//
-// Re-serialising the index through a YAML marshaller would reflow 40,000 lines,
-// drop the anchors and merge keys the gallery relies on, and produce a diff no
-// reviewer could read, which makes a pull request worthless even when the
-// content inside it is right. Every generator that adds variants to an entry the
-// gallery already ships therefore edits lines, and they share this package so
-// that two of them cannot drift apart on where a variants block belongs.
-package galleryedit
-
-import (
-	"fmt"
-	"regexp"
-	"sort"
-	"strings"
-)
-
-var (
-	entryStart   = regexp.MustCompile(`^-(?: |$)`)
-	inlineName   = regexp.MustCompile(`^- (?:&\S+ )?name:`)
-	keyName      = regexp.MustCompile(`^  name:`)
-	keyVariants  = regexp.MustCompile(`^  variants:\s*(.*)$`)
-	variantItem  = regexp.MustCompile(`^    - `)
-	unsafeInName = regexp.MustCompile(`[:#{}\[\],&*?|>'"%@` + "`" + `]|^\s|\s$`)
-)
-
-// Entry is the positional view of one gallery entry: what it is called and
-// which lines it occupies. Nothing about what the entry MEANS belongs here, so
-// each caller keeps its own semantic decode and only hands over the coordinates.
-type Entry struct {
-	Name string
-	// StartLine and EndLine bound the entry, zero based and half open.
-	StartLine int
-	EndLine   int
-}
-
-// Insert is one entry's pending variants addition. The caller owns the contents
-// of Variants: this package neither orders nor deduplicates them, because the
-// right order and the right dedup rule differ between generators.
-type Insert struct {
-	Entry    Entry
-	Variants []string
-}
-
-// Scan splits index text into lines and reports the line each top level list
-// item begins on.
-func Scan(text string) (lines []string, starts []int) {
-	lines = strings.Split(text, "\n")
-	for i, line := range lines {
-		if entryStart.MatchString(line) {
-			starts = append(starts, i)
-		}
-	}
-	return lines, starts
-}
-
-// Apply splices every insert into the index lines and returns the new text.
-func Apply(lines []string, inserts []Insert) ([]string, error) {
-	type edit struct {
-		at     int
-		remove int
-		insert []string
-	}
-	var edits []edit
-
-	for _, in := range inserts {
-		if len(in.Variants) == 0 {
-			continue
-		}
-
-		items := make([]string, 0, len(in.Variants))
-		for _, v := range in.Variants {
-			items = append(items, "    - model: "+QuoteName(v))
-		}
-
-		at, remove, err := insertionPoint(lines, in.Entry)
-		if err != nil {
-			return nil, err
-		}
-		block := items
-		if remove > 0 || !hasVariantsKey(lines, in.Entry) {
-			block = append([]string{"  variants:"}, items...)
-		}
-		edits = append(edits, edit{at: at, remove: remove, insert: block})
-	}
-
-	// Applying from the bottom up keeps every line number computed against the
-	// original text valid while earlier edits are still pending.
-	sort.Slice(edits, func(i, j int) bool { return edits[i].at > edits[j].at })
-
-	out := append([]string(nil), lines...)
-	for _, e := range edits {
-		tail := append([]string(nil), out[e.at+e.remove:]...)
-		out = append(out[:e.at], append(append([]string(nil), e.insert...), tail...)...)
-	}
-	return out, nil
-}
-
-func hasVariantsKey(lines []string, e Entry) bool {
-	for i := e.StartLine; i < e.EndLine; i++ {
-		if keyVariants.MatchString(lines[i]) {
-			return true
-		}
-	}
-	return false
-}
-
-// insertionPoint reports where new variant items belong, and how many existing
-// lines the insertion replaces.
-//
-// An entry with no variants key gets one right after its name, which is where
-// the hand-written families put it. An entry with an empty "variants: []" has
-// that line replaced by a block. An entry with a block gets its items appended.
-func insertionPoint(lines []string, e Entry) (at int, remove int, err error) {
-	for i := e.StartLine; i < e.EndLine; i++ {
-		m := keyVariants.FindStringSubmatch(lines[i])
-		if m == nil {
-			continue
-		}
-		if strings.TrimSpace(m[1]) == "[]" {
-			return i, 1, nil
-		}
-		if strings.TrimSpace(m[1]) != "" {
-			return 0, 0, fmt.Errorf("entry %q writes its variants inline (%q); this job only edits block lists", e.Name, strings.TrimSpace(m[1]))
-		}
-		last := i
-		for j := i + 1; j < e.EndLine && variantItem.MatchString(lines[j]); j++ {
-			last = j
-		}
-		return last + 1, 0, nil
-	}
-
-	if inlineName.MatchString(lines[e.StartLine]) {
-		return e.StartLine + 1, 0, nil
-	}
-	for i := e.StartLine; i < e.EndLine; i++ {
-		if keyName.MatchString(lines[i]) {
-			return i + 1, 0, nil
-		}
-	}
-	return 0, 0, fmt.Errorf("entry %q has no name line to anchor the insertion to", e.Name)
-}
-
-// QuoteName quotes a variant reference when the name would otherwise change
-// meaning as bare YAML. Config-suffixed names carry a ":" and always need it.
-func QuoteName(name string) string {
-	if unsafeInName.MatchString(name) {
-		return `"` + strings.ReplaceAll(name, `"`, `\"`) + `"`
-	}
-	return name
-}

.github/ci/variantproposals/body.go

@@ -1,133 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"strings"
-)
-
-// RenderBody writes the pull request body.
-//
-// The body is the product of this job, not the diff. Grouping is a judgement
-// call that has gone wrong in both directions before, so a reviewer has to be
-// able to accept or reject each family from the body alone, without opening
-// HuggingFace to work out whether two entries hold the same weights.
-func RenderBody(r *Result, ledgerPath string) string {
-	var b strings.Builder
-
-	b.WriteString("## Proposed gallery variant groupings\n\n")
-	b.WriteString("This is a proposal, not a decision. The gallery agent adds one build per model and never joins an existing family, so entries that are alternative builds of the same weights drift apart as the gallery grows. This job re-applies the grouping heuristics from the manual sweeps and asks a human to confirm.\n\n")
-	b.WriteString("Each family below lists the parent, the variants, and the evidence that they are the same weights. **Reject anything whose evidence you do not believe.**\n\n")
-	b.WriteString(fmt.Sprintf("To decline a family permanently, add one line to `%s` in this pull request and close it:\n\n", ledgerPath))
-	b.WriteString("```yaml\npairs:\n  - {parent: some-model, variant: some-model-thing, reason: \"different finetune\"}\n```\n\n")
-
-	b.WriteString(fmt.Sprintf("### Proposed families (%d)\n\n", len(r.Families)))
-	if len(r.Families) == 0 {
-		b.WriteString("None.\n\n")
-	}
-	for _, f := range r.Families {
-		b.WriteString(fmt.Sprintf("#### `%s`\n\n", f.Parent))
-		b.WriteString("| variant | signals | evidence |\n|---|---|---|\n")
-		for _, p := range f.Proposals {
-			b.WriteString(fmt.Sprintf("| `%s` | %s | %s |\n", p.Variant, joinSignals(p.Evidence.Signals), describeEvidence(p.Evidence)))
-		}
-		b.WriteString("\n")
-	}
-
-	b.WriteString(fmt.Sprintf("### Declined by the ledger (%d)\n\n", len(r.Suppressed)))
-	if len(r.Suppressed) == 0 {
-		b.WriteString("Nothing the heuristics found was already on the ledger.\n\n")
-	} else {
-		b.WriteString("Candidates the heuristics found and the ledger has already settled. They are listed so the ledger's effect stays visible rather than silently shrinking the job's output.\n\n")
-		for _, s := range r.Suppressed {
-			b.WriteString(fmt.Sprintf("- `%s` + `%s`: %s\n", s.A, s.B, s.Reason))
-		}
-		b.WriteString("\n")
-	}
-
-	if len(r.AliasSkipped) > 0 {
-		b.WriteString(fmt.Sprintf("### Aliases, not variants (%d)\n\n", len(r.AliasSkipped)))
-		b.WriteString("These entries install byte for byte the same payload. An alias exists so clients can send a particular name; folding it under another entry would hide that name.\n\n")
-		for _, s := range r.AliasSkipped {
-			b.WriteString(fmt.Sprintf("- `%s` + `%s`: %s\n", s.A, s.B, s.Reason))
-		}
-		b.WriteString("\n")
-	}
-
-	if len(r.Refusals) > 0 {
-		b.WriteString(fmt.Sprintf("### Found but refused (%d)\n\n", len(r.Refusals)))
-		b.WriteString("Candidates the heuristics found but the authoring rules would not let this job write. They need a human edit or a rule change.\n\n")
-		for _, ref := range r.Refusals {
-			b.WriteString(fmt.Sprintf("- %s: %s\n", codeList(ref.Members), ref.Reason))
-		}
-		b.WriteString("\n")
-	}
-
-	b.WriteString("---\n\nOpened by `.github/ci/variantproposals`. Heuristics and the rejection ledger live there and in the ledger file; a wrong proposal is a bug in one of the two.\n")
-	return b.String()
-}
-
-func joinSignals(signals []Signal) string {
-	if len(signals) == 0 {
-		return "inferred through another member of the family"
-	}
-	out := make([]string, 0, len(signals))
-	for _, s := range signals {
-		out = append(out, "`"+string(s)+"`")
-	}
-	return strings.Join(out, ", ")
-}
-
-func describeEvidence(e Evidence) string {
-	var parts []string
-	if e.SharedStem != "" {
-		parts = append(parts, fmt.Sprintf("same name once quantization markers are stripped: `%s`", e.SharedStem))
-	}
-	if e.SharedFile != "" {
-		parts = append(parts, fmt.Sprintf("same primary weight filename once quantization markers are stripped: `%s`", e.SharedFile))
-	}
-	if e.SharedRepo != "" {
-		parts = append(parts, fmt.Sprintf("same upstream repo `%s`", e.SharedRepo))
-	}
-	if len(e.QuantTokens) > 0 {
-		parts = append(parts, "differing quantization tokens: `"+strings.Join(e.QuantTokens, "`, `")+"`")
-	}
-	if len(parts) == 0 {
-		return "reached this family through another member"
-	}
-	return strings.Join(parts, "; ")
-}
-
-func codeList(names []string) string {
-	out := make([]string, 0, len(names))
-	for _, n := range names {
-		out = append(out, "`"+n+"`")
-	}
-	return strings.Join(out, " + ")
-}
-
-// RenderSummary is the terminal-facing digest of a run, so the workflow log
-// says what happened without anyone opening the pull request.
-func RenderSummary(r *Result) string {
-	var b strings.Builder
-	fmt.Fprintf(&b, "families proposed: %d\n", len(r.Families))
-	for _, f := range r.Families {
-		names := make([]string, 0, len(f.Proposals))
-		for _, p := range f.Proposals {
-			names = append(names, p.Variant)
-		}
-		fmt.Fprintf(&b, "  %s <- %s\n", f.Parent, strings.Join(names, ", "))
-	}
-	fmt.Fprintf(&b, "declined by ledger: %d\n", len(r.Suppressed))
-	for _, s := range r.Suppressed {
-		fmt.Fprintf(&b, "  %s\n", s)
-	}
-	fmt.Fprintf(&b, "aliases skipped: %d\n", len(r.AliasSkipped))
-	for _, s := range r.AliasSkipped {
-		fmt.Fprintf(&b, "  %s\n", s)
-	}
-	fmt.Fprintf(&b, "refused: %d\n", len(r.Refusals))
-	for _, ref := range r.Refusals {
-		fmt.Fprintf(&b, "  %s: %s\n", strings.Join(ref.Members, " + "), ref.Reason)
-	}
-	return b.String()
-}

.github/ci/variantproposals/edit.go

@@ -1,42 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/mudler/LocalAI/.github/ci/galleryedit"
-)
-
-// ApplyFamilies writes the proposed variant lists into the index text.
-//
-// The line editing itself lives in galleryedit, shared with the apexentries
-// generator. Both jobs add variants to entries the gallery already ships, and a
-// second answer to "where does a variants block go" would drift from this one;
-// see that package for why the edit is textual rather than a YAML round trip.
-func ApplyFamilies(ix *Index, families []Family) ([]string, error) {
-	byName, _ := ix.ByName()
-
-	var inserts []galleryedit.Insert
-	for _, f := range families {
-		entry, ok := byName[strings.ToLower(f.Parent)]
-		if !ok {
-			return nil, fmt.Errorf("parent %q is not in the index", f.Parent)
-		}
-
-		variants := make([]string, 0, len(f.Proposals))
-		for _, p := range f.Proposals {
-			variants = append(variants, p.Variant)
-		}
-
-		inserts = append(inserts, galleryedit.Insert{
-			Entry: galleryedit.Entry{
-				Name:      entry.Name,
-				StartLine: entry.StartLine,
-				EndLine:   entry.EndLine,
-			},
-			Variants: variants,
-		})
-	}
-
-	return galleryedit.Apply(ix.Lines, inserts)
-}

.github/ci/variantproposals/edit_test.go

@@ -1,153 +0,0 @@
-package main
-
-import (
-	"strings"
-
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("ApplyFamilies", func() {
-	apply := func(ix *Index, families []Family) []string {
-		lines, err := ApplyFamilies(ix, families)
-		ExpectWithOffset(1, err).ToNot(HaveOccurred())
-		return lines
-	}
-
-	// insertedLines is what a reviewer would see in the diff. A textual editor
-	// that reflowed the file would show thousands here, which is the failure
-	// this whole approach exists to avoid.
-	insertedLines := func(before, after []string) int {
-		remaining := map[string]int{}
-		for _, l := range before {
-			remaining[l]++
-		}
-		n := 0
-		for _, l := range after {
-			if remaining[l] > 0 {
-				remaining[l]--
-				continue
-			}
-			n++
-		}
-		return n
-	}
-
-	It("adds a variants block right after the entry's name and touches nothing else", func() {
-		ix := indexOf(
-			entryYAML("foo-model", "acme/repo", "foo-model-Q4_K_M.gguf", "aa"),
-			entryYAML("foo-model-q8_0", "acme/repo", "foo-model-Q8_0.gguf", "bb"),
-		)
-		out := apply(ix, []Family{{Parent: "foo-model", Proposals: []Proposal{{Variant: "foo-model-q8_0"}}}})
-
-		Expect(out[0]).To(Equal("- name: foo-model"))
-		Expect(out[1]).To(Equal("  variants:"))
-		Expect(out[2]).To(Equal("    - model: foo-model-q8_0"))
-		Expect(len(out)).To(Equal(len(ix.Lines) + 2))
-		Expect(insertedLines(ix.Lines, out)).To(Equal(2))
-	})
-
-	It("appends to a variants block that already exists", func() {
-		ix := indexOf(`- name: partial
-  variants:
-    - model: partial-q8_0
-  url: u
-  overrides:
-    parameters:
-      model: partial-Q4_K_M.gguf
-`, entryYAML("partial-f16", "acme/repo", "partial-f16.gguf", "cc"))
-		out := apply(ix, []Family{{Parent: "partial", Proposals: []Proposal{{Variant: "partial-f16"}}}})
-
-		Expect(out[1]).To(Equal("  variants:"))
-		Expect(out[2]).To(Equal("    - model: partial-q8_0"))
-		Expect(out[3]).To(Equal("    - model: partial-f16"))
-		Expect(out[4]).To(Equal("  url: u"))
-	})
-
-	It("replaces an explicit empty list rather than leaving two variants keys", func() {
-		ix := indexOf(`- name: emptied
-  variants: []
-  url: u
-`, entryYAML("emptied-q8_0", "acme/repo", "emptied-Q8_0.gguf", "cc"))
-		out := apply(ix, []Family{{Parent: "emptied", Proposals: []Proposal{{Variant: "emptied-q8_0"}}}})
-
-		Expect(strings.Join(out[:4], "\n")).To(Equal("- name: emptied\n  variants:\n    - model: emptied-q8_0\n  url: u"))
-		Expect(strings.Count(strings.Join(out, "\n"), "variants:")).To(Equal(1))
-	})
-
-	It("quotes a config-suffixed name so the reference stays a string", func() {
-		ix := indexOf(
-			entryYAML("phi-2-chat", "acme/repo", "phi-2-chat-Q4_K_M.gguf", "aa"),
-			entryYAML("phi-2-chat:Q8_0", "acme/repo", "phi-2-chat-Q8_0.gguf", "bb"),
-		)
-		out := apply(ix, []Family{{Parent: "phi-2-chat", Proposals: []Proposal{{Variant: "phi-2-chat:Q8_0"}}}})
-		Expect(out[2]).To(Equal(`    - model: "phi-2-chat:Q8_0"`))
-
-		// The result has to still be a gallery, and the reference has to
-		// resolve to the entry it names.
-		reparsed, err := ParseIndex(strings.Join(out, "\n"))
-		Expect(err).ToNot(HaveOccurred())
-		Expect(reparsed.Entries[0].Variants).To(ConsistOf(VariantRef{Model: "phi-2-chat:Q8_0"}))
-	})
-
-	It("keeps line numbers correct when several entries are edited at once", func() {
-		ix := indexOf(
-			entryYAML("alpha", "acme/repo", "alpha-Q4_K_M.gguf", "aa"),
-			entryYAML("alpha-q8_0", "acme/repo", "alpha-Q8_0.gguf", "bb"),
-			entryYAML("beta", "acme/repo", "beta-Q4_K_M.gguf", "cc"),
-			entryYAML("beta-q8_0", "acme/repo", "beta-Q8_0.gguf", "dd"),
-		)
-		out := apply(ix, []Family{
-			{Parent: "alpha", Proposals: []Proposal{{Variant: "alpha-q8_0"}}},
-			{Parent: "beta", Proposals: []Proposal{{Variant: "beta-q8_0"}}},
-		})
-
-		reparsed, err := ParseIndex(strings.Join(out, "\n"))
-		Expect(err).ToNot(HaveOccurred())
-		Expect(reparsed.Entries).To(HaveLen(4))
-		Expect(reparsed.Entries[0].Variants).To(ConsistOf(VariantRef{Model: "alpha-q8_0"}))
-		Expect(reparsed.Entries[2].Variants).To(ConsistOf(VariantRef{Model: "beta-q8_0"}))
-		Expect(reparsed.Entries[1].Variants).To(BeEmpty())
-		Expect(reparsed.Entries[3].Variants).To(BeEmpty())
-	})
-
-	It("fails loudly rather than editing an entry it cannot find", func() {
-		ix := indexOf(entryYAML("only", "acme/repo", "only-Q4_K_M.gguf", "aa"))
-		_, err := ApplyFamilies(ix, []Family{{Parent: "missing", Proposals: []Proposal{{Variant: "x"}}}})
-		Expect(err).To(MatchError(ContainSubstring("not in the index")))
-	})
-})
-
-var _ = Describe("ParseIndex", func() {
-	It("records the anchor an entry defines and the anchor an entry merges", func() {
-		ix := indexOf(`- &anc
-  name: anchored
-  url: u
-`, `- !!merge <<: *anc
-  name: child
-`)
-		Expect(ix.Entries[0].AnchorName).To(Equal("anc"))
-		Expect(ix.Entries[1].MergesFrom).To(Equal("anc"))
-		Expect(ix.MergeChildren("anc")).To(HaveLen(1))
-	})
-
-	It("carries merged values into the child, so an inherited variants key is visible", func() {
-		ix := indexOf(`- &anc
-  name: anchored
-  url: u
-  variants:
-    - model: something
-`, `- !!merge <<: *anc
-  name: child
-`)
-		Expect(ix.Entries[1].HasVariants()).To(BeTrue())
-	})
-
-	It("refuses a list item that decodes to nothing", func() {
-		// Every line number the editor works from comes from pairing decoded
-		// entries with top level list items. If those two views can disagree,
-		// the editor writes into the wrong entry, so the parse refuses instead.
-		_, err := ParseIndex("- name: one\n  url: u\n-\n")
-		Expect(err).To(MatchError(ContainSubstring("empty")))
-	})
-})

.github/ci/variantproposals/index.go

@@ -1,281 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"os"
-	"regexp"
-	"sort"
-	"strings"
-
-	"gopkg.in/yaml.v3"
-
-	"github.com/mudler/LocalAI/.github/ci/galleryedit"
-)
-
-// File is the subset of a gallery file entry the proposer reads.
-type File struct {
-	Filename string `yaml:"filename"`
-	URI      string `yaml:"uri"`
-	SHA256   string `yaml:"sha256"`
-}
-
-// VariantRef mirrors the gallery's variant reference.
-type VariantRef struct {
-	Model string `yaml:"model"`
-}
-
-// GalleryEntry is one gallery entry, carrying both the semantics the heuristics need
-// and the text range the editor needs.
-//
-// The two views are kept together deliberately. The editor must not round-trip
-// the index through a YAML marshaller: the gallery is 40,000 lines and a
-// reflowed diff cannot be reviewed, which defeats the entire point of a job
-// whose output is a human decision.
-type GalleryEntry struct {
-	Name       string         `yaml:"name"`
-	URL        string         `yaml:"url"`
-	ConfigFile map[string]any `yaml:"config_file"`
-	Overrides  map[string]any `yaml:"overrides"`
-	Files      []File         `yaml:"files"`
-	Variants   []VariantRef   `yaml:"variants"`
-
-	// Index is the entry's position in gallery order.
-	Index int `yaml:"-"`
-	// StartLine and EndLine bound the entry's lines, zero based and half open.
-	StartLine int `yaml:"-"`
-	EndLine   int `yaml:"-"`
-	// AnchorName is set when the entry defines a YAML anchor. Adding a variants
-	// key to such an entry is inherited by everything that merges it, which is
-	// why proposals involving anchors get special treatment.
-	AnchorName string `yaml:"-"`
-	// MergesFrom is the anchor this entry pulls in with "!!merge <<:".
-	MergesFrom string `yaml:"-"`
-}
-
-// Index is a parsed gallery index: entries plus the exact lines they came from.
-type Index struct {
-	Lines   []string
-	Entries []*GalleryEntry
-}
-
-var (
-	anchorStart = regexp.MustCompile(`^- &(\S+)`)
-	mergeStart  = regexp.MustCompile(`^- !!merge <<: \*(\S+)`)
-)
-
-// LoadIndex reads and parses a gallery index file.
-func LoadIndex(path string) (*Index, error) {
-	data, err := os.ReadFile(path)
-	if err != nil {
-		return nil, err
-	}
-	return ParseIndex(string(data))
-}
-
-// ParseIndex builds an Index from the raw text of a gallery index.
-//
-// The YAML decode and the textual scan are cross checked against each other: if
-// they disagree on how many entries there are, every line number the editor
-// would use is suspect, so the run fails rather than editing the wrong entry.
-func ParseIndex(text string) (*Index, error) {
-	var entries []*GalleryEntry
-	if err := yaml.Unmarshal([]byte(text), &entries); err != nil {
-		return nil, fmt.Errorf("decoding gallery index: %w", err)
-	}
-
-	lines, starts := galleryedit.Scan(text)
-	if len(starts) != len(entries) {
-		return nil, fmt.Errorf("gallery index has %d decoded entries but %d top level list items; refusing to edit by line number", len(entries), len(starts))
-	}
-
-	for i, e := range entries {
-		if e == nil {
-			return nil, fmt.Errorf("gallery index list item %d is empty; refusing to edit by line number", i)
-		}
-		e.Index = i
-		e.StartLine = starts[i]
-		if i+1 < len(starts) {
-			e.EndLine = starts[i+1]
-		} else {
-			e.EndLine = len(lines)
-		}
-		if m := anchorStart.FindStringSubmatch(lines[e.StartLine]); m != nil {
-			e.AnchorName = m[1]
-		}
-		if m := mergeStart.FindStringSubmatch(lines[e.StartLine]); m != nil {
-			e.MergesFrom = m[1]
-		}
-	}
-
-	return &Index{Lines: lines, Entries: entries}, nil
-}
-
-// MergeChildren lists the entries that pull in the given anchor.
-func (ix *Index) MergeChildren(anchor string) []*GalleryEntry {
-	var out []*GalleryEntry
-	for _, e := range ix.Entries {
-		if e.MergesFrom == anchor {
-			out = append(out, e)
-		}
-	}
-	return out
-}
-
-// ByName indexes entries by lowercased name. A name appearing twice keeps the
-// first occurrence, matching the gallery's own first-match-wins resolution, and
-// the duplicates are returned so the caller can refuse to touch them: a
-// proposal naming an ambiguous entry cannot be reviewed.
-func (ix *Index) ByName() (map[string]*GalleryEntry, map[string]int) {
-	byName := make(map[string]*GalleryEntry, len(ix.Entries))
-	counts := make(map[string]int, len(ix.Entries))
-	for _, e := range ix.Entries {
-		key := strings.ToLower(e.Name)
-		counts[key]++
-		if _, seen := byName[key]; !seen {
-			byName[key] = e
-		}
-	}
-	dupes := map[string]int{}
-	for name, n := range counts {
-		if n > 1 {
-			dupes[name] = n
-		}
-	}
-	return byName, dupes
-}
-
-// Installable reports whether installing this entry would put anything on disk.
-// A variant target that installs nothing is a dead end for the selector, so it
-// is never proposed as one.
-func (e *GalleryEntry) Installable() bool {
-	return e.URL != "" || len(e.ConfigFile) > 0 || len(e.Overrides) > 0 || len(e.Files) > 0
-}
-
-// HasVariants reports whether the entry already offers builds of its own. Such
-// an entry cannot be a variant target: nesting is what the gallery's own
-// resolution refuses.
-func (e *GalleryEntry) HasVariants() bool {
-	return len(e.Variants) > 0
-}
-
-// auxiliaryFile matches the shared side files that several unrelated models
-// legitimately hand out the same copy of. Grouping on one of these is how an
-// earlier sweep linked four wan-2.1 entries to each other and Z-Image-Turbo to
-// qwen3-4b: they shared a text encoder, not weights.
-var auxiliaryFile = regexp.MustCompile(`(?i)(mmproj|vae|clip|t5|umt5|text_?encoder|tokenizer|\bae\b|^ae\.|scheduler|config)`)
-
-// IsAuxiliaryFile reports whether a filename is a side file rather than the
-// model's own weights.
-func IsAuxiliaryFile(filename string) bool {
-	base := filename
-	if i := strings.LastIndex(base, "/"); i >= 0 {
-		base = base[i+1:]
-	}
-	return auxiliaryFile.MatchString(base)
-}
-
-// PrimaryWeightFile returns the filename of the entry's own weights, and
-// whether one could be identified unambiguously.
-//
-// The declared overrides.parameters.model wins because that is the file the
-// backend is actually pointed at. Falling back to the file list only works when
-// exactly one non-auxiliary file is present; anything else is ambiguous, and
-// guessing is precisely the failure mode this heuristic has already had.
-func (e *GalleryEntry) PrimaryWeightFile() (string, bool) {
-	if params, ok := e.Overrides["parameters"].(map[string]any); ok {
-		if model, ok := params["model"].(string); ok && model != "" && !IsAuxiliaryFile(model) {
-			return model, true
-		}
-	}
-	var candidates []string
-	for _, f := range e.Files {
-		if f.Filename == "" || IsAuxiliaryFile(f.Filename) {
-			continue
-		}
-		candidates = append(candidates, f.Filename)
-	}
-	if len(candidates) == 1 {
-		return candidates[0], true
-	}
-	return "", false
-}
-
-// SourceRepo returns the upstream repository the entry's files come from, as a
-// coarse "host + owner + repo" key.
-func (e *GalleryEntry) SourceRepo() string {
-	for _, f := range e.Files {
-		if f.URI == "" {
-			continue
-		}
-		return repoKey(f.URI)
-	}
-	return ""
-}
-
-func repoKey(uri string) string {
-	u := strings.ToLower(uri)
-	u = strings.TrimPrefix(u, "huggingface://")
-	u = strings.TrimPrefix(u, "https://huggingface.co/")
-	u = strings.TrimPrefix(u, "http://huggingface.co/")
-	parts := strings.Split(u, "/")
-	if len(parts) >= 2 {
-		return parts[0] + "/" + parts[1]
-	}
-	return u
-}
-
-// SameInstallPayload reports whether two entries install byte for byte the same
-// thing.
-//
-// Entries like this are aliases, not variants. whisper-1 exists so a client
-// speaking the OpenAI API can send that name and get whisper-base; folding it
-// under whisper-base as a variant would hide the very name clients send.
-func SameInstallPayload(a, b *GalleryEntry) bool {
-	if a.URL != b.URL {
-		return false
-	}
-	if !sameYAML(a.Overrides, b.Overrides) || !sameYAML(a.ConfigFile, b.ConfigFile) {
-		return false
-	}
-	return sameChecksums(a.Files, b.Files)
-}
-
-func sameChecksums(a, b []File) bool {
-	if len(a) != len(b) || len(a) == 0 {
-		return false
-	}
-	ha := make([]string, 0, len(a))
-	hb := make([]string, 0, len(b))
-	for _, f := range a {
-		if f.SHA256 == "" {
-			return false
-		}
-		ha = append(ha, f.SHA256)
-	}
-	for _, f := range b {
-		if f.SHA256 == "" {
-			return false
-		}
-		hb = append(hb, f.SHA256)
-	}
-	sort.Strings(ha)
-	sort.Strings(hb)
-	for i := range ha {
-		if ha[i] != hb[i] {
-			return false
-		}
-	}
-	return true
-}
-
-func sameYAML(a, b any) bool {
-	ba, err := yaml.Marshal(a)
-	if err != nil {
-		return false
-	}
-	bb, err := yaml.Marshal(b)
-	if err != nil {
-		return false
-	}
-	return string(ba) == string(bb)
-}

.github/ci/variantproposals/ledger.go

@@ -1,180 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"os"
-	"sort"
-	"strings"
-
-	"gopkg.in/yaml.v3"
-)
-
-// Ledger records the grouping decisions a human has already made against the
-// proposer, so a declined candidate stays declined instead of coming back every
-// night until reviewers stop reading the job's pull requests.
-//
-// It is checked in next to the gallery and is meant to be edited inside the
-// proposal pull request itself: declining a family is adding one flow-mapping
-// line under pairs or groups and closing the PR.
-type Ledger struct {
-	// Tokens are name segments that mark a distinct model rather than another
-	// build of the same one: finetune names, language codes, product suffixes.
-	// A candidate whose two names differ by any of these is never proposed.
-	Tokens []LedgerToken `yaml:"tokens"`
-	// Pairs are individual candidates a human considered and declined. Order
-	// does not matter: the pair is matched both ways round.
-	Pairs []LedgerPair `yaml:"pairs"`
-	// Groups decline every pair drawn from a set at once, for families like a
-	// per-language release where listing each pair would be unreadable.
-	Groups []LedgerGroup `yaml:"groups"`
-}
-
-type LedgerToken struct {
-	Token  string `yaml:"token"`
-	Reason string `yaml:"reason"`
-}
-
-type LedgerPair struct {
-	Parent  string `yaml:"parent"`
-	Variant string `yaml:"variant"`
-	Reason  string `yaml:"reason"`
-}
-
-type LedgerGroup struct {
-	Members []string `yaml:"members"`
-	Reason  string   `yaml:"reason"`
-}
-
-// LoadLedger reads a ledger file. A missing file is not an error: a gallery
-// that has declined nothing yet is a legitimate state, and failing the job over
-// it would only teach people to keep an empty file around.
-func LoadLedger(path string) (*Ledger, error) {
-	data, err := os.ReadFile(path)
-	if os.IsNotExist(err) {
-		return &Ledger{}, nil
-	}
-	if err != nil {
-		return nil, err
-	}
-	return ParseLedger(data)
-}
-
-func ParseLedger(data []byte) (*Ledger, error) {
-	l := &Ledger{}
-	if err := yaml.Unmarshal(data, l); err != nil {
-		return nil, fmt.Errorf("parsing ledger: %w", err)
-	}
-	for i, t := range l.Tokens {
-		if strings.TrimSpace(t.Token) == "" {
-			return nil, fmt.Errorf("ledger tokens[%d] has an empty token", i)
-		}
-	}
-	for i, p := range l.Pairs {
-		if strings.TrimSpace(p.Parent) == "" || strings.TrimSpace(p.Variant) == "" {
-			return nil, fmt.Errorf("ledger pairs[%d] needs both parent and variant", i)
-		}
-	}
-	return l, nil
-}
-
-// Suppression is a ledger hit: why a candidate was not proposed, in words a
-// reviewer can check against the ledger file.
-type Suppression struct {
-	A      string
-	B      string
-	Reason string
-}
-
-func (s Suppression) String() string {
-	return fmt.Sprintf("%s + %s: %s", s.A, s.B, s.Reason)
-}
-
-// Suppresses reports whether the ledger has already declined pairing these two
-// entries, and why.
-//
-// The token rule is applied to the segments the two names do not share. Two
-// builds of the same weights differ only in quantization markers, so any
-// ledgered token showing up in that difference is by construction a claim that
-// the entries are different models.
-func (l *Ledger) Suppresses(a, b string) (Suppression, bool) {
-	la, lb := strings.ToLower(a), strings.ToLower(b)
-	for _, p := range l.Pairs {
-		lp, lv := strings.ToLower(p.Parent), strings.ToLower(p.Variant)
-		if (lp == la && lv == lb) || (lp == lb && lv == la) {
-			return Suppression{A: a, B: b, Reason: p.Reason}, true
-		}
-	}
-	for _, g := range l.Groups {
-		var seenA, seenB bool
-		for _, m := range g.Members {
-			lm := strings.ToLower(m)
-			if lm == la {
-				seenA = true
-			}
-			if lm == lb {
-				seenB = true
-			}
-		}
-		if seenA && seenB {
-			return Suppression{A: a, B: b, Reason: g.Reason}, true
-		}
-	}
-	diff := differingSegments(la, lb)
-	for _, t := range l.Tokens {
-		token := strings.ToLower(strings.TrimSpace(t.Token))
-		if _, ok := diff[token]; ok {
-			reason := t.Reason
-			if reason == "" {
-				reason = fmt.Sprintf("names differ by %q", token)
-			}
-			return Suppression{A: a, B: b, Reason: fmt.Sprintf("%s (token %q)", reason, token)}, true
-		}
-	}
-	return Suppression{}, false
-}
-
-// segments splits a name into the atoms the token rules are written against.
-func segments(name string) []string {
-	fields := strings.FieldsFunc(strings.ToLower(name), func(r rune) bool {
-		return r == '-' || r == '_' || r == '.' || r == ':' || r == '/'
-	})
-	return fields
-}
-
-// differingSegments returns the set of segments present in exactly one of the
-// two names.
-func differingSegments(a, b string) map[string]struct{} {
-	setA := map[string]int{}
-	for _, s := range segments(a) {
-		setA[s]++
-	}
-	setB := map[string]int{}
-	for _, s := range segments(b) {
-		setB[s]++
-	}
-	diff := map[string]struct{}{}
-	for s := range setA {
-		if setB[s] == 0 {
-			diff[s] = struct{}{}
-		}
-	}
-	for s := range setB {
-		if setA[s] == 0 {
-			diff[s] = struct{}{}
-		}
-	}
-	return diff
-}
-
-// SortedSuppressions gives the ledger's effect on one run in a stable order, so
-// the pull request body reads the same way for the same gallery.
-func SortedSuppressions(in []Suppression) []Suppression {
-	out := append([]Suppression(nil), in...)
-	sort.Slice(out, func(i, j int) bool {
-		if out[i].A != out[j].A {
-			return out[i].A < out[j].A
-		}
-		return out[i].B < out[j].B
-	})
-	return out
-}

.github/ci/variantproposals/main.go

@@ -1,65 +0,0 @@
-// Command variant-proposals looks for gallery entries that are alternative
-// builds of the same weights but are not grouped under one another, and writes
-// a proposal for a human to accept or reject.
-//
-// It never decides. Grouping has gone wrong repeatedly in both directions, so
-// the job's value is catching drift and surfacing candidates with their
-// evidence, not automating the call. The scheduled workflow feeds its output to
-// a pull request in the same shape as .github/checksum_checker.sh.
-package main
-
-import (
-	"flag"
-	"fmt"
-	"os"
-	"strings"
-)
-
-func main() {
-	index := flag.String("index", "gallery/index.yaml", "path to the gallery index")
-	ledger := flag.String("ledger", "gallery/variant-exclusions.yaml", "path to the rejection ledger")
-	bodyOut := flag.String("body-out", "", "write the pull request body here")
-	apply := flag.Bool("apply", false, "write the proposed groupings back into the index")
-	flag.Parse()
-
-	if err := run(*index, *ledger, *bodyOut, *apply); err != nil {
-		fmt.Fprintln(os.Stderr, "variant-proposals:", err)
-		os.Exit(1)
-	}
-}
-
-func run(indexPath, ledgerPath, bodyOut string, apply bool) error {
-	ix, err := LoadIndex(indexPath)
-	if err != nil {
-		return err
-	}
-	ledger, err := LoadLedger(ledgerPath)
-	if err != nil {
-		return err
-	}
-
-	result := Propose(ix, ledger)
-	fmt.Print(RenderSummary(result))
-
-	if !result.HasProposals() {
-		// An empty pull request every night is how a proposal job gets muted.
-		fmt.Println("nothing to propose")
-		return nil
-	}
-
-	if bodyOut != "" {
-		if err := os.WriteFile(bodyOut, []byte(RenderBody(result, ledgerPath)), 0o644); err != nil {
-			return err
-		}
-	}
-
-	if !apply {
-		return nil
-	}
-
-	lines, err := ApplyFamilies(ix, result.Families)
-	if err != nil {
-		return err
-	}
-	return os.WriteFile(indexPath, []byte(strings.Join(lines, "\n")), 0o644)
-}

.github/ci/variantproposals/propose.go

@@ -1,615 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"regexp"
-	"sort"
-	"strings"
-)
-
-// Signal names the grouping heuristic that linked two entries.
-type Signal string
-
-const (
-	// SignalName is "same name once quantization markers are stripped".
-	SignalName Signal = "name-modulo-quant"
-	// SignalConfigSuffix is the ":" convention, foo:q8_0 as a build of foo.
-	SignalConfigSuffix Signal = "config-suffix"
-	// SignalWeightFile is "same primary weight filename once quantization
-	// markers are stripped", auxiliary files excluded.
-	SignalWeightFile Signal = "weight-filename"
-)
-
-// Evidence is what a reviewer needs in order to agree or disagree without
-// opening HuggingFace: what the two entries share, and what differs.
-type Evidence struct {
-	Signals     []Signal
-	SharedStem  string
-	SharedFile  string
-	SharedRepo  string
-	QuantTokens []string
-}
-
-// Proposal is one variant target offered to one parent.
-type Proposal struct {
-	Variant  string
-	Evidence Evidence
-}
-
-// Family is a complete proposal: one parent gaining one or more variants.
-type Family struct {
-	Parent    string
-	Proposals []Proposal
-}
-
-// Refusal is a family the heuristics found but the rules would not let through.
-// Refusals are reported rather than dropped: a candidate the job keeps refusing
-// is either a rule worth revisiting or a gallery bug worth fixing.
-type Refusal struct {
-	Members []string
-	Reason  string
-}
-
-// Result is one run of the proposer.
-type Result struct {
-	Families     []Family
-	Refusals     []Refusal
-	Suppressed   []Suppression
-	AliasSkipped []Suppression
-}
-
-// HasProposals reports whether the run found anything to open a pull request
-// about. A job that opens an empty pull request every night is a job people
-// filter out of their inbox.
-func (r *Result) HasProposals() bool {
-	return len(r.Families) > 0
-}
-
-// sizeToken matches a parameter-count marker: 8b, 1.7b, a3b for an active
-// expert count, e2b for the Gemma effective sizes, 8x7b for a mixture.
-//
-// This is a structural rule rather than a ledger entry because it is about the
-// shape of the token, not about any one model. Different parameter sizes were
-// mis-grouped by an earlier sweep and the failure is systematic.
-var sizeToken = regexp.MustCompile(`^(?:[0-9]+(?:\.[0-9]+)?[bm]|[ae][0-9]+(?:\.[0-9]+)?b|[0-9]+x[0-9]+(?:\.[0-9]+)?b)$`)
-
-func differsByParameterSize(a, b string) (string, bool) {
-	for seg := range differingSegments(a, b) {
-		if sizeToken.MatchString(seg) {
-			return seg, true
-		}
-	}
-	return "", false
-}
-
-// genericFileStem lists weight filenames too generic to be evidence of
-// anything. Two entries both shipping "model.safetensors" share a convention,
-// not a set of weights.
-var genericFileStem = map[string]struct{}{
-	"model": {}, "weights": {}, "pytorch_model": {}, "diffusion_pytorch_model": {},
-	"consolidated": {}, "ggml-model": {}, "model-00001-of-00002": {},
-}
-
-// minFileStemLength keeps short, collision-prone filename stems from linking
-// unrelated entries.
-const minFileStemLength = 6
-
-type pair struct {
-	a, b     int
-	evidence Evidence
-}
-
-// Propose runs the grouping heuristics over a gallery index and returns what it
-// would offer a human, what it refused, and what the ledger silenced.
-//
-// Nothing here touches the network or git, and the index is not modified.
-func Propose(ix *Index, ledger *Ledger) *Result {
-	if ledger == nil {
-		ledger = &Ledger{}
-	}
-	result := &Result{}
-
-	byName, dupes := ix.ByName()
-
-	// Existing relationships. A target already claimed must not be claimed
-	// again, and two entries already in one family need no proposal.
-	claimedBy := map[string]string{}
-	familyOf := map[string]string{}
-	for _, e := range ix.Entries {
-		if !e.HasVariants() {
-			continue
-		}
-		familyOf[strings.ToLower(e.Name)] = strings.ToLower(e.Name)
-		for _, v := range e.Variants {
-			target := strings.ToLower(v.Model)
-			if _, taken := claimedBy[target]; !taken {
-				claimedBy[target] = strings.ToLower(e.Name)
-			}
-			familyOf[target] = strings.ToLower(e.Name)
-		}
-	}
-
-	candidates := map[[2]int]*Evidence{}
-
-	addPair := func(i, j int, sig Signal, apply func(*Evidence)) {
-		if i == j {
-			return
-		}
-		if i > j {
-			i, j = j, i
-		}
-		key := [2]int{i, j}
-		ev, ok := candidates[key]
-		if !ok {
-			ev = &Evidence{}
-			candidates[key] = ev
-		}
-		for _, s := range ev.Signals {
-			if s == sig {
-				apply(ev)
-				return
-			}
-		}
-		ev.Signals = append(ev.Signals, sig)
-		apply(ev)
-	}
-
-	// Signal 1 and 2: entries sharing a name stem.
-	byStem := map[string][]int{}
-	for _, e := range ix.Entries {
-		if e.Name == "" {
-			continue
-		}
-		byStem[NameStem(e.Name)] = append(byStem[NameStem(e.Name)], e.Index)
-	}
-	for stem, members := range byStem {
-		if len(members) < 2 {
-			continue
-		}
-		for i := 0; i < len(members); i++ {
-			for j := i + 1; j < len(members); j++ {
-				a, b := ix.Entries[members[i]], ix.Entries[members[j]]
-				sig := SignalName
-				if HasConfigSuffix(a.Name) || HasConfigSuffix(b.Name) {
-					sig = SignalConfigSuffix
-				}
-				// The bare parent carries no marker in its name, so the
-				// evidence would read "differs by q8_0" and say nothing about
-				// what the parent is. The weight filenames fill that in.
-				fa, _ := a.PrimaryWeightFile()
-				fb, _ := b.PrimaryWeightFile()
-				addPair(members[i], members[j], sig, func(ev *Evidence) {
-					ev.SharedStem = stem
-					ev.QuantTokens = quantDifference(a.Name, b.Name, fa, fb)
-				})
-			}
-		}
-	}
-
-	// Signal 3: entries whose own weight file is the same file at a different
-	// quantization. Auxiliary files never take part.
-	byFile := map[string][]int{}
-	for _, e := range ix.Entries {
-		primary, ok := e.PrimaryWeightFile()
-		if !ok {
-			continue
-		}
-		stem := FileStem(primary)
-		if len(stem) < minFileStemLength {
-			continue
-		}
-		if _, generic := genericFileStem[stem]; generic {
-			continue
-		}
-		byFile[stem] = append(byFile[stem], e.Index)
-	}
-	for stem, members := range byFile {
-		if len(members) < 2 {
-			continue
-		}
-		for i := 0; i < len(members); i++ {
-			for j := i + 1; j < len(members); j++ {
-				a, b := ix.Entries[members[i]], ix.Entries[members[j]]
-				// The filename alone is not evidence. Publishers reuse the
-				// upstream filename for finetunes and for models that merely
-				// embed the base weights: bert-embeddings, an ultravox audio
-				// model and a roleplay finetune all ship a file called
-				// llama-3.2-1b-instruct-q4_k_m.gguf. Requiring the same
-				// upstream repository turns the signal back into what it
-				// claims to be, one repo publishing one file at two
-				// quantizations. Two repos holding the same weights is a fact
-				// no filename proves, so it stays a human call.
-				repo := a.SourceRepo()
-				if repo == "" || repo != b.SourceRepo() {
-					continue
-				}
-				fa, _ := a.PrimaryWeightFile()
-				fb, _ := b.PrimaryWeightFile()
-				addPair(members[i], members[j], SignalWeightFile, func(ev *Evidence) {
-					ev.SharedFile = stem
-					ev.SharedRepo = repo
-					if len(ev.QuantTokens) == 0 {
-						ev.QuantTokens = quantDifference(fa, fb)
-					}
-				})
-			}
-		}
-	}
-
-	// Filter candidates. Everything dropped here is dropped for a reason a
-	// reviewer can read back off the ledger or the rules.
-	var kept []pair
-	for key, ev := range candidates {
-		a, b := ix.Entries[key[0]], ix.Entries[key[1]]
-		la, lb := strings.ToLower(a.Name), strings.ToLower(b.Name)
-		if la == lb {
-			continue
-		}
-		if dupes[la] > 0 || dupes[lb] > 0 {
-			result.Refusals = append(result.Refusals, Refusal{
-				Members: []string{a.Name, b.Name},
-				Reason:  "one of these names appears more than once in the gallery, so a variant reference to it is ambiguous",
-			})
-			continue
-		}
-		if fa, fb := familyOf[la], familyOf[lb]; fa != "" && fa == fb {
-			continue
-		}
-		if seg, differs := differsByParameterSize(la, lb); differs {
-			result.Suppressed = append(result.Suppressed, Suppression{
-				A: a.Name, B: b.Name, Reason: fmt.Sprintf("different parameter sizes (segment %q)", seg),
-			})
-			continue
-		}
-		if s, ok := ledger.Suppresses(a.Name, b.Name); ok {
-			result.Suppressed = append(result.Suppressed, s)
-			continue
-		}
-		if SameInstallPayload(a, b) {
-			result.AliasSkipped = append(result.AliasSkipped, Suppression{
-				A: a.Name, B: b.Name,
-				Reason: "identical install payload; these are aliases of one build, not alternative builds",
-			})
-			continue
-		}
-		kept = append(kept, pair{a: key[0], b: key[1], evidence: *ev})
-	}
-
-	sort.Slice(kept, func(i, j int) bool {
-		if kept[i].a != kept[j].a {
-			return kept[i].a < kept[j].a
-		}
-		return kept[i].b < kept[j].b
-	})
-
-	// Components. A pair from either signal joins the same family, so a chain
-	// of alternative builds discovered by different signals stays one family
-	// rather than two overlapping ones that would double claim a target.
-	parent := map[int]int{}
-	var find func(int) int
-	find = func(x int) int {
-		if p, ok := parent[x]; ok && p != x {
-			parent[x] = find(p)
-			return parent[x]
-		}
-		if _, ok := parent[x]; !ok {
-			parent[x] = x
-		}
-		return parent[x]
-	}
-	union := func(x, y int) {
-		rx, ry := find(x), find(y)
-		if rx != ry {
-			parent[ry] = rx
-		}
-	}
-	evidenceFor := map[[2]int]Evidence{}
-	for _, p := range kept {
-		union(p.a, p.b)
-		evidenceFor[[2]int{p.a, p.b}] = p.evidence
-	}
-
-	components := map[int][]int{}
-	for _, p := range kept {
-		for _, m := range []int{p.a, p.b} {
-			root := find(m)
-			if !contains(components[root], m) {
-				components[root] = append(components[root], m)
-			}
-		}
-	}
-
-	roots := make([]int, 0, len(components))
-	for r := range components {
-		roots = append(roots, r)
-	}
-	sort.Ints(roots)
-
-	proposedTargets := map[string]string{}
-	for _, root := range roots {
-		members := components[root]
-		sort.Ints(members)
-		family, refusal := buildFamily(ix, members, evidenceFor, claimedBy, proposedTargets, byName)
-		if refusal != nil {
-			result.Refusals = append(result.Refusals, *refusal)
-			continue
-		}
-		if family == nil {
-			continue
-		}
-		for _, p := range family.Proposals {
-			proposedTargets[strings.ToLower(p.Variant)] = family.Parent
-		}
-		result.Families = append(result.Families, *family)
-	}
-
-	sort.Slice(result.Families, func(i, j int) bool { return result.Families[i].Parent < result.Families[j].Parent })
-	result.Suppressed = SortedSuppressions(result.Suppressed)
-	result.AliasSkipped = SortedSuppressions(result.AliasSkipped)
-	result.Refusals = dedupeRefusals(result.Refusals)
-	return result
-}
-
-// dedupeRefusals collapses the same refusal reached from both orderings of a
-// pair, and sorts what is left. A reviewer reading the same complaint twice
-// learns to skim the section.
-func dedupeRefusals(in []Refusal) []Refusal {
-	seen := map[string]struct{}{}
-	var out []Refusal
-	for _, r := range in {
-		members := append([]string(nil), r.Members...)
-		sort.Strings(members)
-		key := strings.Join(members, "\x00") + "\x00" + r.Reason
-		if _, dup := seen[key]; dup {
-			continue
-		}
-		seen[key] = struct{}{}
-		out = append(out, r)
-	}
-	sort.Slice(out, func(i, j int) bool {
-		if a, b := strings.Join(out[i].Members, ","), strings.Join(out[j].Members, ","); a != b {
-			return a < b
-		}
-		return out[i].Reason < out[j].Reason
-	})
-	return out
-}
-
-func contains(xs []int, x int) bool {
-	for _, v := range xs {
-		if v == x {
-			return true
-		}
-	}
-	return false
-}
-
-// buildFamily turns a connected component into a proposal, or refuses it.
-func buildFamily(ix *Index, members []int, evidenceFor map[[2]int]Evidence, claimedBy map[string]string, proposedTargets map[string]string, byName map[string]*GalleryEntry) (*Family, *Refusal) {
-	names := make([]string, 0, len(members))
-	for _, m := range members {
-		names = append(names, ix.Entries[m].Name)
-	}
-
-	parentIdx, err := selectParent(ix, members)
-	if err != nil {
-		return nil, &Refusal{Members: names, Reason: err.Error()}
-	}
-	parentEntry := ix.Entries[parentIdx]
-	parentName := strings.ToLower(parentEntry.Name)
-
-	// A parent that is itself somebody's variant would create a chain, which
-	// the gallery's own resolution refuses to install.
-	if owner, claimed := claimedBy[parentName]; claimed {
-		return nil, &Refusal{Members: names, Reason: fmt.Sprintf("the natural parent %q is already a variant of %q; proposing it as a parent would nest variants", parentEntry.Name, owner)}
-	}
-	if owner, claimed := proposedTargets[parentName]; claimed {
-		return nil, &Refusal{Members: names, Reason: fmt.Sprintf("the natural parent %q is already proposed as a variant of %q; proposing it as a parent would nest variants", parentEntry.Name, owner)}
-	}
-
-	// Adding a variants key to an anchor is inherited by every entry that
-	// merges it, silently grouping models nobody proposed. Handling that means
-	// editing each merging child too, which is a larger change than this job
-	// should make unsupervised, so it refuses and hands the reviewer the list.
-	if parentEntry.AnchorName != "" {
-		children := ix.MergeChildren(parentEntry.AnchorName)
-		if len(children) > 0 {
-			childNames := make([]string, 0, len(children))
-			for _, c := range children {
-				childNames = append(childNames, c.Name)
-			}
-			return nil, &Refusal{
-				Members: names,
-				Reason: fmt.Sprintf("the parent %q defines YAML anchor &%s, and a variants key added there is inherited by the %d entries that merge it (%s). Grouping this family by hand also means adding an explicit `variants: []` to each of those entries",
-					parentEntry.Name, parentEntry.AnchorName, len(children), strings.Join(childNames, ", ")),
-			}
-		}
-	}
-
-	existing := map[string]struct{}{}
-	for _, v := range parentEntry.Variants {
-		existing[strings.ToLower(v.Model)] = struct{}{}
-	}
-
-	family := &Family{Parent: parentEntry.Name}
-	for _, m := range members {
-		if m == parentIdx {
-			continue
-		}
-		target := ix.Entries[m]
-		lower := strings.ToLower(target.Name)
-		if _, already := existing[lower]; already {
-			continue
-		}
-		if target.HasVariants() {
-			return nil, &Refusal{Members: names, Reason: fmt.Sprintf("%q already offers variants of its own, so it cannot itself be a variant target", target.Name)}
-		}
-		if !target.Installable() {
-			return nil, &Refusal{Members: names, Reason: fmt.Sprintf("%q has no url, config_file, overrides or files, so it is not independently installable", target.Name)}
-		}
-		if owner, claimed := claimedBy[lower]; claimed && owner != parentName {
-			return nil, &Refusal{Members: names, Reason: fmt.Sprintf("%q is already a variant of %q; a target claimed by two parents is not something the gallery resolves predictably", target.Name, owner)}
-		}
-		if owner, claimed := proposedTargets[lower]; claimed && owner != parentEntry.Name {
-			return nil, &Refusal{Members: names, Reason: fmt.Sprintf("%q is already proposed as a variant of %q in this same run", target.Name, owner)}
-		}
-		family.Proposals = append(family.Proposals, Proposal{
-			Variant:  target.Name,
-			Evidence: lookupEvidence(evidenceFor, parentIdx, m),
-		})
-	}
-
-	if len(family.Proposals) == 0 {
-		return nil, nil
-	}
-	sort.Slice(family.Proposals, func(i, j int) bool { return family.Proposals[i].Variant < family.Proposals[j].Variant })
-	return family, nil
-}
-
-func lookupEvidence(evidenceFor map[[2]int]Evidence, a, b int) Evidence {
-	if a > b {
-		a, b = b, a
-	}
-	if ev, ok := evidenceFor[[2]int{a, b}]; ok {
-		return ev
-	}
-	// The two entries reached the same family through a third one. Say so
-	// rather than inventing evidence that was never observed for this pair.
-	return Evidence{Signals: []Signal{SignalName}}
-}
-
-// selectParent picks the entry the others should hang off.
-//
-// The bare name wins when there is one: it is the name a user types and the one
-// documentation links to. Otherwise the smallest build wins, judged by the
-// quantization token in the entry's own weight filename, so the default install
-// is the one most hosts can actually run.
-func selectParent(ix *Index, members []int) (int, error) {
-	// The family's own stem: the one the most members reduce to, shortest name
-	// breaking a tie. An entry named exactly that is the bare entry.
-	stemCount := map[string]int{}
-	for _, m := range members {
-		stemCount[NameStem(ix.Entries[m].Name)]++
-	}
-	// Only a stem two or more members reduce to is the family's own stem. A
-	// stem reached by exactly one member is just that member's name, and
-	// treating it as the family stem would crown whichever name happens to be
-	// shortest rather than whichever build is the base one.
-	familyStem := ""
-	for stem, n := range stemCount {
-		if n < 2 {
-			continue
-		}
-		if familyStem == "" || n > stemCount[familyStem] ||
-			(n == stemCount[familyStem] && len(stem) < len(familyStem)) ||
-			(n == stemCount[familyStem] && len(stem) == len(familyStem) && stem < familyStem) {
-			familyStem = stem
-		}
-	}
-
-	var bare []int
-	for _, m := range members {
-		e := ix.Entries[m]
-		if HasConfigSuffix(e.Name) {
-			continue
-		}
-		if strings.ToLower(e.Name) == familyStem {
-			bare = append(bare, m)
-		}
-	}
-	if len(bare) == 1 {
-		return bare[0], nil
-	}
-	if len(bare) > 1 {
-		names := make([]string, 0, len(bare))
-		for _, m := range bare {
-			names = append(names, ix.Entries[m].Name)
-		}
-		return 0, fmt.Errorf("more than one entry is named exactly %q (%s), so which one is the base build is a judgement this job will not make", familyStem, strings.Join(names, ", "))
-	}
-
-	// No shared stem to be named after. An entry whose name every other member
-	// extends is still recognisably the base one, and this is the only handle
-	// left for families whose weights carry no readable quantization token at
-	// all, such as the ONNX builds.
-	if prefix, ok := uniquePrefixMember(ix, members); ok {
-		return prefix, nil
-	}
-
-	best := -1
-	bestWidth := 1 << 20
-	for _, m := range members {
-		e := ix.Entries[m]
-		width := unknownWidth
-		if primary, ok := e.PrimaryWeightFile(); ok {
-			width = BuildWidth(primary)
-		}
-		// Members are visited in gallery order, so a strict comparison leaves
-		// the earliest entry holding a tie and the choice is deterministic.
-		if width < bestWidth {
-			best, bestWidth = m, width
-		}
-	}
-	if best < 0 {
-		return 0, fmt.Errorf("no member could be identified as the smallest build")
-	}
-	if bestWidth == unknownWidth {
-		names := make([]string, 0, len(members))
-		for _, m := range members {
-			names = append(names, ix.Entries[m].Name)
-		}
-		return 0, fmt.Errorf("no member declares a weight file whose quantization can be read (%s), so the smallest build cannot be identified", strings.Join(names, ", "))
-	}
-	return best, nil
-}
-
-// uniquePrefixMember reports the single member whose name every other member's
-// name starts with, if there is exactly one.
-func uniquePrefixMember(ix *Index, members []int) (int, bool) {
-	found := -1
-	for _, m := range members {
-		name := strings.ToLower(ix.Entries[m].Name)
-		isPrefix := true
-		for _, other := range members {
-			if other == m {
-				continue
-			}
-			if !strings.HasPrefix(strings.ToLower(ix.Entries[other].Name), name) {
-				isPrefix = false
-				break
-			}
-		}
-		if !isPrefix {
-			continue
-		}
-		if found >= 0 {
-			return 0, false
-		}
-		found = m
-	}
-	return found, found >= 0
-}
-
-// quantDifference lists the quantization tokens that tell two names apart. It
-// is the compact form of the evidence: "these differ only by q4_k_m vs q8_0".
-func quantDifference(names ...string) []string {
-	var out []string
-	seen := map[string]struct{}{}
-	for _, name := range names {
-		// Filenames arrive here too, so the extension goes first and "/" counts
-		// as a separator. "_" deliberately does not: it holds "q4_k_m" together.
-		trimmed := weightExtension.ReplaceAllString(name, "")
-		for _, seg := range strings.FieldsFunc(strings.ToLower(trimmed), func(r rune) bool { return r == '-' || r == '/' }) {
-			if !IsQuantToken(seg) {
-				continue
-			}
-			if _, ok := seen[seg]; ok {
-				continue
-			}
-			seen[seg] = struct{}{}
-			out = append(out, seg)
-		}
-	}
-	sort.Strings(out)
-	return out
-}

.github/ci/variantproposals/propose_test.go

@@ -1,429 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"strings"
-
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-// entryYAML writes one gallery entry with a single weight file, which is the
-// shape almost every real entry has. Specs that need something else write the
-// YAML out by hand.
-func entryYAML(name, repo, filename, sha string) string {
-	return fmt.Sprintf(`- name: %s
-  url: github:mudler/LocalAI/gallery/virtual.yaml@master
-  overrides:
-    parameters:
-      model: %s
-  files:
-    - filename: %s
-      uri: huggingface://%s/%s
-      sha256: %s
-`, name, filename, filename, repo, filename, sha)
-}
-
-func indexOf(entries ...string) *Index {
-	ix, err := ParseIndex(strings.Join(entries, ""))
-	ExpectWithOffset(1, err).ToNot(HaveOccurred())
-	return ix
-}
-
-// familyNames flattens a result into "parent <- variant, variant" strings, the
-// form the specs assert against.
-func familyNames(r *Result) []string {
-	out := make([]string, 0, len(r.Families))
-	for _, f := range r.Families {
-		names := make([]string, 0, len(f.Proposals))
-		for _, p := range f.Proposals {
-			names = append(names, p.Variant)
-		}
-		out = append(out, f.Parent+" <- "+strings.Join(names, ", "))
-	}
-	return out
-}
-
-func refusalReasons(r *Result) string {
-	var b strings.Builder
-	for _, ref := range r.Refusals {
-		b.WriteString(strings.Join(ref.Members, " + ") + ": " + ref.Reason + "\n")
-	}
-	return b.String()
-}
-
-func suppressionReasons(r *Result) string {
-	var b strings.Builder
-	for _, s := range r.Suppressed {
-		b.WriteString(s.String() + "\n")
-	}
-	return b.String()
-}
-
-var _ = Describe("Propose", func() {
-	Describe("the grouping signals", func() {
-		It("groups entries whose names differ only by a quantization marker", func() {
-			ix := indexOf(
-				entryYAML("foo-model", "acme/foo-GGUF", "foo-model-Q4_K_M.gguf", "aa"),
-				entryYAML("foo-model-q8_0", "acme/foo-GGUF", "foo-model-Q8_0.gguf", "bb"),
-			)
-			r := Propose(ix, nil)
-			Expect(familyNames(r)).To(ConsistOf("foo-model <- foo-model-q8_0"))
-			Expect(r.Families[0].Proposals[0].Evidence.Signals).To(ContainElement(SignalName))
-			Expect(r.Families[0].Proposals[0].Evidence.SharedStem).To(Equal("foo-model"))
-			Expect(r.Families[0].Proposals[0].Evidence.QuantTokens).To(ContainElements("q4_k_m", "q8_0"))
-		})
-
-		It("groups entries that use the colon config-suffix convention", func() {
-			ix := indexOf(
-				entryYAML("bar-model", "acme/bar-GGUF", "bar-model-Q4_K_M.gguf", "aa"),
-				entryYAML("bar-model:grammar-functioncall", "acme/bar-GGUF", "bar-model-Q4_K_M-grammar.gguf", "bb"),
-			)
-			r := Propose(ix, nil)
-			Expect(familyNames(r)).To(ConsistOf("bar-model <- bar-model:grammar-functioncall"))
-			Expect(r.Families[0].Proposals[0].Evidence.Signals).To(ContainElement(SignalConfigSuffix))
-		})
-
-		It("groups entries whose own weight file is the same file at another quantization", func() {
-			// The names share no stem, so only the filename signal can link
-			// these two.
-			ix := indexOf(
-				entryYAML("omni-cpp", "Serveurperso/Omni-GGUF", "omnivoice-base-Q8_0.gguf", "aa"),
-				entryYAML("omni-cpp-hq", "Serveurperso/Omni-GGUF", "omnivoice-base-BF16.gguf", "bb"),
-			)
-			r := Propose(ix, nil)
-			Expect(familyNames(r)).To(ConsistOf("omni-cpp <- omni-cpp-hq"))
-			ev := r.Families[0].Proposals[0].Evidence
-			Expect(ev.Signals).To(ConsistOf(SignalWeightFile))
-			Expect(ev.SharedFile).To(Equal("omnivoice-base"))
-			Expect(ev.SharedRepo).To(Equal("serveurperso/omni-gguf"))
-		})
-
-		It("does not let a shared auxiliary file link unrelated models", func() {
-			// Both entries ship the same text encoder. That is a packaging
-			// convention, not evidence of shared weights: this is how an
-			// earlier sweep linked four wan-2.1 entries to each other.
-			ix := indexOf(`- name: wan-2.1-t2v
-  url: u
-  files:
-    - filename: wan-2.1-t2v-Q4_K_M.gguf
-      uri: huggingface://acme/wan/wan-2.1-t2v-Q4_K_M.gguf
-      sha256: aa
-    - filename: umt5-xxl-encoder-Q8_0.gguf
-      uri: huggingface://acme/wan/umt5-xxl-encoder-Q8_0.gguf
-      sha256: cc
-`, `- name: z-image-turbo
-  url: u
-  files:
-    - filename: z-image-turbo-Q4_K_M.gguf
-      uri: huggingface://acme/wan/z-image-turbo-Q4_K_M.gguf
-      sha256: bb
-    - filename: umt5-xxl-encoder-Q8_0.gguf
-      uri: huggingface://acme/wan/umt5-xxl-encoder-Q8_0.gguf
-      sha256: cc
-`)
-			r := Propose(ix, nil)
-			Expect(familyNames(r)).To(BeEmpty())
-		})
-
-		It("does not treat a shared filename in two different repos as evidence", func() {
-			// A finetune republished under the base model's filename is the
-			// most common way this signal misfires.
-			ix := indexOf(
-				entryYAML("llama-3.2-3b-instruct", "hugging-quants/Llama-3.2-3B-Instruct-GGUF", "llama-3.2-3b-instruct-q4_k_m.gguf", "aa"),
-				entryYAML("llama-3.2-3b-shiro-roleplay", "someone/Shiro-GGUF", "Llama-3.2-3B-Instruct.Q8_0.gguf", "bb"),
-			)
-			r := Propose(ix, nil)
-			Expect(familyNames(r)).To(BeEmpty())
-		})
-	})
-
-	Describe("what must never be proposed", func() {
-		It("does not group different parameter sizes that share a prefix", func() {
-			ix := indexOf(
-				entryYAML("qwen3-tts-cpp-0.6b-base", "Serveurperso/Qwen3-TTS-GGUF", "qwen3-tts-talker-Q4_K_M.gguf", "aa"),
-				entryYAML("qwen3-tts-cpp-1.7b-base", "Serveurperso/Qwen3-TTS-GGUF", "qwen3-tts-talker-Q8_0.gguf", "bb"),
-			)
-			r := Propose(ix, nil)
-			Expect(familyNames(r)).To(BeEmpty())
-			Expect(suppressionReasons(r)).To(ContainSubstring("different parameter sizes"))
-		})
-
-		It("does not group the Gemma effective sizes", func() {
-			ix := indexOf(
-				entryYAML("gemma-4-e2b-it", "google/gemma-GGUF", "gemma-4-it-Q4_K_M.gguf", "aa"),
-				entryYAML("gemma-4-e4b-it", "google/gemma-GGUF", "gemma-4-it-Q8_0.gguf", "bb"),
-			)
-			r := Propose(ix, nil)
-			Expect(familyNames(r)).To(BeEmpty())
-			Expect(suppressionReasons(r)).To(ContainSubstring("different parameter sizes"))
-		})
-
-		It("does not group entries with a byte-identical install payload", func() {
-			// whisper-1 exists so OpenAI-compatible clients can send that name.
-			// Folding it under whisper-base would hide the name they send.
-			payload := `  url: github:mudler/LocalAI/gallery/whisper-base.yaml@master
-  overrides:
-    parameters:
-      model: ggml-whisper-base.bin
-  files:
-    - filename: ggml-whisper-base.bin
-      uri: huggingface://ggerganov/whisper.cpp/ggml-base.bin
-      sha256: aa
-`
-			ix := indexOf("- name: whisper-base\n"+payload, "- name: whisper-1\n"+payload)
-			r := Propose(ix, nil)
-			Expect(familyNames(r)).To(BeEmpty())
-			Expect(r.AliasSkipped).To(HaveLen(1))
-			Expect(r.AliasSkipped[0].Reason).To(ContainSubstring("aliases"))
-		})
-
-		DescribeTable("declines the categories the ledger records",
-			func(nameA, nameB string, ledgerYAML string) {
-				ix := indexOf(
-					entryYAML(nameA, "acme/repo", "shared-weights-Q4_K_M.gguf", "aa"),
-					entryYAML(nameB, "acme/repo", "shared-weights-Q8_0.gguf", "bb"),
-				)
-				ledger, err := ParseLedger([]byte(ledgerYAML))
-				Expect(err).ToNot(HaveOccurred())
-
-				// Without the ledger these would be proposed, which is what
-				// makes the ledger load bearing rather than decorative.
-				Expect(familyNames(Propose(ix, nil))).ToNot(BeEmpty())
-
-				r := Propose(ix, ledger)
-				Expect(familyNames(r)).To(BeEmpty())
-				Expect(r.Suppressed).To(HaveLen(1))
-			},
-			Entry("a finetune", "base-model", "base-model-abliterated",
-				"tokens:\n  - {token: abliterated, reason: finetune}\n"),
-			Entry("a distill", "base-model", "base-model-distilled",
-				"tokens:\n  - {token: distilled, reason: distilled}\n"),
-			Entry("English-only versus multilingual ASR", "whisper-small", "whisper-small-en",
-				"pairs:\n  - {parent: whisper-small, variant: whisper-small-en, reason: English-only versus multilingual}\n"),
-			Entry("two products sharing a prefix", "vibevoice-cpp", "vibevoice-cpp-asr",
-				"pairs:\n  - {parent: vibevoice-cpp, variant: vibevoice-cpp-asr, reason: different products}\n"),
-			Entry("a per-language release", "kokoros-de", "kokoros-ja",
-				"groups:\n  - {members: [kokoros, kokoros-de, kokoros-ja], reason: different languages}\n"),
-		)
-
-		It("reports the ledger's reason so its effect stays visible", func() {
-			ix := indexOf(
-				entryYAML("base-model", "acme/repo", "shared-weights-Q4_K_M.gguf", "aa"),
-				entryYAML("base-model-heretic", "acme/repo", "shared-weights-Q8_0.gguf", "bb"),
-			)
-			ledger, err := ParseLedger([]byte("tokens:\n  - {token: heretic, reason: \"finetune, not a re-quantization\"}\n"))
-			Expect(err).ToNot(HaveOccurred())
-			r := Propose(ix, ledger)
-			Expect(suppressionReasons(r)).To(ContainSubstring("finetune, not a re-quantization"))
-			Expect(suppressionReasons(r)).To(ContainSubstring(`token "heretic"`))
-		})
-	})
-
-	Describe("parent selection", func() {
-		It("picks the bare-named entry when one exists", func() {
-			ix := indexOf(
-				entryYAML("base-model-q8_0", "acme/repo", "base-model-Q8_0.gguf", "aa"),
-				entryYAML("base-model", "acme/repo", "base-model-Q4_K_M.gguf", "bb"),
-				entryYAML("base-model-f16", "acme/repo", "base-model-f16.gguf", "cc"),
-			)
-			r := Propose(ix, nil)
-			Expect(familyNames(r)).To(ConsistOf("base-model <- base-model-f16, base-model-q8_0"))
-		})
-
-		It("picks the smallest build when no entry is bare-named", func() {
-			ix := indexOf(
-				entryYAML("ced-base-f16", "acme/repo", "ced-base-f16.gguf", "aa"),
-				entryYAML("ced-base-q8", "acme/repo", "ced-base-Q8_0.gguf", "bb"),
-			)
-			r := Propose(ix, nil)
-			Expect(familyNames(r)).To(ConsistOf("ced-base-q8 <- ced-base-f16"))
-		})
-
-		It("judges the smallest build by the quantization in the model filename, not the name", func() {
-			// The names carry no marker at all; only the filenames say which
-			// build is which.
-			ix := indexOf(
-				entryYAML("thing-hq", "acme/repo", "thing-weights-BF16.gguf", "aa"),
-				entryYAML("thing-lite", "acme/repo", "thing-weights-Q4_K_M.gguf", "bb"),
-			)
-			r := Propose(ix, nil)
-			Expect(familyNames(r)).To(ConsistOf("thing-lite <- thing-hq"))
-		})
-	})
-
-	Describe("the rules a proposal has to respect", func() {
-		It("refuses to nest: a target that already offers variants of its own", func() {
-			ix := indexOf(
-				entryYAML("nest-model", "acme/repo", "nest-model-Q4_K_M.gguf", "aa"),
-				`- name: nest-model-q8_0
-  url: u
-  variants:
-    - model: nest-model-q8_0-mtp
-  overrides:
-    parameters:
-      model: nest-model-Q8_0.gguf
-  files:
-    - filename: nest-model-Q8_0.gguf
-      uri: huggingface://acme/repo/nest-model-Q8_0.gguf
-      sha256: bb
-`,
-				entryYAML("nest-model-q8_0-mtp", "other/repo", "nest-model-mtp.gguf", "cc"),
-			)
-			r := Propose(ix, nil)
-			Expect(familyNames(r)).To(BeEmpty())
-			Expect(refusalReasons(r)).To(ContainSubstring("already offers variants of its own"))
-		})
-
-		It("refuses to nest: a parent that is already somebody else's variant", func() {
-			ix := indexOf(
-				`- name: outer
-  url: u
-  variants:
-    - model: middle
-  overrides:
-    parameters:
-      model: outer-Q4_K_M.gguf
-  files:
-    - filename: outer-Q4_K_M.gguf
-      uri: huggingface://acme/repo/outer-Q4_K_M.gguf
-      sha256: aa
-`,
-				entryYAML("middle", "acme/other", "middle-Q4_K_M.gguf", "bb"),
-				entryYAML("middle-q8_0", "acme/other", "middle-Q8_0.gguf", "cc"),
-			)
-			r := Propose(ix, nil)
-			Expect(familyNames(r)).To(BeEmpty())
-			Expect(refusalReasons(r)).To(ContainSubstring("would nest variants"))
-		})
-
-		It("refuses to let two parents claim one target", func() {
-			ix := indexOf(
-				`- name: claimant
-  url: u
-  variants:
-    - model: contested-q8_0
-  overrides:
-    parameters:
-      model: claimant-Q4_K_M.gguf
-  files:
-    - filename: claimant-Q4_K_M.gguf
-      uri: huggingface://acme/repo/claimant-Q4_K_M.gguf
-      sha256: aa
-`,
-				entryYAML("contested", "acme/other", "contested-Q4_K_M.gguf", "bb"),
-				entryYAML("contested-q8_0", "acme/other", "contested-Q8_0.gguf", "cc"),
-			)
-			r := Propose(ix, nil)
-			Expect(familyNames(r)).To(BeEmpty())
-			Expect(refusalReasons(r)).To(ContainSubstring("already a variant of"))
-		})
-
-		It("refuses a target that is not independently installable", func() {
-			ix := indexOf(
-				entryYAML("stub-model", "acme/repo", "stub-model-Q4_K_M.gguf", "aa"),
-				"- name: stub-model-q8_0\n  description: a stanza nobody finished\n",
-			)
-			r := Propose(ix, nil)
-			Expect(familyNames(r)).To(BeEmpty())
-			Expect(refusalReasons(r)).To(ContainSubstring("not independently installable"))
-		})
-
-		It("refuses a family whose parent defines a merge anchor, naming the entries that would inherit", func() {
-			ix := indexOf(
-				`- &anchored
-  name: anchored-model
-  url: u
-  overrides:
-    parameters:
-      model: anchored-Q4_K_M.gguf
-  files:
-    - filename: anchored-Q4_K_M.gguf
-      uri: huggingface://acme/repo/anchored-Q4_K_M.gguf
-      sha256: aa
-`,
-				`- !!merge <<: *anchored
-  name: anchored-child
-  variants: []
-  overrides:
-    parameters:
-      model: unrelated-child-Q4_K_M.gguf
-  files:
-    - filename: unrelated-child-Q4_K_M.gguf
-      uri: huggingface://other/repo/unrelated-child-Q4_K_M.gguf
-      sha256: cc
-`,
-				entryYAML("anchored-model-q8_0", "acme/repo", "anchored-Q8_0.gguf", "bb"),
-			)
-			r := Propose(ix, nil)
-			Expect(familyNames(r)).To(BeEmpty())
-			Expect(refusalReasons(r)).To(ContainSubstring("defines YAML anchor &anchored"))
-			Expect(refusalReasons(r)).To(ContainSubstring("anchored-child"))
-			Expect(refusalReasons(r)).To(ContainSubstring("variants: []"))
-		})
-
-		It("refuses an entry whose name is not unique in the gallery", func() {
-			ix := indexOf(
-				entryYAML("twin", "acme/repo", "twin-Q4_K_M.gguf", "aa"),
-				entryYAML("twin", "acme/repo", "twin-Q4_K_M.gguf", "aa"),
-				entryYAML("twin-q8_0", "acme/repo", "twin-Q8_0.gguf", "bb"),
-			)
-			r := Propose(ix, nil)
-			Expect(familyNames(r)).To(BeEmpty())
-			Expect(refusalReasons(r)).To(ContainSubstring("appears more than once"))
-		})
-
-		It("says nothing about a pair that is already grouped", func() {
-			ix := indexOf(
-				`- name: settled
-  url: u
-  variants:
-    - model: settled-q8_0
-  overrides:
-    parameters:
-      model: settled-Q4_K_M.gguf
-  files:
-    - filename: settled-Q4_K_M.gguf
-      uri: huggingface://acme/repo/settled-Q4_K_M.gguf
-      sha256: aa
-`,
-				entryYAML("settled-q8_0", "acme/repo", "settled-Q8_0.gguf", "bb"),
-			)
-			r := Propose(ix, nil)
-			Expect(r.HasProposals()).To(BeFalse())
-			Expect(r.Refusals).To(BeEmpty())
-			Expect(r.Suppressed).To(BeEmpty())
-		})
-
-		It("adds only the missing members to a family that already exists", func() {
-			ix := indexOf(
-				`- name: partial
-  url: u
-  variants:
-    - model: partial-q8_0
-  overrides:
-    parameters:
-      model: partial-Q4_K_M.gguf
-  files:
-    - filename: partial-Q4_K_M.gguf
-      uri: huggingface://acme/repo/partial-Q4_K_M.gguf
-      sha256: aa
-`,
-				entryYAML("partial-q8_0", "acme/repo", "partial-Q8_0.gguf", "bb"),
-				entryYAML("partial-f16", "acme/repo", "partial-f16.gguf", "cc"),
-			)
-			r := Propose(ix, nil)
-			Expect(familyNames(r)).To(ConsistOf("partial <- partial-f16"))
-		})
-	})
-
-	It("does not modify the index it was given", func() {
-		text := entryYAML("foo-model", "acme/foo-GGUF", "foo-model-Q4_K_M.gguf", "aa") +
-			entryYAML("foo-model-q8_0", "acme/foo-GGUF", "foo-model-Q8_0.gguf", "bb")
-		ix, err := ParseIndex(text)
-		Expect(err).ToNot(HaveOccurred())
-		before := strings.Join(ix.Lines, "\n")
-		Propose(ix, nil)
-		Expect(strings.Join(ix.Lines, "\n")).To(Equal(before))
-	})
-})

.github/ci/variantproposals/quant.go

@@ -1,151 +0,0 @@
-package main
-
-import (
-	"regexp"
-	"strconv"
-	"strings"
-)
-
-// Quantization and precision markers that distinguish one build of a set of
-// weights from another build of the same weights. Stripping them from a name
-// is what lets the proposer notice that two entries are the same model.
-//
-// qat and apex are in this list on a maintainer ruling: they are quantization
-// techniques applied to published weights, not separate weights. Names that use
-// "apex" to mean a finetune are handled by the rejection ledger instead, because
-// no amount of pattern matching can tell the two uses apart.
-const quantAlternation = `q[2-8](?:_[0-9a-z]+)*|pq[2-8](?:_[0-9a-z]+)*|iq[1-9][0-9a-z]*(?:_[0-9a-z]+)*|i1|` +
-	`f16|f32|bf16|fp16|fp32|fp8|fp4|nvfp4|mxfp4(?:_moe)*|awq|gptq|qat|apex|gguf|ggml|[0-9]+bit|g[0-9]+`
-
-// quantSegment matches a whole hyphen-delimited segment of an entry name.
-// Names separate their parts with "-" and keep quantization tokens internally
-// joined with "_", so a segment is the right unit here: "q4_k_m" arrives whole.
-var quantSegment = regexp.MustCompile(`^(?:` + quantAlternation + `)$`)
-
-// quantFileSuffix matches a trailing quantization token in a weight filename.
-// Filenames mix "-", "_" and "." as separators, so unlike entry names they
-// cannot be split into segments up front without tearing "Q4_K_M" apart.
-var quantFileSuffix = regexp.MustCompile(`(?i)[-_.](?:` + quantAlternation + `)$`)
-
-var weightExtension = regexp.MustCompile(`(?i)\.(gguf|ggml|safetensors|bin|pt|pth|onnx)$`)
-
-// IsQuantToken reports whether a single name segment is a quantization or
-// precision marker rather than part of the model's identity.
-func IsQuantToken(segment string) bool {
-	return quantSegment.MatchString(strings.ToLower(segment))
-}
-
-// NameStem reduces an entry name to the identity it shares with its alternative
-// builds: the config suffix after ":" is dropped, then trailing quantization
-// segments are stripped.
-//
-// It implements the first two grouping signals together because they answer the
-// same question. "foo:q8_0" and "foo-q8_0" are both alternative builds of "foo",
-// and the caller that needs to report which convention was used can compare the
-// name against the stem itself.
-//
-// At least one segment always survives, so a name made entirely of quantization
-// tokens does not collapse to the empty stem and swallow every other such name.
-func NameStem(name string) string {
-	base := strings.ToLower(strings.TrimSpace(name))
-	if i := strings.Index(base, ":"); i >= 0 {
-		base = base[:i]
-	}
-	segments := strings.Split(base, "-")
-	for len(segments) > 1 && quantSegment.MatchString(segments[len(segments)-1]) {
-		segments = segments[:len(segments)-1]
-	}
-	return strings.Join(segments, "-")
-}
-
-// HasConfigSuffix reports whether a name uses the ":" convention for naming a
-// config variant of another entry.
-func HasConfigSuffix(name string) bool {
-	return strings.Contains(name, ":")
-}
-
-// FileStem reduces a weight filename to the identity shared by its other
-// quantizations: directories, extension and trailing quantization tokens go.
-//
-// This is the third grouping signal. It is the one that has misfired before, so
-// callers must filter auxiliary files out before handing a filename here: a
-// shared text encoder is not evidence of shared weights.
-func FileStem(filename string) string {
-	base := filename
-	if i := strings.LastIndex(base, "/"); i >= 0 {
-		base = base[i+1:]
-	}
-	base = weightExtension.ReplaceAllString(base, "")
-	for {
-		stripped := quantFileSuffix.ReplaceAllString(base, "")
-		if stripped == base {
-			break
-		}
-		base = stripped
-	}
-	return strings.ToLower(base)
-}
-
-// bitsPerWeight ranks quantization tokens so the smallest build of a family can
-// be identified when no bare-named entry exists to be the parent.
-//
-// The figures are nominal bits per weight, not measured file sizes. Ranking is
-// all that is asked of them, and a nominal figure is available from the name
-// alone without downloading anything.
-func bitsPerWeight(token string) (int, bool) {
-	t := strings.ToLower(token)
-	switch {
-	case t == "i1":
-		return 1, true
-	case strings.HasPrefix(t, "nvfp4"), strings.HasPrefix(t, "mxfp4"), t == "fp4":
-		return 4, true
-	case t == "fp8":
-		return 8, true
-	case t == "f16", t == "bf16", t == "fp16":
-		return 16, true
-	case t == "f32", t == "fp32":
-		return 32, true
-	case t == "awq", t == "gptq":
-		return 4, true
-	}
-	if m := regexp.MustCompile(`^p?q([1-9])`).FindStringSubmatch(t); m != nil {
-		n, _ := strconv.Atoi(m[1])
-		return n, true
-	}
-	if m := regexp.MustCompile(`^iq([1-9])`).FindStringSubmatch(t); m != nil {
-		n, _ := strconv.Atoi(m[1])
-		return n, true
-	}
-	if m := regexp.MustCompile(`^([0-9]+)bit$`).FindStringSubmatch(t); m != nil {
-		n, _ := strconv.Atoi(m[1])
-		return n, true
-	}
-	return 0, false
-}
-
-// unknownWidth sorts after every recognised quantization so an entry whose
-// build cannot be read from its filename never wins the "smallest build" tie
-// break by accident.
-const unknownWidth = 1 << 10
-
-// BuildWidth reports the nominal bits per weight of the build a filename holds.
-// An unreadable filename gets unknownWidth.
-func BuildWidth(filename string) int {
-	base := filename
-	if i := strings.LastIndex(base, "/"); i >= 0 {
-		base = base[i+1:]
-	}
-	base = weightExtension.ReplaceAllString(base, "")
-	best := unknownWidth
-	for {
-		m := quantFileSuffix.FindString(base)
-		if m == "" {
-			break
-		}
-		if bits, ok := bitsPerWeight(m[1:]); ok && bits < best {
-			best = bits
-		}
-		base = base[:len(base)-len(m)]
-	}
-	return best
-}

.github/ci/variantproposals/quant_test.go

@@ -1,92 +0,0 @@
-package main
-
-import (
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("quantization markers", func() {
-	DescribeTable("NameStem strips the markers that distinguish builds, not models",
-		func(name, expected string) {
-			Expect(NameStem(name)).To(Equal(expected))
-		},
-		Entry("plain q4", "foo-model-q4_k_m", "foo-model"),
-		Entry("q8_0", "foo-model-q8_0", "foo-model"),
-		Entry("q5_1", "foo-model-q5_1", "foo-model"),
-		Entry("q2 with group size", "ternary-bonsai-8b-q2-g64", "ternary-bonsai-8b"),
-		Entry("iq variant", "ideogram-4-iq4nl-ggml", "ideogram-4"),
-		Entry("i1 imatrix", "orca-agent-v0.1-i1", "orca-agent-v0.1"),
-		Entry("f16", "ced-base-f16", "ced-base"),
-		Entry("bf16", "some-model-bf16", "some-model"),
-		Entry("fp8", "some-model-fp8", "some-model"),
-		Entry("nvfp4", "qwen3.6-27b-nvfp4", "qwen3.6-27b"),
-		Entry("mxfp4_moe", "huihui-qwen3-vl-30b-a3b-instruct-abliterated-mxfp4_moe", "huihui-qwen3-vl-30b-a3b-instruct-abliterated"),
-		Entry("pq2", "ternary-bonsai-8b-pq2", "ternary-bonsai-8b"),
-		Entry("awq", "some-model-awq", "some-model"),
-		Entry("gptq", "some-model-gptq", "some-model"),
-		Entry("Nbit", "qwen3-8b-mlx-4bit", "qwen3-8b-mlx"),
-		Entry("gguf", "some-model-gguf", "some-model"),
-		Entry("ggml", "flux.1-dev-ggml", "flux.1-dev"),
-		Entry("qat is a quantization technique", "gemma-3-27b-it-qat", "gemma-3-27b-it"),
-		Entry("apex is a quantization technique", "qwen3.6-35b-a3b-apex", "qwen3.6-35b-a3b"),
-		Entry("stacked markers", "gemma-4-e2b-it-qat-q4_0", "gemma-4-e2b-it"),
-		Entry("the config suffix is dropped", "phi-2-chat:Q8_0", "phi-2-chat"),
-		Entry("a non-quant config suffix is dropped too", "meta-llama-3.1-8b-instruct:grammar-functioncall", "meta-llama-3.1-8b-instruct"),
-	)
-
-	DescribeTable("NameStem leaves alone what identifies a different model",
-		func(name, expected string) {
-			Expect(NameStem(name)).To(Equal(expected))
-		},
-		Entry("parameter size", "qwen3-tts-cpp-0.6b-base", "qwen3-tts-cpp-0.6b-base"),
-		Entry("language suffix", "kokoros-de", "kokoros-de"),
-		Entry("English-only ASR", "whisper-small-en", "whisper-small-en"),
-		Entry("finetune", "qwen3-30b-a3b-abliterated", "qwen3-30b-a3b-abliterated"),
-		Entry("product suffix", "vibevoice-cpp-asr", "vibevoice-cpp-asr"),
-	)
-
-	It("never strips a name down to nothing", func() {
-		Expect(NameStem("q4_k_m")).To(Equal("q4_k_m"))
-		Expect(NameStem("f16-q8_0")).To(Equal("f16"))
-	})
-
-	DescribeTable("FileStem reduces a weight filename to the weights it holds",
-		func(filename, expected string) {
-			Expect(FileStem(filename)).To(Equal(expected))
-		},
-		Entry("directory and extension go", "bonsai/models/Ternary-Bonsai-8B-gguf/Ternary-Bonsai-8B-Q2_0.gguf", "ternary-bonsai-8b"),
-		Entry("underscored quant token stays whole", "Llama-3.2-1B-Instruct-Q4_K_M.gguf", "llama-3.2-1b-instruct"),
-		Entry("dot separated quant token", "Llama-3.2-3B-Instruct.Q4_K_M.gguf", "llama-3.2-3b-instruct"),
-		Entry("group size suffix", "Ternary-Bonsai-8B-Q2_0_g64.gguf", "ternary-bonsai-8b"),
-		Entry("bf16", "omnivoice-cpp-hq/omnivoice-base-BF16.gguf", "omnivoice-base"),
-		Entry("safetensors", "some/dir/Model-Name-fp8.safetensors", "model-name"),
-	)
-
-	DescribeTable("BuildWidth reads the nominal width out of a filename",
-		func(filename string, expected int) {
-			Expect(BuildWidth(filename)).To(Equal(expected))
-		},
-		Entry("q4", "foo-Q4_K_M.gguf", 4),
-		Entry("q8", "foo-Q8_0.gguf", 8),
-		Entry("q2", "foo-Q2_0.gguf", 2),
-		Entry("f16", "foo-f16.gguf", 16),
-		Entry("bf16", "foo-BF16.gguf", 16),
-		Entry("iq3", "foo-iq3_xxs.gguf", 3),
-		Entry("nothing readable sorts last", "foo.gguf", unknownWidth),
-	)
-
-	It("treats an auxiliary file as never being the model's own weights", func() {
-		for _, f := range []string{
-			"mmproj-model-f16.gguf",
-			"dir/vae-BF16.gguf",
-			"clip_l.safetensors",
-			"umt5-xxl-encoder-Q8_0.gguf",
-			"t5xxl_fp16.safetensors",
-			"ae.safetensors",
-			"omnivoice-tokenizer-Q8_0.gguf",
-		} {
-			Expect(IsAuxiliaryFile(f)).To(BeTrue(), "expected %q to be auxiliary", f)
-		}
-		Expect(IsAuxiliaryFile("gemma-3-27b-it-Q4_K_M.gguf")).To(BeFalse())
-	})
-})

.github/ci/variantproposals/variantproposals_suite_test.go

@@ -1,13 +0,0 @@
-package main
-
-import (
-	"testing"
-
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-func TestVariantProposals(t *testing.T) {
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "gallery variant proposals")
-}

.github/dependabot.yml

@@ -45,16 +45,6 @@ updates:
     directory: "/backend/python/diffusers"
     schedule:
       interval: "weekly"
-    # torch and transformers are deliberately pinned in this backend (see
-    # backend/python/diffusers/requirements-*.txt and issue #9979), and the
-    # l4t12 variant resolves them from the Jetson pip index
-    # (https://pypi.jetson-ai-lab.io/jp6/cu129/). dependabot cannot authenticate
-    # against that index and fails the whole weekly update with a
-    # private_source_authentication_failure. Ignore the two pinned deps we don't
-    # want bumped anyway so the job stays green.
-    ignore:
-    - dependency-name: "torch"
-    - dependency-name: "transformers"
   - package-ecosystem: "pip"
     directory: "/backend/python/exllama"
     schedule:

.github/gh_curl.sh

@@ -1,39 +0,0 @@
-#!/bin/bash
-# Shared curl wrapper for the nightly dependency-bump scripts.
-#
-# The bump workflow fans out to ~25 parallel matrix jobs, each querying
-# api.github.com. Anonymous API calls are capped at 60/hour per source IP and
-# GitHub-hosted runners egress through shared NAT addresses, so a random handful
-# of jobs were getting rate-limited (HTTP 403 -> curl exit 22, empty response)
-# every single night. Authenticating with GITHUB_TOKEN lifts the ceiling to
-# 1000/hour; the retries absorb whatever transient blips remain.
-
-# Wraps curl with GitHub auth (when a token is present) plus retry/timeout
-# hardening. Callers pass their own headers and the URL.
-gh_curl() {
-    # The bump scripts run under `set -x`; without this the Authorization header
-    # would be echoed into the job log on every call.
-    local had_xtrace=0
-    case "$-" in
-        *x*) had_xtrace=1; set +x ;;
-    esac
-
-    local args=(
-        --silent --show-error --location --fail
-        # --retry-all-errors so 403 rate-limit responses are retried too; plain
-        # --retry only covers 408/429/5xx. curl honours Retry-After when sent.
-        --retry 5 --retry-delay 3 --retry-all-errors
-        --connect-timeout 15 --max-time 60
-    )
-    if [ -n "${GITHUB_TOKEN:-}" ]; then
-        args+=(--header "Authorization: Bearer ${GITHUB_TOKEN}")
-    fi
-
-    curl "${args[@]}" "$@"
-    local rc=$?
-
-    if [ "$had_xtrace" -eq 1 ]; then
-        set -x
-    fi
-    return $rc
-}

.github/workflows/backend.yml

@@ -32,33 +32,19 @@ jobs:
     if: github.repository == 'mudler/LocalAI'
     runs-on: ubuntu-latest
     outputs:
+      matrix-singlearch: ${{ steps.set-matrix.outputs['matrix-singlearch'] }}
       matrix-multiarch: ${{ steps.set-matrix.outputs['matrix-multiarch'] }}
       matrix-darwin: ${{ steps.set-matrix.outputs['matrix-darwin'] }}
       merge-matrix-multiarch: ${{ steps.set-matrix.outputs['merge-matrix-multiarch'] }}
+      merge-matrix-singlearch: ${{ steps.set-matrix.outputs['merge-matrix-singlearch'] }}
+      has-backends-singlearch: ${{ steps.set-matrix.outputs['has-backends-singlearch'] }}
       has-backends-multiarch: ${{ steps.set-matrix.outputs['has-backends-multiarch'] }}
       has-backends-darwin: ${{ steps.set-matrix.outputs['has-backends-darwin'] }}
       has-merges-multiarch: ${{ steps.set-matrix.outputs['has-merges-multiarch'] }}
-      # Single-arch backends are sharded across SINGLEARCH_SHARDS matrix jobs to
-      # stay under GitHub's 256-jobs-per-matrix limit (see changed-backends.js).
-      matrix-singlearch-1: ${{ steps.set-matrix.outputs['matrix-singlearch-1'] }}
-      merge-matrix-singlearch-1: ${{ steps.set-matrix.outputs['merge-matrix-singlearch-1'] }}
-      has-backends-singlearch-1: ${{ steps.set-matrix.outputs['has-backends-singlearch-1'] }}
-      has-merges-singlearch-1: ${{ steps.set-matrix.outputs['has-merges-singlearch-1'] }}
-      matrix-singlearch-2: ${{ steps.set-matrix.outputs['matrix-singlearch-2'] }}
-      merge-matrix-singlearch-2: ${{ steps.set-matrix.outputs['merge-matrix-singlearch-2'] }}
-      has-backends-singlearch-2: ${{ steps.set-matrix.outputs['has-backends-singlearch-2'] }}
-      has-merges-singlearch-2: ${{ steps.set-matrix.outputs['has-merges-singlearch-2'] }}
-      matrix-singlearch-3: ${{ steps.set-matrix.outputs['matrix-singlearch-3'] }}
-      merge-matrix-singlearch-3: ${{ steps.set-matrix.outputs['merge-matrix-singlearch-3'] }}
-      has-backends-singlearch-3: ${{ steps.set-matrix.outputs['has-backends-singlearch-3'] }}
-      has-merges-singlearch-3: ${{ steps.set-matrix.outputs['has-merges-singlearch-3'] }}
-      matrix-singlearch-4: ${{ steps.set-matrix.outputs['matrix-singlearch-4'] }}
-      merge-matrix-singlearch-4: ${{ steps.set-matrix.outputs['merge-matrix-singlearch-4'] }}
-      has-backends-singlearch-4: ${{ steps.set-matrix.outputs['has-backends-singlearch-4'] }}
-      has-merges-singlearch-4: ${{ steps.set-matrix.outputs['has-merges-singlearch-4'] }}
+      has-merges-singlearch: ${{ steps.set-matrix.outputs['has-merges-singlearch'] }}
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
 
       - name: Setup Bun
         uses: oven-sh/setup-bun@v2
@@ -123,9 +109,9 @@ jobs:
   # take their full ~6h cold without blocking manifest assembly for the
   # multi-arch backends whose per-arch digests would otherwise sit untagged
   # on quay long enough to be GC'd.
-  backend-jobs-singlearch-1:
+  backend-jobs-singlearch:
     needs: generate-matrix
-    if: needs.generate-matrix.outputs['has-backends-singlearch-1'] == 'true'
+    if: needs.generate-matrix.outputs['has-backends-singlearch'] == 'true'
     uses: ./.github/workflows/backend_build.yml
     with:
       tag-latest: ${{ matrix.tag-latest }}
@@ -152,100 +138,7 @@ jobs:
     strategy:
       fail-fast: false
       max-parallel: 8
-      matrix: ${{ fromJson(needs.generate-matrix.outputs['matrix-singlearch-1']) }}
-
-  backend-jobs-singlearch-2:
-    needs: generate-matrix
-    if: needs.generate-matrix.outputs['has-backends-singlearch-2'] == 'true'
-    uses: ./.github/workflows/backend_build.yml
-    with:
-      tag-latest: ${{ matrix.tag-latest }}
-      tag-suffix: ${{ matrix.tag-suffix }}
-      build-type: ${{ matrix.build-type }}
-      cuda-major-version: ${{ matrix.cuda-major-version }}
-      cuda-minor-version: ${{ matrix.cuda-minor-version }}
-      platforms: ${{ matrix.platforms }}
-      platform-tag: ${{ matrix.platform-tag || '' }}
-      runs-on: ${{ matrix.runs-on }}
-      builder-base-image: ${{ matrix.builder-base-image || '' }}
-      base-image: ${{ matrix.base-image }}
-      backend: ${{ matrix.backend }}
-      dockerfile: ${{ matrix.dockerfile }}
-      skip-drivers: ${{ matrix.skip-drivers }}
-      context: ${{ matrix.context }}
-      ubuntu-version: ${{ matrix.ubuntu-version }}
-      amdgpu-targets: ${{ matrix.amdgpu-targets || 'gfx908,gfx90a,gfx942,gfx950,gfx1030,gfx1100,gfx1101,gfx1102,gfx1151,gfx1200,gfx1201' }}
-    secrets:
-      dockerUsername: ${{ secrets.DOCKERHUB_USERNAME }}
-      dockerPassword: ${{ secrets.DOCKERHUB_PASSWORD }}
-      quayUsername: ${{ secrets.LOCALAI_REGISTRY_USERNAME }}
-      quayPassword: ${{ secrets.LOCALAI_REGISTRY_PASSWORD }}
-    strategy:
-      fail-fast: false
-      max-parallel: 8
-      matrix: ${{ fromJson(needs.generate-matrix.outputs['matrix-singlearch-2']) }}
-
-  backend-jobs-singlearch-3:
-    needs: generate-matrix
-    if: needs.generate-matrix.outputs['has-backends-singlearch-3'] == 'true'
-    uses: ./.github/workflows/backend_build.yml
-    with:
-      tag-latest: ${{ matrix.tag-latest }}
-      tag-suffix: ${{ matrix.tag-suffix }}
-      build-type: ${{ matrix.build-type }}
-      cuda-major-version: ${{ matrix.cuda-major-version }}
-      cuda-minor-version: ${{ matrix.cuda-minor-version }}
-      platforms: ${{ matrix.platforms }}
-      platform-tag: ${{ matrix.platform-tag || '' }}
-      runs-on: ${{ matrix.runs-on }}
-      builder-base-image: ${{ matrix.builder-base-image || '' }}
-      base-image: ${{ matrix.base-image }}
-      backend: ${{ matrix.backend }}
-      dockerfile: ${{ matrix.dockerfile }}
-      skip-drivers: ${{ matrix.skip-drivers }}
-      context: ${{ matrix.context }}
-      ubuntu-version: ${{ matrix.ubuntu-version }}
-      amdgpu-targets: ${{ matrix.amdgpu-targets || 'gfx908,gfx90a,gfx942,gfx950,gfx1030,gfx1100,gfx1101,gfx1102,gfx1151,gfx1200,gfx1201' }}
-    secrets:
-      dockerUsername: ${{ secrets.DOCKERHUB_USERNAME }}
-      dockerPassword: ${{ secrets.DOCKERHUB_PASSWORD }}
-      quayUsername: ${{ secrets.LOCALAI_REGISTRY_USERNAME }}
-      quayPassword: ${{ secrets.LOCALAI_REGISTRY_PASSWORD }}
-    strategy:
-      fail-fast: false
-      max-parallel: 8
-      matrix: ${{ fromJson(needs.generate-matrix.outputs['matrix-singlearch-3']) }}
-
-  backend-jobs-singlearch-4:
-    needs: generate-matrix
-    if: needs.generate-matrix.outputs['has-backends-singlearch-4'] == 'true'
-    uses: ./.github/workflows/backend_build.yml
-    with:
-      tag-latest: ${{ matrix.tag-latest }}
-      tag-suffix: ${{ matrix.tag-suffix }}
-      build-type: ${{ matrix.build-type }}
-      cuda-major-version: ${{ matrix.cuda-major-version }}
-      cuda-minor-version: ${{ matrix.cuda-minor-version }}
-      platforms: ${{ matrix.platforms }}
-      platform-tag: ${{ matrix.platform-tag || '' }}
-      runs-on: ${{ matrix.runs-on }}
-      builder-base-image: ${{ matrix.builder-base-image || '' }}
-      base-image: ${{ matrix.base-image }}
-      backend: ${{ matrix.backend }}
-      dockerfile: ${{ matrix.dockerfile }}
-      skip-drivers: ${{ matrix.skip-drivers }}
-      context: ${{ matrix.context }}
-      ubuntu-version: ${{ matrix.ubuntu-version }}
-      amdgpu-targets: ${{ matrix.amdgpu-targets || 'gfx908,gfx90a,gfx942,gfx950,gfx1030,gfx1100,gfx1101,gfx1102,gfx1151,gfx1200,gfx1201' }}
-    secrets:
-      dockerUsername: ${{ secrets.DOCKERHUB_USERNAME }}
-      dockerPassword: ${{ secrets.DOCKERHUB_PASSWORD }}
-      quayUsername: ${{ secrets.LOCALAI_REGISTRY_USERNAME }}
-      quayPassword: ${{ secrets.LOCALAI_REGISTRY_PASSWORD }}
-    strategy:
-      fail-fast: false
-      max-parallel: 8
-      matrix: ${{ fromJson(needs.generate-matrix.outputs['matrix-singlearch-4']) }}
+      matrix: ${{ fromJson(needs.generate-matrix.outputs['matrix-singlearch']) }}
 
   # Apply tags to per-arch digests via `imagetools create`. Split into two
   # jobs that mirror the build split so each merge waits ONLY on its
@@ -281,12 +174,10 @@ jobs:
       fail-fast: false
       matrix: ${{ fromJson(needs.generate-matrix.outputs['merge-matrix-multiarch']) }}
 
-  # One merge shard per build shard: backend-merge-jobs-singlearch-<n> needs only
-  # backend-jobs-singlearch-<n>, preserving the "merge waits only on its own
-  # build" property while staying under the 256-jobs-per-matrix limit.
-  backend-merge-jobs-singlearch-1:
-    needs: [generate-matrix, backend-jobs-singlearch-1]
-    if: ${{ !cancelled() && needs.generate-matrix.outputs['has-merges-singlearch-1'] == 'true' }}
+  backend-merge-jobs-singlearch:
+    needs: [generate-matrix, backend-jobs-singlearch]
+    # See note on backend-merge-jobs-multiarch above for !cancelled().
+    if: ${{ !cancelled() && needs.generate-matrix.outputs['has-merges-singlearch'] == 'true' }}
     uses: ./.github/workflows/backend_merge.yml
     with:
       tag-latest: ${{ matrix.tag-latest }}
@@ -298,55 +189,7 @@ jobs:
       quayPassword: ${{ secrets.LOCALAI_REGISTRY_PASSWORD }}
     strategy:
       fail-fast: false
-      matrix: ${{ fromJson(needs.generate-matrix.outputs['merge-matrix-singlearch-1']) }}
-
-  backend-merge-jobs-singlearch-2:
-    needs: [generate-matrix, backend-jobs-singlearch-2]
-    if: ${{ !cancelled() && needs.generate-matrix.outputs['has-merges-singlearch-2'] == 'true' }}
-    uses: ./.github/workflows/backend_merge.yml
-    with:
-      tag-latest: ${{ matrix.tag-latest }}
-      tag-suffix: ${{ matrix.tag-suffix }}
-    secrets:
-      dockerUsername: ${{ secrets.DOCKERHUB_USERNAME }}
-      dockerPassword: ${{ secrets.DOCKERHUB_PASSWORD }}
-      quayUsername: ${{ secrets.LOCALAI_REGISTRY_USERNAME }}
-      quayPassword: ${{ secrets.LOCALAI_REGISTRY_PASSWORD }}
-    strategy:
-      fail-fast: false
-      matrix: ${{ fromJson(needs.generate-matrix.outputs['merge-matrix-singlearch-2']) }}
-
-  backend-merge-jobs-singlearch-3:
-    needs: [generate-matrix, backend-jobs-singlearch-3]
-    if: ${{ !cancelled() && needs.generate-matrix.outputs['has-merges-singlearch-3'] == 'true' }}
-    uses: ./.github/workflows/backend_merge.yml
-    with:
-      tag-latest: ${{ matrix.tag-latest }}
-      tag-suffix: ${{ matrix.tag-suffix }}
-    secrets:
-      dockerUsername: ${{ secrets.DOCKERHUB_USERNAME }}
-      dockerPassword: ${{ secrets.DOCKERHUB_PASSWORD }}
-      quayUsername: ${{ secrets.LOCALAI_REGISTRY_USERNAME }}
-      quayPassword: ${{ secrets.LOCALAI_REGISTRY_PASSWORD }}
-    strategy:
-      fail-fast: false
-      matrix: ${{ fromJson(needs.generate-matrix.outputs['merge-matrix-singlearch-3']) }}
-
-  backend-merge-jobs-singlearch-4:
-    needs: [generate-matrix, backend-jobs-singlearch-4]
-    if: ${{ !cancelled() && needs.generate-matrix.outputs['has-merges-singlearch-4'] == 'true' }}
-    uses: ./.github/workflows/backend_merge.yml
-    with:
-      tag-latest: ${{ matrix.tag-latest }}
-      tag-suffix: ${{ matrix.tag-suffix }}
-    secrets:
-      dockerUsername: ${{ secrets.DOCKERHUB_USERNAME }}
-      dockerPassword: ${{ secrets.DOCKERHUB_PASSWORD }}
-      quayUsername: ${{ secrets.LOCALAI_REGISTRY_USERNAME }}
-      quayPassword: ${{ secrets.LOCALAI_REGISTRY_PASSWORD }}
-    strategy:
-      fail-fast: false
-      matrix: ${{ fromJson(needs.generate-matrix.outputs['merge-matrix-singlearch-4']) }}
+      matrix: ${{ fromJson(needs.generate-matrix.outputs['merge-matrix-singlearch']) }}
 
   backend-jobs-darwin:
     needs: generate-matrix

.github/workflows/backend_build.yml

@@ -101,7 +101,7 @@ jobs:
     steps:
 
       - name: Checkout
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: true
 

.github/workflows/backend_build_darwin.yml

@@ -57,7 +57,7 @@ jobs:
       HOMEBREW_NO_ANALYTICS: '1'
     steps:
       - name: Clone
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: true
 
@@ -82,7 +82,7 @@ jobs:
       # as the Linux registry cache.
       - name: Restore Homebrew cache
         id: brew-cache
-        uses: actions/cache/restore@v6
+        uses: actions/cache/restore@v4
         with:
           path: |
             ~/Library/Caches/Homebrew/downloads
@@ -99,7 +99,6 @@ jobs:
             /opt/homebrew/Cellar/xxhash
             /opt/homebrew/Cellar/zstd
             /opt/homebrew/Cellar/nlohmann-json
-            /opt/homebrew/Cellar/opus
           key: brew-${{ runner.os }}-${{ runner.arch }}-v1-${{ hashFiles('.github/workflows/backend_build_darwin.yml') }}
 
       - name: Dependencies
@@ -114,12 +113,7 @@ jobs:
           # nlohmann-json is header-only and required by the ds4 backend
           # (dsml_renderer.cpp includes <nlohmann/json.hpp>); on Linux it comes
           # from the apt-installed nlohmann-json3-dev in the build image.
-          # opus + pkg-config are required by the opus go backend: its
-          # Makefile/package.sh call `pkg-config --cflags/--libs opus` to build
-          # libopusshim.dylib and to locate libopus.dylib for bundling. brew's
-          # pkg-config defaults its search path to the Homebrew prefix so the
-          # opus.pc is found.
-          brew install protobuf grpc make protoc-gen-go protoc-gen-go-grpc libomp llvm ccache blake3 fmt hiredis xxhash zstd nlohmann-json opus pkg-config
+          brew install protobuf grpc make protoc-gen-go protoc-gen-go-grpc libomp llvm ccache blake3 fmt hiredis xxhash zstd nlohmann-json
           # Force-reinstall ccache so brew re-validates its full runtime-dep
           # closure on every run. This is the durable fix: when the upstream
           # ccache formula gains a new transitive dep (as it has multiple times
@@ -138,11 +132,11 @@ jobs:
           # and decides "already installed" without re-linking, so on a cache-
           # hit run the formulas aren't on PATH. Force-link them; --overwrite
           # tolerates pre-existing symlinks from earlier installs.
-          brew link --overwrite protobuf grpc make protoc-gen-go protoc-gen-go-grpc libomp llvm ccache blake3 fmt hiredis xxhash zstd nlohmann-json opus pkg-config 2>/dev/null || true
+          brew link --overwrite protobuf grpc make protoc-gen-go protoc-gen-go-grpc libomp llvm ccache blake3 fmt hiredis xxhash zstd nlohmann-json 2>/dev/null || true
 
       - name: Save Homebrew cache
         if: github.event_name != 'pull_request' && steps.brew-cache.outputs.cache-hit != 'true'
-        uses: actions/cache/save@v6
+        uses: actions/cache/save@v4
         with:
           path: |
             ~/Library/Caches/Homebrew/downloads
@@ -159,7 +153,6 @@ jobs:
             /opt/homebrew/Cellar/xxhash
             /opt/homebrew/Cellar/zstd
             /opt/homebrew/Cellar/nlohmann-json
-            /opt/homebrew/Cellar/opus
           key: brew-${{ runner.os }}-${{ runner.arch }}-v1-${{ hashFiles('.github/workflows/backend_build_darwin.yml') }}
 
       # ---- ccache for llama.cpp CMake builds ----
@@ -178,7 +171,7 @@ jobs:
       - name: Restore ccache
         if: inputs.backend == 'llama-cpp'
         id: ccache-cache
-        uses: actions/cache/restore@v6
+        uses: actions/cache/restore@v4
         with:
           path: ~/Library/Caches/ccache
           key: ccache-llama-${{ runner.arch }}-${{ steps.llama-version.outputs.version }}-${{ github.run_id }}
@@ -211,7 +204,7 @@ jobs:
       - name: Restore Python wheel cache
         if: inputs.lang == 'python'
         id: pyenv-cache
-        uses: actions/cache/restore@v6
+        uses: actions/cache/restore@v4
         with:
           path: |
             ~/Library/Caches/pip
@@ -235,17 +228,8 @@ jobs:
         run: |
           make backends/ds4-darwin
 
-      # privacy-filter is a C++/ggml backend like ds4 - a single grpc-server with
-      # otool dylib bundling - so it gets its own bespoke darwin script rather than
-      # the generic build-darwin-go-backend path.
-      - name: Build privacy-filter backend (Darwin Metal)
-        if: inputs.backend == 'privacy-filter'
-        run: |
-          make protogen-go
-          make backends/privacy-filter-darwin
-
       - name: Build ${{ inputs.backend }}-darwin
-        if: inputs.backend != 'llama-cpp' && inputs.backend != 'ds4' && inputs.backend != 'privacy-filter'
+        if: inputs.backend != 'llama-cpp' && inputs.backend != 'ds4'
         run: |
           make protogen-go
           BACKEND=${{ inputs.backend }} BUILD_TYPE=${{ inputs.build-type }} USE_PIP=${{ inputs.use-pip }} make build-darwin-${{ inputs.lang }}-backend
@@ -256,14 +240,14 @@ jobs:
 
       - name: Save ccache
         if: inputs.backend == 'llama-cpp' && github.event_name != 'pull_request'
-        uses: actions/cache/save@v6
+        uses: actions/cache/save@v4
         with:
           path: ~/Library/Caches/ccache
           key: ccache-llama-${{ runner.arch }}-${{ steps.llama-version.outputs.version }}-${{ github.run_id }}
 
       - name: Save Python wheel cache
         if: inputs.lang == 'python' && github.event_name != 'pull_request' && steps.pyenv-cache.outputs.cache-hit != 'true'
-        uses: actions/cache/save@v6
+        uses: actions/cache/save@v4
         with:
           path: |
             ~/Library/Caches/pip

.github/workflows/backend_merge.yml

@@ -49,7 +49,7 @@ jobs:
       # Sparse checkout: the merge job needs `.github/scripts/` (for the
       # keepalive cleanup script) but none of the source tree.
       - name: Checkout (.github/scripts only)
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           sparse-checkout: |
             .github/scripts

.github/workflows/backend_pr.yml

@@ -11,33 +11,19 @@ jobs:
   generate-matrix:
     runs-on: ubuntu-latest
     outputs:
+      matrix-singlearch: ${{ steps.set-matrix.outputs['matrix-singlearch'] }}
       matrix-multiarch: ${{ steps.set-matrix.outputs['matrix-multiarch'] }}
       matrix-darwin: ${{ steps.set-matrix.outputs['matrix-darwin'] }}
       merge-matrix-multiarch: ${{ steps.set-matrix.outputs['merge-matrix-multiarch'] }}
+      merge-matrix-singlearch: ${{ steps.set-matrix.outputs['merge-matrix-singlearch'] }}
+      has-backends-singlearch: ${{ steps.set-matrix.outputs['has-backends-singlearch'] }}
       has-backends-multiarch: ${{ steps.set-matrix.outputs['has-backends-multiarch'] }}
       has-backends-darwin: ${{ steps.set-matrix.outputs['has-backends-darwin'] }}
       has-merges-multiarch: ${{ steps.set-matrix.outputs['has-merges-multiarch'] }}
-      # Single-arch backends are sharded across SINGLEARCH_SHARDS matrix jobs to
-      # stay under GitHub's 256-jobs-per-matrix limit (see changed-backends.js).
-      matrix-singlearch-1: ${{ steps.set-matrix.outputs['matrix-singlearch-1'] }}
-      merge-matrix-singlearch-1: ${{ steps.set-matrix.outputs['merge-matrix-singlearch-1'] }}
-      has-backends-singlearch-1: ${{ steps.set-matrix.outputs['has-backends-singlearch-1'] }}
-      has-merges-singlearch-1: ${{ steps.set-matrix.outputs['has-merges-singlearch-1'] }}
-      matrix-singlearch-2: ${{ steps.set-matrix.outputs['matrix-singlearch-2'] }}
-      merge-matrix-singlearch-2: ${{ steps.set-matrix.outputs['merge-matrix-singlearch-2'] }}
-      has-backends-singlearch-2: ${{ steps.set-matrix.outputs['has-backends-singlearch-2'] }}
-      has-merges-singlearch-2: ${{ steps.set-matrix.outputs['has-merges-singlearch-2'] }}
-      matrix-singlearch-3: ${{ steps.set-matrix.outputs['matrix-singlearch-3'] }}
-      merge-matrix-singlearch-3: ${{ steps.set-matrix.outputs['merge-matrix-singlearch-3'] }}
-      has-backends-singlearch-3: ${{ steps.set-matrix.outputs['has-backends-singlearch-3'] }}
-      has-merges-singlearch-3: ${{ steps.set-matrix.outputs['has-merges-singlearch-3'] }}
-      matrix-singlearch-4: ${{ steps.set-matrix.outputs['matrix-singlearch-4'] }}
-      merge-matrix-singlearch-4: ${{ steps.set-matrix.outputs['merge-matrix-singlearch-4'] }}
-      has-backends-singlearch-4: ${{ steps.set-matrix.outputs['has-backends-singlearch-4'] }}
-      has-merges-singlearch-4: ${{ steps.set-matrix.outputs['has-merges-singlearch-4'] }}
+      has-merges-singlearch: ${{ steps.set-matrix.outputs['has-merges-singlearch'] }}
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
 
       - name: Setup Bun
         uses: oven-sh/setup-bun@v2
@@ -85,10 +71,10 @@ jobs:
       fail-fast: true
       max-parallel: 8
       matrix: ${{ fromJson(needs.generate-matrix.outputs['matrix-multiarch']) }}
-  backend-jobs-singlearch-1:
+  backend-jobs-singlearch:
     needs: generate-matrix
-    if: needs.generate-matrix.outputs['has-backends-singlearch-1'] == 'true'
     uses: ./.github/workflows/backend_build.yml
+    if: needs.generate-matrix.outputs['has-backends-singlearch'] == 'true'
     with:
       tag-latest: ${{ matrix.tag-latest }}
       tag-suffix: ${{ matrix.tag-suffix }}
@@ -112,94 +98,7 @@ jobs:
     strategy:
       fail-fast: true
       max-parallel: 8
-      matrix: ${{ fromJson(needs.generate-matrix.outputs['matrix-singlearch-1']) }}
-
-  backend-jobs-singlearch-2:
-    needs: generate-matrix
-    if: needs.generate-matrix.outputs['has-backends-singlearch-2'] == 'true'
-    uses: ./.github/workflows/backend_build.yml
-    with:
-      tag-latest: ${{ matrix.tag-latest }}
-      tag-suffix: ${{ matrix.tag-suffix }}
-      build-type: ${{ matrix.build-type }}
-      cuda-major-version: ${{ matrix.cuda-major-version }}
-      cuda-minor-version: ${{ matrix.cuda-minor-version }}
-      platforms: ${{ matrix.platforms }}
-      platform-tag: ${{ matrix.platform-tag || '' }}
-      runs-on: ${{ matrix.runs-on }}
-      builder-base-image: ${{ matrix.builder-base-image || '' }}
-      base-image: ${{ matrix.base-image }}
-      backend: ${{ matrix.backend }}
-      dockerfile: ${{ matrix.dockerfile }}
-      skip-drivers: ${{ matrix.skip-drivers }}
-      context: ${{ matrix.context }}
-      ubuntu-version: ${{ matrix.ubuntu-version }}
-      amdgpu-targets: ${{ matrix.amdgpu-targets || 'gfx908,gfx90a,gfx942,gfx950,gfx1030,gfx1100,gfx1101,gfx1102,gfx1151,gfx1200,gfx1201' }}
-    secrets:
-      quayUsername: ${{ secrets.LOCALAI_REGISTRY_USERNAME }}
-      quayPassword: ${{ secrets.LOCALAI_REGISTRY_PASSWORD }}
-    strategy:
-      fail-fast: true
-      max-parallel: 8
-      matrix: ${{ fromJson(needs.generate-matrix.outputs['matrix-singlearch-2']) }}
-
-  backend-jobs-singlearch-3:
-    needs: generate-matrix
-    if: needs.generate-matrix.outputs['has-backends-singlearch-3'] == 'true'
-    uses: ./.github/workflows/backend_build.yml
-    with:
-      tag-latest: ${{ matrix.tag-latest }}
-      tag-suffix: ${{ matrix.tag-suffix }}
-      build-type: ${{ matrix.build-type }}
-      cuda-major-version: ${{ matrix.cuda-major-version }}
-      cuda-minor-version: ${{ matrix.cuda-minor-version }}
-      platforms: ${{ matrix.platforms }}
-      platform-tag: ${{ matrix.platform-tag || '' }}
-      runs-on: ${{ matrix.runs-on }}
-      builder-base-image: ${{ matrix.builder-base-image || '' }}
-      base-image: ${{ matrix.base-image }}
-      backend: ${{ matrix.backend }}
-      dockerfile: ${{ matrix.dockerfile }}
-      skip-drivers: ${{ matrix.skip-drivers }}
-      context: ${{ matrix.context }}
-      ubuntu-version: ${{ matrix.ubuntu-version }}
-      amdgpu-targets: ${{ matrix.amdgpu-targets || 'gfx908,gfx90a,gfx942,gfx950,gfx1030,gfx1100,gfx1101,gfx1102,gfx1151,gfx1200,gfx1201' }}
-    secrets:
-      quayUsername: ${{ secrets.LOCALAI_REGISTRY_USERNAME }}
-      quayPassword: ${{ secrets.LOCALAI_REGISTRY_PASSWORD }}
-    strategy:
-      fail-fast: true
-      max-parallel: 8
-      matrix: ${{ fromJson(needs.generate-matrix.outputs['matrix-singlearch-3']) }}
-
-  backend-jobs-singlearch-4:
-    needs: generate-matrix
-    if: needs.generate-matrix.outputs['has-backends-singlearch-4'] == 'true'
-    uses: ./.github/workflows/backend_build.yml
-    with:
-      tag-latest: ${{ matrix.tag-latest }}
-      tag-suffix: ${{ matrix.tag-suffix }}
-      build-type: ${{ matrix.build-type }}
-      cuda-major-version: ${{ matrix.cuda-major-version }}
-      cuda-minor-version: ${{ matrix.cuda-minor-version }}
-      platforms: ${{ matrix.platforms }}
-      platform-tag: ${{ matrix.platform-tag || '' }}
-      runs-on: ${{ matrix.runs-on }}
-      builder-base-image: ${{ matrix.builder-base-image || '' }}
-      base-image: ${{ matrix.base-image }}
-      backend: ${{ matrix.backend }}
-      dockerfile: ${{ matrix.dockerfile }}
-      skip-drivers: ${{ matrix.skip-drivers }}
-      context: ${{ matrix.context }}
-      ubuntu-version: ${{ matrix.ubuntu-version }}
-      amdgpu-targets: ${{ matrix.amdgpu-targets || 'gfx908,gfx90a,gfx942,gfx950,gfx1030,gfx1100,gfx1101,gfx1102,gfx1151,gfx1200,gfx1201' }}
-    secrets:
-      quayUsername: ${{ secrets.LOCALAI_REGISTRY_USERNAME }}
-      quayPassword: ${{ secrets.LOCALAI_REGISTRY_PASSWORD }}
-    strategy:
-      fail-fast: true
-      max-parallel: 8
-      matrix: ${{ fromJson(needs.generate-matrix.outputs['matrix-singlearch-4']) }}
+      matrix: ${{ fromJson(needs.generate-matrix.outputs['matrix-singlearch']) }}
   backend-merge-jobs-multiarch:
     needs: [generate-matrix, backend-jobs-multiarch]
     # backend_merge.yml's push-side steps are all gated on
@@ -219,9 +118,9 @@ jobs:
       fail-fast: false
       matrix: ${{ fromJson(needs.generate-matrix.outputs['merge-matrix-multiarch']) }}
 
-  backend-merge-jobs-singlearch-1:
-    needs: [generate-matrix, backend-jobs-singlearch-1]
-    if: ${{ !cancelled() && github.event_name != 'pull_request' && needs.generate-matrix.outputs['has-merges-singlearch-1'] == 'true' }}
+  backend-merge-jobs-singlearch:
+    needs: [generate-matrix, backend-jobs-singlearch]
+    if: ${{ !cancelled() && github.event_name != 'pull_request' && needs.generate-matrix.outputs['has-merges-singlearch'] == 'true' }}
     uses: ./.github/workflows/backend_merge.yml
     with:
       tag-latest: ${{ matrix.tag-latest }}
@@ -231,49 +130,7 @@ jobs:
       quayPassword: ${{ secrets.LOCALAI_REGISTRY_PASSWORD }}
     strategy:
       fail-fast: false
-      matrix: ${{ fromJson(needs.generate-matrix.outputs['merge-matrix-singlearch-1']) }}
-
-  backend-merge-jobs-singlearch-2:
-    needs: [generate-matrix, backend-jobs-singlearch-2]
-    if: ${{ !cancelled() && github.event_name != 'pull_request' && needs.generate-matrix.outputs['has-merges-singlearch-2'] == 'true' }}
-    uses: ./.github/workflows/backend_merge.yml
-    with:
-      tag-latest: ${{ matrix.tag-latest }}
-      tag-suffix: ${{ matrix.tag-suffix }}
-    secrets:
-      quayUsername: ${{ secrets.LOCALAI_REGISTRY_USERNAME }}
-      quayPassword: ${{ secrets.LOCALAI_REGISTRY_PASSWORD }}
-    strategy:
-      fail-fast: false
-      matrix: ${{ fromJson(needs.generate-matrix.outputs['merge-matrix-singlearch-2']) }}
-
-  backend-merge-jobs-singlearch-3:
-    needs: [generate-matrix, backend-jobs-singlearch-3]
-    if: ${{ !cancelled() && github.event_name != 'pull_request' && needs.generate-matrix.outputs['has-merges-singlearch-3'] == 'true' }}
-    uses: ./.github/workflows/backend_merge.yml
-    with:
-      tag-latest: ${{ matrix.tag-latest }}
-      tag-suffix: ${{ matrix.tag-suffix }}
-    secrets:
-      quayUsername: ${{ secrets.LOCALAI_REGISTRY_USERNAME }}
-      quayPassword: ${{ secrets.LOCALAI_REGISTRY_PASSWORD }}
-    strategy:
-      fail-fast: false
-      matrix: ${{ fromJson(needs.generate-matrix.outputs['merge-matrix-singlearch-3']) }}
-
-  backend-merge-jobs-singlearch-4:
-    needs: [generate-matrix, backend-jobs-singlearch-4]
-    if: ${{ !cancelled() && github.event_name != 'pull_request' && needs.generate-matrix.outputs['has-merges-singlearch-4'] == 'true' }}
-    uses: ./.github/workflows/backend_merge.yml
-    with:
-      tag-latest: ${{ matrix.tag-latest }}
-      tag-suffix: ${{ matrix.tag-suffix }}
-    secrets:
-      quayUsername: ${{ secrets.LOCALAI_REGISTRY_USERNAME }}
-      quayPassword: ${{ secrets.LOCALAI_REGISTRY_PASSWORD }}
-    strategy:
-      fail-fast: false
-      matrix: ${{ fromJson(needs.generate-matrix.outputs['merge-matrix-singlearch-4']) }}
+      matrix: ${{ fromJson(needs.generate-matrix.outputs['merge-matrix-singlearch']) }}
   backend-jobs-darwin:
     needs: generate-matrix
     uses: ./.github/workflows/backend_build_darwin.yml

.github/workflows/base-images.yml

@@ -127,7 +127,7 @@ jobs:
             # the original l4t matrix entry which set skip-drivers: 'true'.
             skip-drivers: 'true'
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v6
         with:
           submodules: false
       - name: Free disk space

.github/workflows/build-test.yaml

@@ -6,20 +6,12 @@ on:
       - master
   pull_request:
 
-# Supersede an in-flight run when a PR gets a new push. Keyed on the PR number
-# so every push to the same PR shares a group; on a master push the key falls
-# back to github.sha (unique per commit) and cancel-in-progress is false, so
-# master runs never cancel each other -- each commit is built on its own.
-concurrency:
-  group: ci-build-test-${{ github.event.pull_request.number || github.sha }}-${{ github.repository }}
-  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
-
 jobs:
   build-test:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           fetch-depth: 0
       - name: Set up Go
@@ -33,7 +25,7 @@ jobs:
     runs-on: macos-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           fetch-depth: 0
       - name: Set up Go
@@ -55,7 +47,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           fetch-depth: 0
       - name: Configure apt mirror on runner

.github/workflows/bump-inference-defaults.yml

@@ -14,7 +14,7 @@ jobs:
   bump:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v6
 
       - uses: actions/setup-go@v5
         with:

.github/workflows/bump_deps.yaml

@@ -22,18 +22,10 @@ jobs:
             variable: "TURBOQUANT_VERSION"
             branch: "feature/turboquant-kv-cache"
             file: "backend/cpp/turboquant/Makefile"
-          - repository: "PrismML-Eng/llama.cpp"
-            variable: "BONSAI_VERSION"
-            branch: "prism"
-            file: "backend/cpp/bonsai/Makefile"
           - repository: "antirez/ds4"
             variable: "DS4_VERSION"
             branch: "main"
             file: "backend/cpp/ds4/Makefile"
-          - repository: "meituan-longcat/LongCat-Video"
-            variable: "LONGCAT_VIDEO_VERSION"
-            branch: "main"
-            file: "backend/python/longcat-video/Makefile"
           - repository: "localai-org/privacy-filter.cpp"
             variable: "PRIVACY_FILTER_VERSION"
             branch: "master"
@@ -50,19 +42,11 @@ jobs:
             variable: "PARAKEET_VERSION"
             branch: "master"
             file: "backend/go/parakeet-cpp/Makefile"
-          - repository: "mudler/vllm.cpp"
-            variable: "VLLM_CPP_VERSION"
-            branch: "main"
-            file: "backend/go/vllm-cpp/Makefile"
-          - repository: "localai-org/moss-transcribe.cpp"
-            variable: "MOSS_VERSION"
-            branch: "master"
-            file: "backend/go/moss-transcribe-cpp/Makefile"
-          - repository: "localai-org/ced.cpp"
+          - repository: "mudler/ced.cpp"
             variable: "CED_VERSION"
-            branch: "main"
+            branch: "master"
             file: "backend/go/ced/Makefile"
-          - repository: "localai-org/voice-detect.cpp"
+          - repository: "mudler/voice-detect.cpp"
             variable: "VOICEDETECT_VERSION"
             branch: "master"
             file: "backend/go/voice-detect/Makefile"
@@ -94,7 +78,7 @@ jobs:
             variable: "SAM3_VERSION"
             branch: "main"
             file: "backend/go/sam3-cpp/Makefile"
-          - repository: "localai-org/rf-detr.cpp"
+          - repository: "mudler/rf-detr.cpp"
             variable: "RFDETR_VERSION"
             branch: "main"
             file: "backend/go/rfdetr-cpp/Makefile"
@@ -114,21 +98,11 @@ jobs:
             variable: "VIBEVOICE_CPP_VERSION"
             branch: "master"
             file: "backend/go/vibevoice-cpp/Makefile"
-          - repository: "mudler/magpie-tts.cpp"
-            variable: "MAGPIETTS_CPP_VERSION"
-            branch: "main"
-            file: "backend/go/magpie-tts-cpp/Makefile"
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v6
       - name: Bump dependencies 🔧
         id: bump
-        env:
-          # This job fans out to ~25 parallel matrix entries, all querying
-          # api.github.com from runner IPs that share the 60/hour anonymous
-          # rate limit. Authenticating raises it to 1000/hour, which is what
-          # kept a random handful of these red every night.
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
           bash .github/bump_deps.sh ${{ matrix.repository }} ${{ matrix.branch }} ${{ matrix.variable }} ${{ matrix.file }}
           {
@@ -162,11 +136,9 @@ jobs:
     if: github.repository == 'mudler/LocalAI'
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v6
       - name: Bump vLLM cu130 wheel pin 🔧
         id: bump
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
           bash .github/bump_vllm_wheel.sh vllm-project/vllm backend/python/vllm/requirements-cublas13-after.txt VLLM_VERSION
           {
@@ -190,41 +162,3 @@ jobs:
           branch: "update/VLLM_VERSION"
           body: ${{ steps.bump.outputs.message }}
           signoff: true
-
-  bump-vllm-metal:
-    # The darwin (Apple Silicon) vLLM build installs vllm-metal, which is locked
-    # to a specific vLLM source release. install.sh pins both VLLM_METAL_VERSION
-    # (the wheel release) and VLLM_VERSION (the vLLM it builds against); this job
-    # tracks vllm-project/vllm-metal and rewrites both atomically. Separate from
-    # bump-vllm-wheel because darwin follows vllm-metal, not vllm/vllm latest.
-    if: github.repository == 'mudler/LocalAI'
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v7
-      - name: Bump vllm-metal pin 🔧
-        id: bump
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          bash .github/bump_vllm_metal.sh vllm-project/vllm-metal backend/python/vllm/install.sh VLLM_METAL_VERSION
-          {
-            echo 'message<<EOF'
-            cat "VLLM_METAL_VERSION_message.txt"
-            echo EOF
-          } >> "$GITHUB_OUTPUT"
-          {
-            echo 'commit<<EOF'
-            cat "VLLM_METAL_VERSION_commit.txt"
-            echo EOF
-          } >> "$GITHUB_OUTPUT"
-          rm -rfv VLLM_METAL_VERSION_message.txt VLLM_METAL_VERSION_commit.txt
-      - name: Create Pull Request
-        uses: peter-evans/create-pull-request@v8
-        with:
-          token: ${{ secrets.UPDATE_BOT_TOKEN }}
-          push-to-fork: ci-forks/LocalAI
-          commit-message: ':arrow_up: Update vllm-project/vllm-metal (darwin)'
-          title: 'chore: :arrow_up: Update vllm-metal (darwin) to `${{ steps.bump.outputs.commit }}`'
-          branch: "update/VLLM_METAL_VERSION"
-          body: ${{ steps.bump.outputs.message }}
-          signoff: true

.github/workflows/bump_docs.yaml

@@ -13,12 +13,8 @@ jobs:
           - repository: "mudler/LocalAI"
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v6
       - name: Bump dependencies 🔧
-        env:
-          # Authenticated API calls get 1000 req/hour instead of the 60/hour
-          # anonymous cap that is shared across every job on the runner's IP.
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
           bash .github/bump_docs.sh ${{ matrix.repository }}
       - name: Create Pull Request

.github/workflows/checksum_checker.yaml

@@ -8,7 +8,7 @@ jobs:
     if: github.repository == 'mudler/LocalAI'
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v6
       - name: Configure apt mirror on runner
         uses: ./.github/actions/configure-apt-mirror
       - name: Install dependencies

.github/workflows/ci-tools-tests.yaml

@@ -1,39 +0,0 @@
----
-# The packages under .github/ci/ are invisible to `go list ./...`, so neither
-# `make lint` nor the repository test run ever touches them. Their specs are
-# dead weight until a workflow names each package explicitly.
-name: 'CI tool tests'
-on:
-  pull_request:
-    paths:
-      - '.github/ci/**'
-      - '.github/workflows/ci-tools-tests.yaml'
-  push:
-    branches:
-      - master
-    paths:
-      - '.github/ci/**'
-jobs:
-  ci-tools:
-    name: 'Test the .github/ci generators'
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v7
-      - uses: actions/setup-go@v5
-        with:
-          go-version-file: go.mod
-          cache: false
-
-      # The discovery heuristics are the risky part of these tools. A regression
-      # produces confident, wrong gallery entries, which is worse than no tool.
-      - name: 'Test the APEX entry generator'
-        run: go test ./.github/ci/apexentries/
-
-      - name: 'Test the variant proposer'
-        run: go test ./.github/ci/variantproposals/
-
-      # Shared by both generators above. Its behaviour is exercised through their
-      # specs; this step exists so a break in the shared package fails under its
-      # own name rather than as a puzzling failure in whichever caller ran first.
-      - name: 'Test the shared gallery editor'
-        run: go test ./.github/ci/galleryedit/

.github/workflows/deploy-explorer.yaml

@@ -16,7 +16,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Clone
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: true
       - uses: actions/setup-go@v5

.github/workflows/gallery-agent.yaml

@@ -31,7 +31,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
 

.github/workflows/gallery_variant_proposals.yaml

@@ -1,54 +0,0 @@
-name: Propose gallery variant groupings
-on:
-  schedule:
-    - cron: 0 4 * * 1
-  workflow_dispatch:
-jobs:
-  variant_proposals:
-    if: github.repository == 'mudler/LocalAI'
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v7
-      - uses: actions/setup-go@v5
-        with:
-          go-version-file: go.mod
-          cache: false
-
-      # The heuristics are the risky part of this job. A regression in them
-      # produces confident, wrong proposals, which is worse than no job at all.
-      - name: Test the proposer
-        run: go test ./.github/ci/variantproposals/
-
-      - name: Propose groupings 🔧
-        id: propose
-        run: |
-          rm -f /tmp/variant-proposals-body.md
-          go run ./.github/ci/variantproposals \
-            -index gallery/index.yaml \
-            -ledger gallery/variant-exclusions.yaml \
-            -body-out /tmp/variant-proposals-body.md \
-            -apply
-          if [ -s /tmp/variant-proposals-body.md ]; then
-            echo "have_proposals=true" >> "$GITHUB_OUTPUT"
-            {
-              echo 'body<<VARIANT_PROPOSAL_BODY_EOF'
-              cat /tmp/variant-proposals-body.md
-              echo VARIANT_PROPOSAL_BODY_EOF
-            } >> "$GITHUB_OUTPUT"
-          else
-            echo "have_proposals=false" >> "$GITHUB_OUTPUT"
-          fi
-
-      # No body file means the proposer found nothing. Opening an empty pull
-      # request every run is how a proposal job gets muted by its reviewers.
-      - name: Create Pull Request
-        if: steps.propose.outputs.have_proposals == 'true'
-        uses: peter-evans/create-pull-request@v8
-        with:
-          token: ${{ secrets.UPDATE_BOT_TOKEN }}
-          push-to-fork: ci-forks/LocalAI
-          commit-message: 'chore(model-gallery): propose variant groupings'
-          title: 'chore(model-gallery): propose variant groupings for review'
-          branch: "propose/variant-groupings"
-          body: ${{ steps.propose.outputs.body }}
-          signoff: true

.github/workflows/generate_intel_image.yaml

@@ -44,7 +44,7 @@ jobs:
         uses: docker/setup-buildx-action@master
 
       - name: Checkout
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
 
       - name: Cache Intel images
         uses: docker/build-push-action@v7

.github/workflows/gh-pages.yml

@@ -28,7 +28,7 @@ jobs:
       HUGO_VERSION: "0.146.3"
     steps:
       - name: Checkout
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           fetch-depth: 0  # needed for enableGitInfo
           submodules: true

.github/workflows/image-pr.yml

@@ -52,7 +52,7 @@
               tag-latest: 'false'
               tag-suffix: '-gpu-nvidia-cuda-13'
               runs-on: 'ubuntu-latest'
-              base-image: "ubuntu:24.04"
+              base-image: "ubuntu:22.04"
               makeflags: "--jobs=3 --output-sync=target"
               ubuntu-version: '2404'
             - build-type: 'hipblas'

.github/workflows/image.yml

@@ -113,7 +113,7 @@
               tag-latest: 'auto'
               tag-suffix: '-gpu-nvidia-cuda-13'
               runs-on: 'ubuntu-latest'
-              base-image: "ubuntu:24.04"
+              base-image: "ubuntu:22.04"
               skip-drivers: 'false'
               makeflags: "--jobs=4 --output-sync=target"
               ubuntu-version: '2404'

.github/workflows/image_build.yml

@@ -80,7 +80,7 @@ jobs:
     steps:
 
       - name: Checkout
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
 
       - name: Configure apt mirror on runner
         id: apt_mirror

.github/workflows/image_merge.yml

@@ -36,7 +36,7 @@ jobs:
       # Sparse checkout: needed for .github/scripts/ (the keepalive cleanup
       # script). Skips the rest of the source tree.
       - name: Checkout (.github/scripts only)
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           sparse-checkout: |
             .github/scripts

.github/workflows/lint.yml

@@ -20,7 +20,7 @@ jobs:
   golangci-lint:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v6
         with:
           # Full history so golangci-lint's new-from-merge-base can reach
           # origin/master and compute the diff against it.
@@ -46,23 +46,3 @@ jobs:
           touch core/http/react-ui/dist/index.html
       - name: lint
         run: make lint
-
-  build-scripts:
-    # The image packaging scripts encode invariants that only surface inside a
-    # container build (a missing transitive dep, a partial cuDNN family). Their
-    # shell tests need nothing but bash + gcc + ldd, so run them on every PR
-    # rather than waiting on a multi-GB cross-arch backend image build.
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v7
-      - name: run packaging script tests
-        run: make test-build-scripts
-
-      # The backend matrix path filter fails silently: a miss emits an empty
-      # matrix, every job goes green, and the change reaches no image (#10946).
-      # Its tests need only node, so they ride along with this job.
-      - uses: actions/setup-node@v7
-        with:
-          node-version: '20'
-      - name: run CI script tests
-        run: make test-ci-scripts

.github/workflows/realtime-conformance.yml

@@ -1,69 +0,0 @@
----
-name: 'realtime-conformance'
-
-# Verifies the realtime state-machine implementations conform to their formal
-# designs (docs/design/realtime-state-machines.md, formal-verification/). BOTH
-# layers are enforced and the gate is fail-closed: the Go conformance layer
-# (respcoord + turncoord transition/rapid tests under -race) AND the FizzBee model check of
-# the authoritative specs. FizzBee is pinned + checksum-verified
-# (formal-verification/fizzbee.sha256), so a failed install fails the job rather
-# than silently skipping verification.
-
-on:
-  pull_request:
-    paths:
-      - 'core/http/endpoints/openai/coordinator/**'
-      - 'core/http/endpoints/openai/respcoord/**'
-      - 'core/http/endpoints/openai/turncoord/**'
-      - 'core/http/endpoints/openai/conncoord/**'
-      - 'core/http/endpoints/openai/compactcoord/**'
-      - 'core/http/endpoints/openai/ttscoord/**'
-      - 'formal-verification/**'
-      - 'scripts/realtime-conformance.sh'
-      - 'scripts/install-fizzbee.sh'
-      - '.github/workflows/realtime-conformance.yml'
-  push:
-    branches:
-      - master
-    paths:
-      - 'core/http/endpoints/openai/coordinator/**'
-      - 'core/http/endpoints/openai/respcoord/**'
-      - 'core/http/endpoints/openai/turncoord/**'
-      - 'core/http/endpoints/openai/conncoord/**'
-      - 'core/http/endpoints/openai/compactcoord/**'
-      - 'core/http/endpoints/openai/ttscoord/**'
-      - 'formal-verification/**'
-      - 'scripts/realtime-conformance.sh'
-
-concurrency:
-  group: realtime-conformance-${{ github.event.pull_request.number || github.sha }}-${{ github.repository }}
-  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
-
-jobs:
-  conformance:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        go-version: ['1.26.x']
-    steps:
-      - name: Clone
-        uses: actions/checkout@v7
-      - name: Setup Go ${{ matrix.go-version }}
-        uses: actions/setup-go@v5
-        with:
-          go-version: ${{ matrix.go-version }}
-          cache: false
-      - name: Cache FizzBee
-        uses: actions/cache@v6
-        with:
-          path: .tools/fizzbee
-          key: fizzbee-v0.5.2-${{ runner.os }}-${{ hashFiles('formal-verification/fizzbee.sha256') }}
-      - name: Install FizzBee (pinned, checksum-verified)
-        # No `|| true`: a failed/forged download must fail the job, not silently
-        # drop the design verification. install-fizzbee.sh is a no-op if the
-        # cached binary is already present and valid.
-        run: ./scripts/install-fizzbee.sh
-      - name: Run conformance gate (fail-closed)
-        # No skip env: both the Go conformance and the FizzBee model check are
-        # required. The gate auto-detects .tools/fizzbee/fizz.
-        run: make test-realtime-conformance

.github/workflows/release.yaml

@@ -10,7 +10,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           fetch-depth: 0
       - name: Set up Go
@@ -24,35 +24,20 @@ jobs:
           args: release --clean
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          MACOS_SIGN_P12: ${{ secrets.MACOS_CERTIFICATE }}
-          MACOS_SIGN_PASSWORD: ${{ secrets.MACOS_CERTIFICATE_PWD }}
-          MACOS_NOTARY_KEY: ${{ secrets.MACOS_NOTARY_KEY }}
-          MACOS_NOTARY_KEY_ID: ${{ secrets.MACOS_NOTARY_KEY_ID }}
-          MACOS_NOTARY_ISSUER_ID: ${{ secrets.MACOS_NOTARY_ISSUER_ID }}
   launcher-build-darwin:
     runs-on: macos-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           fetch-depth: 0
       - name: Set up Go
         uses: actions/setup-go@v5
         with:
           go-version: 1.23
-      - name: Import signing certificate
-        env:
-          MACOS_CERTIFICATE: ${{ secrets.MACOS_CERTIFICATE }}
-          MACOS_CERTIFICATE_PWD: ${{ secrets.MACOS_CERTIFICATE_PWD }}
-          MACOS_CI_KEYCHAIN_PWD: ${{ secrets.MACOS_CI_KEYCHAIN_PWD }}
-        run: bash contrib/macos/sign-and-notarize.sh import-cert
-      - name: Build, sign and notarize the DMG
-        env:
-          MACOS_SIGN_IDENTITY: ${{ secrets.MACOS_SIGN_IDENTITY }}
-          MACOS_NOTARY_KEY: ${{ secrets.MACOS_NOTARY_KEY }}
-          MACOS_NOTARY_KEY_ID: ${{ secrets.MACOS_NOTARY_KEY_ID }}
-          MACOS_NOTARY_ISSUER_ID: ${{ secrets.MACOS_NOTARY_ISSUER_ID }}
-        run: make release-launcher-darwin
+      - name: Build launcher for macOS ARM64
+        run: |
+          make build-launcher-darwin
       - name: Upload DMG to Release
         uses: softprops/action-gh-release@v3
         with:
@@ -61,7 +46,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           fetch-depth: 0
       - name: Configure apt mirror on runner

.github/workflows/secscan.yaml

@@ -7,19 +7,6 @@ on:
   schedule:
   - cron: '0 0 * * 0'
 
-# `push:` is deliberately unfiltered, so this fires on every push to every
-# branch and there is no pull_request event to key on -- the usual
-# `github.event.pull_request.number || github.sha` idiom used elsewhere would
-# key on the unique-per-commit sha and dedup nothing. Group on the ref instead
-# so successive pushes to the same feature branch supersede one another.
-#
-# Cancelling is safe here: the only output is a SARIF upload, and code scanning
-# tracks the latest result per ref, so a superseded scan has nothing to lose.
-# master is excluded anyway -- every commit on master gets its own scan.
-concurrency:
-  group: ci-secscan-${{ github.ref }}-${{ github.repository }}
-  cancel-in-progress: ${{ github.ref != 'refs/heads/master' }}
-
 jobs:
   tests:
     runs-on: ubuntu-latest
@@ -27,7 +14,7 @@ jobs:
       GO111MODULE: on
     steps:
       - name: Checkout Source
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         if: ${{ github.actor != 'dependabot[bot]' }}
       - name: Run Gosec Security Scanner
         if: ${{ github.actor != 'dependabot[bot]' }}

.github/workflows/stalebot.yml

@@ -11,7 +11,7 @@ jobs:
     if: github.repository == 'mudler/LocalAI'
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/stale@1e223db275d687790206a7acac4d1a11bd6fe629 # v9
+      - uses: actions/stale@eb5cf3af3ac0a1aa4c9c45633dd1ae542a27a899 # v9
         with:
           stale-issue-message: 'This issue is stale because it has been open 90 days with no activity. Remove stale label or comment or this will be closed in 5 days.'
           stale-pr-message: 'This PR is stale because it has been open 90 days with no activity. Remove stale label or comment or this will be closed in 10 days.'

.github/workflows/test-extra.yml

@@ -37,7 +37,6 @@ jobs:
       sglang: ${{ steps.detect.outputs.sglang }}
       acestep-cpp: ${{ steps.detect.outputs.acestep-cpp }}
       qwen3-tts-cpp: ${{ steps.detect.outputs.qwen3-tts-cpp }}
-      magpie-tts-cpp: ${{ steps.detect.outputs.magpie-tts-cpp }}
       rfdetr-cpp: ${{ steps.detect.outputs.rfdetr-cpp }}
       locate-anything-cpp: ${{ steps.detect.outputs.locate-anything-cpp }}
       vibevoice-cpp: ${{ steps.detect.outputs.vibevoice-cpp }}
@@ -51,7 +50,7 @@ jobs:
       parakeet-cpp: ${{ steps.detect.outputs.parakeet-cpp }}
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
       - name: Setup Bun
         uses: oven-sh/setup-bun@v2
       - name: Install dependencies
@@ -68,7 +67,7 @@ jobs:
   #   runs-on: ubuntu-latest
   #   steps:
   #     - name: Clone
-  #       uses: actions/checkout@v7
+  #       uses: actions/checkout@v6
   #       with:
   #         submodules: true
   #     - name: Dependencies
@@ -91,7 +90,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Clone
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: true
       - name: Dependencies
@@ -114,7 +113,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Clone
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: true
       - name: Dependencies
@@ -138,7 +137,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Clone
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: true
       - name: Dependencies
@@ -159,7 +158,7 @@ jobs:
   #  runs-on: ubuntu-latest
   #  steps:
   #    - name: Clone
-  #      uses: actions/checkout@v7
+  #      uses: actions/checkout@v6
   #      with:
   #        submodules: true
   #    - name: Dependencies
@@ -179,7 +178,7 @@ jobs:
   #   runs-on: ubuntu-latest
   #   steps:
   #     - name: Clone
-  #       uses: actions/checkout@v7
+  #       uses: actions/checkout@v6
   #       with:
   #         submodules: true
   #     - name: Dependencies
@@ -241,7 +240,7 @@ jobs:
   #           sudo rm -rf "$AGENT_TOOLSDIRECTORY" || true
   #           df -h
   #     - name: Clone
-  #       uses: actions/checkout@v7
+  #       uses: actions/checkout@v6
   #       with:
   #         submodules: true
   #     - name: Dependencies
@@ -266,7 +265,7 @@ jobs:
   #   runs-on: ubuntu-latest
   #   steps:
   #     - name: Clone
-  #       uses: actions/checkout@v7
+  #       uses: actions/checkout@v6
   #       with:
   #         submodules: true
   #     - name: Dependencies
@@ -289,7 +288,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Clone
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: true
       - name: Dependencies
@@ -310,7 +309,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Clone
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: true
       - name: Dependencies
@@ -331,7 +330,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Clone
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: true
       - name: Dependencies
@@ -352,7 +351,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Clone
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: true
       - name: Dependencies
@@ -374,7 +373,7 @@ jobs:
   #   timeout-minutes: 45
   #   steps:
   #     - name: Clone
-  #       uses: actions/checkout@v7
+  #       uses: actions/checkout@v6
   #       with:
   #         submodules: true
   #     - name: Dependencies
@@ -395,7 +394,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Clone
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: true
       - name: Dependencies
@@ -416,7 +415,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Clone
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: true
       - name: Dependencies
@@ -437,7 +436,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Clone
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: true
       - name: Dependencies
@@ -463,7 +462,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Clone
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: true
       - name: Dependencies
@@ -485,7 +484,7 @@ jobs:
     timeout-minutes: 30
     steps:
       - name: Clone
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: true
       - name: Dependencies
@@ -514,7 +513,7 @@ jobs:
     timeout-minutes: 90
     steps:
       - name: Clone
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: true
       - name: Setup Go
@@ -531,7 +530,7 @@ jobs:
     timeout-minutes: 90
     steps:
       - name: Clone
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: true
       - name: Setup Go
@@ -553,7 +552,7 @@ jobs:
     timeout-minutes: 20
     steps:
       - name: Clone
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: true
       - name: Setup Go
@@ -580,7 +579,7 @@ jobs:
     timeout-minutes: 90
     steps:
       - name: Clone
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: true
       - name: Setup Go
@@ -588,7 +587,7 @@ jobs:
         with:
           go-version: '1.25.4'
       - name: Setup Node.js
-        uses: actions/setup-node@v7
+        uses: actions/setup-node@v6
         with:
           node-version: '22'
       - name: Build sherpa-onnx backend image and run realtime e2e tests
@@ -605,7 +604,7 @@ jobs:
     timeout-minutes: 90
     steps:
       - name: Clone
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: true
       - name: Setup Go
@@ -626,7 +625,7 @@ jobs:
     timeout-minutes: 90
     steps:
       - name: Clone
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: true
       - name: Setup Go
@@ -646,7 +645,7 @@ jobs:
     timeout-minutes: 90
     steps:
       - name: Clone
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: true
       - name: Setup Go
@@ -665,7 +664,7 @@ jobs:
     timeout-minutes: 90
     steps:
       - name: Clone
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: true
       - name: Setup Go
@@ -682,7 +681,7 @@ jobs:
     timeout-minutes: 90
     steps:
       - name: Clone
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: true
       - name: Setup Go
@@ -699,7 +698,7 @@ jobs:
     timeout-minutes: 90
     steps:
       - name: Clone
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: true
       - name: Setup Go
@@ -742,7 +741,7 @@ jobs:
   #   timeout-minutes: 90
   #   steps:
   #     - name: Clone
-  #       uses: actions/checkout@v7
+  #       uses: actions/checkout@v6
   #       with:
   #         submodules: true
   #     - name: Dependencies
@@ -784,7 +783,7 @@ jobs:
   #   timeout-minutes: 90
   #   steps:
   #     - name: Clone
-  #       uses: actions/checkout@v7
+  #       uses: actions/checkout@v6
   #       with:
   #         submodules: true
   #     - name: Dependencies
@@ -809,7 +808,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Clone
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: true
       - name: Dependencies
@@ -841,7 +840,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Clone
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: true
       - name: Dependencies
@@ -867,38 +866,6 @@ jobs:
       - name: Test qwen3-tts-cpp
         run: |
           make --jobs=5 --output-sync=target -C backend/go/qwen3-tts-cpp test
-  tests-magpie-tts-cpp:
-    needs: detect-changes
-    if: needs.detect-changes.outputs.magpie-tts-cpp == 'true' || needs.detect-changes.outputs.run-all == 'true'
-    runs-on: ubuntu-latest
-    steps:
-      - name: Clone
-        uses: actions/checkout@v7
-        with:
-          submodules: true
-      - name: Dependencies
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y build-essential cmake curl libopenblas-dev ffmpeg
-      - name: Setup Go
-        uses: actions/setup-go@v5
-      - name: Display Go version
-        run: go version
-      - name: Proto Dependencies
-        run: |
-          # Install protoc
-          curl -L -s https://github.com/protocolbuffers/protobuf/releases/download/v26.1/protoc-26.1-linux-x86_64.zip -o protoc.zip && \
-          unzip -j -d /usr/local/bin protoc.zip bin/protoc && \
-          rm protoc.zip
-          go install google.golang.org/protobuf/cmd/protoc-gen-go@v1.34.2
-          go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@1958fcbe2ca8bd93af633f11e97d44e567e945af
-          PATH="$PATH:$HOME/go/bin" make protogen-go
-      - name: Build magpie-tts-cpp
-        run: |
-          make --jobs=5 --output-sync=target -C backend/go/magpie-tts-cpp
-      - name: Test magpie-tts-cpp
-        run: |
-          make --jobs=5 --output-sync=target -C backend/go/magpie-tts-cpp test
   # Per-backend smoke for rfdetr-cpp: builds the .so + Go binary and runs
   # `make -C backend/go/rfdetr-cpp test`. test.sh fetches the small (~20 MB)
   # rfdetr-nano-q8_0 GGUF from the published mudler/rfdetr-cpp-nano HF repo
@@ -909,7 +876,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Clone
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: true
       - name: Dependencies
@@ -948,7 +915,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Clone
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: true
       - name: Dependencies
@@ -985,7 +952,7 @@ jobs:
     timeout-minutes: 90
     steps:
       - name: Clone
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: true
       - name: Dependencies
@@ -1020,7 +987,7 @@ jobs:
     timeout-minutes: 90
     steps:
       - name: Clone
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: true
       - name: Setup Go
@@ -1041,16 +1008,12 @@ jobs:
   # image + working dir.
   tests-vibevoice-cpp-grpc-transcription:
     needs: detect-changes
-    # Skip on release tag pushes: the ASR Q4_K model is ~10 GB and cannot be
-    # pulled from HF within the inner `go test -timeout 30m` budget on a CI
-    # runner, so every tag build hung and timed out. Still runs on PRs/branch
-    # pushes that touch vibevoice-cpp so regressions are caught off the release path.
-    if: (needs.detect-changes.outputs.vibevoice-cpp == 'true' || needs.detect-changes.outputs.run-all == 'true') && !startsWith(github.ref, 'refs/tags/')
+    if: needs.detect-changes.outputs.vibevoice-cpp == 'true' || needs.detect-changes.outputs.run-all == 'true'
     runs-on: bigger-runner
     timeout-minutes: 150
     steps:
       - name: Clone
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: true
       - name: Dependencies
@@ -1079,7 +1042,7 @@ jobs:
     timeout-minutes: 60
     steps:
       - name: Clone
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: true
       - name: Setup Go
@@ -1095,7 +1058,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Clone
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: true
       - name: Dependencies
@@ -1128,7 +1091,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Clone
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: true
       - name: Dependencies
@@ -1151,7 +1114,7 @@ jobs:
     timeout-minutes: 90
     steps:
       - name: Clone
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: true
       - name: Dependencies
@@ -1177,7 +1140,7 @@ jobs:
     timeout-minutes: 90
     steps:
       - name: Clone
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: true
       - name: Dependencies

.github/workflows/test.yml

@@ -21,7 +21,7 @@ jobs:
         go-version: ['1.26.x']
     steps:
       - name: Clone
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: true
       - name: Free disk space
@@ -48,7 +48,7 @@ jobs:
           sudo apt-get update
           sudo apt-get install curl ffmpeg libopus-dev
       - name: Setup Node.js
-        uses: actions/setup-node@v7
+        uses: actions/setup-node@v6
         with:
           node-version: '22'
       - name: Build React UI
@@ -84,7 +84,7 @@ jobs:
         go-version: ['1.26.x']
     steps:
       - name: Clone
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: true
       - name: Setup Go ${{ matrix.go-version }}
@@ -100,7 +100,7 @@ jobs:
           brew install protobuf grpc make protoc-gen-go protoc-gen-go-grpc libomp llvm opus ffmpeg
           pip install --user --no-cache-dir grpcio-tools grpcio
       - name: Setup Node.js
-        uses: actions/setup-node@v7
+        uses: actions/setup-node@v6
         with:
           node-version: '22'
       - name: Build React UI
@@ -121,19 +121,3 @@ jobs:
           detached: true
           connect-timeout-seconds: 180
           limit-access-to-actor: true
-
-  # Fast standalone unit tests for the backends' pure C++ helpers - currently the
-  # llama-cpp message reconstruction (backend/cpp/llama-cpp/message_content.h),
-  # which guards the OpenAI chat content normalization (mudler/LocalAI#10524,
-  # #7324, #7528). The runner discovers every *_test.cpp under backend/cpp/, so
-  # new pure-C++ unit tests are picked up with no CI changes. These need only the
-  # C++ stdlib + nlohmann/json, so they run on every PR without the full
-  # llama.cpp + gRPC backend build. (The same suite is also wired as an opt-in
-  # CMake/ctest target, -DLLAMA_GRPC_BUILD_TESTS=ON, for in-backend-build runs.)
-  tests-backend-cpp:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Clone
-        uses: actions/checkout@v7
-      - name: Run backend C++ unit tests
-        run: make test-backend-cpp

.github/workflows/tests-aio.yml

@@ -62,7 +62,7 @@ jobs:
           sudo rm -rfv build || true
           df -h
       - name: Clone
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: true
       - name: Dependencies

.github/workflows/tests-e2e.yml

@@ -21,7 +21,7 @@ jobs:
         go-version: ['1.25.x']
     steps:
       - name: Clone
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: true
       - name: Configure apt mirror on runner
@@ -47,7 +47,7 @@ jobs:
           sudo apt-get update
           sudo apt-get install -y build-essential libopus-dev
       - name: Setup Node.js
-        uses: actions/setup-node@v7
+        uses: actions/setup-node@v6
         with:
           node-version: '22'
       - name: Build React UI

.github/workflows/tests-pii-ner-e2e.yml

@@ -1,97 +0,0 @@
----
-name: 'PII NER tier E2E (live GGUF, CPU)'
-
-# Runs the real privacy-filter GGUF NER tier end-to-end on CPU — the gap the
-# hermetic tests/e2e suite cannot cover (it only exercises the in-process
-# pattern tier). Heavy (builds the C++ backend image + downloads a ~2.7 GB
-# GGUF), so it is path-filtered on PRs and otherwise runs nightly / on demand.
-#
-# This drives the container-level harness (tests/e2e-backends) via
-# `make test-extra-backend-privacy-filter`: it builds the privacy-filter image,
-# downloads the model, loads it on CPU, and asserts byte-correct, UTF-8-aligned
-# TokenClassify spans. The complementary HTTP-path specs in tests/e2e
-# (e2e_pii_ner_test.go) Skip unless PII_NER_MODEL_GGUF is wired.
-
-on:
-  workflow_dispatch:
-  schedule:
-    - cron: '0 3 * * *'
-  push:
-    branches:
-      - master
-    paths:
-      - 'backend/cpp/privacy-filter/**'
-      - 'backend/Dockerfile.privacy-filter'
-      - 'core/services/routing/pii/**'
-      - 'core/services/routing/piidetector/**'
-      - 'core/backend/token_classify.go'
-      - 'core/http/endpoints/localai/pii.go'
-      - 'core/schema/pii.go'
-      - 'tests/e2e-backends/**'
-      - 'tests/e2e/e2e_pii_ner_test.go'
-      - 'tests/e2e/e2e_suite_test.go'
-      - '.github/workflows/tests-pii-ner-e2e.yml'
-  pull_request:
-    paths:
-      - 'backend/cpp/privacy-filter/**'
-      - 'backend/Dockerfile.privacy-filter'
-      - 'core/services/routing/pii/**'
-      - 'core/services/routing/piidetector/**'
-      - 'core/backend/token_classify.go'
-      - 'core/http/endpoints/localai/pii.go'
-      - 'core/schema/pii.go'
-      - 'tests/e2e-backends/**'
-      - 'tests/e2e/e2e_pii_ner_test.go'
-      - 'tests/e2e/e2e_suite_test.go'
-      - '.github/workflows/tests-pii-ner-e2e.yml'
-
-concurrency:
-  group: ci-tests-pii-ner-e2e-${{ github.event.pull_request.number || github.sha }}-${{ github.repository }}
-  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
-
-jobs:
-  tests-pii-ner-e2e:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        go-version: ['1.25.x']
-    steps:
-      - name: Clone
-        uses: actions/checkout@v7
-        with:
-          submodules: true
-      - name: Free disk space
-        run: |
-          sudo rm -rf /usr/share/dotnet /usr/local/lib/android /opt/ghc /opt/hostedtoolcache/CodeQL || true
-          sudo docker image prune --all --force || true
-          df -h
-      - name: Configure apt mirror on runner
-        uses: ./.github/actions/configure-apt-mirror
-      - name: Setup Go ${{ matrix.go-version }}
-        uses: actions/setup-go@v5
-        with:
-          go-version: ${{ matrix.go-version }}
-          cache: false
-      - name: Proto Dependencies
-        run: |
-          curl -L -s https://github.com/protocolbuffers/protobuf/releases/download/v26.1/protoc-26.1-linux-x86_64.zip -o protoc.zip && \
-          unzip -j -d /usr/local/bin protoc.zip bin/protoc && \
-          rm protoc.zip
-          go install google.golang.org/protobuf/cmd/protoc-gen-go@v1.34.2
-          go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@1958fcbe2ca8bd93af633f11e97d44e567e945af
-          PATH="$PATH:$HOME/go/bin" make protogen-go
-      - name: Dependencies
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y build-essential
-      # Builds local-ai-backend:privacy-filter, downloads the GGUF, loads it on
-      # CPU and runs the token_classify capability spec (byte-offset contract).
-      - name: Run live PII NER backend E2E
-        run: PATH="$PATH:$HOME/go/bin" make test-extra-backend-privacy-filter
-      - name: Setup tmate session if tests fail
-        if: ${{ failure() }}
-        uses: mxschmitt/action-tmate@v3.23
-        with:
-          detached: true
-          connect-timeout-seconds: 180
-          limit-access-to-actor: true

.github/workflows/tests-ui-e2e.yml

@@ -23,7 +23,7 @@ jobs:
         go-version: ['1.26.x']
     steps:
       - name: Clone
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: true
       - name: Configure apt mirror on runner
@@ -34,7 +34,7 @@ jobs:
           go-version: ${{ matrix.go-version }}
           cache: false
       - name: Setup Node.js
-        uses: actions/setup-node@v7
+        uses: actions/setup-node@v6
         with:
           node-version: '22'
       - name: Setup Bun

.github/workflows/update_swagger.yaml

@@ -10,7 +10,7 @@ jobs:
       fail-fast: false
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v6
       - name: Configure apt mirror on runner
         uses: ./.github/actions/configure-apt-mirror
       - uses: actions/setup-go@v5

.github/workflows/yaml-check.yml

@@ -1,11 +1,6 @@
 name: 'Yamllint GitHub Actions'
 on:
   - pull_request
-
-concurrency:
-  group: ci-yamllint-${{ github.event.pull_request.number || github.sha }}-${{ github.repository }}
-  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
-
 jobs:
   yamllint:
     name: 'Yamllint'

.gitignore

@@ -41,12 +41,7 @@ models/*
 test-models/
 test-dir/
 tests/e2e-aio/backends
-# The mock backend binary built by `make build-mock-backend`. Anchored to its
-# full path: a bare `mock-backend` also matched the *directory* holding the
-# source, so git would not descend into it and adding a file there needed -f.
-# tests/e2e/mock-backend/.gitignore covers the same binary; kept here too so
-# the artifact stays ignored if that scoped file is ever removed.
-/tests/e2e/mock-backend/mock-backend
+mock-backend
 
 release/
 
@@ -96,25 +91,3 @@ core/http/react-ui/test-results/
 
 # Local worktrees
 .worktrees/
-
-# SDD / brainstorm scratch (agent-driven development)
-.superpowers/
-
-# Local Apple signing material (never commit)
-.certs/
-
-# Pinned dev tools (e.g. FizzBee for the realtime-conformance gate)
-.tools/
-
-# FizzBee model-check artifacts: the parser emits <spec>.json next to each
-# .fizz and the checker writes run dirs under out/. Both are regenerated by
-# the realtime-conformance gate; only the .fizz sources are authoritative.
-formal-verification/*.json
-formal-verification/out/
-
-# `go build ./.github/ci/apexentries` drops a binary of the package name into
-# whatever directory it runs in, one `git add -A` away from being committed.
-# Both paths are anchored: an unanchored `apexentries` would also match the
-# package directory itself and untrack the source.
-/apexentries
-/.github/ci/apexentries/apexentries

.goreleaser.yaml

@@ -9,8 +9,7 @@ source:
   enabled: true
   name_template: '{{ .ProjectName }}-{{ .Tag }}-source'
 builds:
-  - id: local-ai
-    main: ./cmd/local-ai
+  - main: ./cmd/local-ai
     env:
       - CGO_ENABLED=0
     ldflags:
@@ -36,19 +35,3 @@ snapshot:
   version_template: "{{ .Tag }}-next"
 changelog:
   use: github-native
-# Sign + notarize the macOS server binary via the quill backend (runs on Linux,
-# no macOS runner needed). Disabled automatically when MACOS_SIGN_P12 is unset
-# (forks / PRs), so those builds stay unsigned and green.
-notarize:
-  macos:
-    - enabled: '{{ isEnvSet "MACOS_SIGN_P12" }}'
-      ids:
-        - local-ai
-      sign:
-        certificate: "{{.Env.MACOS_SIGN_P12}}"
-        password: "{{.Env.MACOS_SIGN_PASSWORD}}"
-      notarize:
-        issuer_id: "{{.Env.MACOS_NOTARY_ISSUER_ID}}"
-        key_id: "{{.Env.MACOS_NOTARY_KEY_ID}}"
-        key: "{{.Env.MACOS_NOTARY_KEY}}"
-        wait: true

.impeccable/live/config.json

@@ -1,6 +0,0 @@
-{
-  "files": ["core/http/react-ui/index.html"],
-  "insertBefore": "</body>",
-  "commentSyntax": "html",
-  "cspChecked": true
-}

AGENTS.md

@@ -35,14 +35,12 @@ LocalAI follows the Linux kernel project's [guidelines for AI coding assistants]
 
 ## Quick Reference
 
-- **Coverage gates**: Never lower a coverage baseline or widen a gate's tolerance to turn a red gate green — the coverage ratchet only moves up. If a change drops coverage, add tests to raise it (e.g. render-smoke specs). See [.agents/building-and-testing.md](.agents/building-and-testing.md).
+- **Git hooks & coverage gates**: Run `make install-hooks` once per clone so the pre-commit lint + coverage gates run. **Never bypass them with `git commit --no-verify`, and never lower a coverage baseline or widen a gate's tolerance to turn a red gate green** — the coverage ratchet only moves up. If a change drops coverage, add tests to raise it (e.g. render-smoke specs). See [.agents/building-and-testing.md](.agents/building-and-testing.md).
 - **Logging**: Use `github.com/mudler/xlog` (same API as slog)
 - **Go style**: Prefer `any` over `interface{}`
 - **Comments**: Explain *why*, not *what*
-- **Docs (docs-with-code rule)**: When you change user-facing behavior (API endpoints, CLI flags, config keys, or features), update the corresponding page under `docs/content/` in the SAME change, not as a follow-up. A user-facing change without a matching docs update is incomplete. See also the documentation conventions in [.agents/coding-style.md](.agents/coding-style.md).
+- **Docs**: Update `docs/content/` when adding features or changing config
 - **New API endpoints**: LocalAI advertises its capability surface in several independent places — swagger `@Tags`, `/api/instructions` registry, auth `RouteFeatureRegistry`, React UI `capabilities.js`, docs. Read [.agents/api-endpoints-and-auth.md](.agents/api-endpoints-and-auth.md) and follow its checklist — missing any surface means clients, admins, and the UI won't know the endpoint exists.
 - **Admin endpoints → MCP tool**: every admin endpoint that an admin would manage conversationally (install/list/edit/toggle/upgrade) MUST also be exposed as an MCP tool in `pkg/mcp/localaitools/`. The LocalAI Assistant chat modality and the standalone `local-ai mcp-server` consume that package; drift between REST and MCP is a real risk. Read [.agents/localai-assistant-mcp.md](.agents/localai-assistant-mcp.md) — the `TestToolHTTPRouteMappingComplete` test fails until you wire the new tool and update the route map.
 - **Build**: Inspect `Makefile` and `.github/workflows/` — ask the user before running long builds
-- **Backend OS coverage**: a new backend must target every OS it can build for, not just Linux. `.github/backend-matrix.yml` has two matrices — `include:` (Linux) and `includeDarwin:` (macOS / Apple Silicon). Most C/C++/GGML and many Python backends build on Darwin too — wire the `includeDarwin` entry + `backend/index.yaml` `metal:` entries, or say in the PR why an OS is unsupported. See the darwin checklist in [.agents/adding-backends.md](.agents/adding-backends.md).
-- **Gallery variant ranking**: a gallery entry can declare `variants` (alternative builds of the same weights), and LocalAI ranks the ones a host can run by engine preference first, size second. A new backend that should be preferred on some hardware must be listed in `engineNamePreferenceRules` in `pkg/system/capabilities.go`; the sibling `backendBuildTagPreferenceRules` speaks build tags rather than engine names, and using the wrong table matches nothing without erroring. See [.agents/adding-backends.md](.agents/adding-backends.md).
 - **UI**: The active UI is the React app in `core/http/react-ui/`. The older Alpine.js/HTML UI in `core/http/static/` is pending deprecation — all new UI work goes in the React UI

CONTRIBUTING.md

@@ -198,6 +198,7 @@ For AI-assisted development, see [`AGENTS.md`](AGENTS.md) (or the equivalent [`C
 
 - Prefer modern Go idioms — for example, use `any` instead of `interface{}`.
 - Use [`golangci-lint`](https://golangci-lint.run) to catch common issues before submitting a PR.
+- Run `make install-hooks` once per clone to enable the pre-commit hook: Go changes run `make lint` + the coverage gate (`make test-coverage-check`); `core/http/react-ui/` changes run the Playwright e2e suite (`make test-ui`). Bypass a single commit with `git commit --no-verify`.
 - Use [`github.com/mudler/xlog`](https://github.com/mudler/xlog) for logging (same API as `slog`). Do not use `fmt.Println` or the standard `log` package for operational logging.
 - Use tab indentation for Go files (as defined in `.editorconfig`).
 
@@ -267,7 +268,7 @@ make test-e2e
 
 ### React UI tests and coverage
 
-The React UI (`core/http/react-ui/`) is covered by Playwright e2e specs, gated by a **monotonic line-coverage ratchet** (`make test-ui-coverage-check`, run in CI). The metric is non-deterministic — a fast local box reads higher than a slow CI runner for the same code — so a small tolerance is unavoidable.
+The React UI (`core/http/react-ui/`) is covered by Playwright e2e specs, gated by a **monotonic line-coverage ratchet** (`make test-ui-coverage-check`, run in CI and pre-commit). The metric is non-deterministic — a fast local box reads higher than a slow CI runner for the same code — so a small tolerance is unavoidable.
 
 **If your change lowers UI coverage, raise it back by adding specs — do not widen the tolerance or hand-lower the baseline.** A *render-smoke* spec (navigate to a page, assert its header is visible) cheaply covers an entire lazy page. See `core/http/react-ui/e2e/page-render-smoke.spec.js` and the full policy in [.agents/building-and-testing.md](.agents/building-and-testing.md#react-ui-coverage).
 

Dockerfile

@@ -12,16 +12,12 @@ ARG APT_MIRROR
 ARG APT_PORTS_MIRROR
 ENV DEBIAN_FRONTEND=noninteractive
 
-# hwdata ships /usr/share/hwdata/pci.ids. Without it, the ghw library we use
-# for hardware detection cannot resolve PCI vendor IDs and fails to enumerate
-# GPUs at all, so the image reports "No GPU detected" (see issue #10941).
 RUN --mount=type=bind,source=.docker/apt-mirror.sh,target=/usr/local/sbin/apt-mirror \
     APT_MIRROR="${APT_MIRROR}" APT_PORTS_MIRROR="${APT_PORTS_MIRROR}" sh /usr/local/sbin/apt-mirror && \
     apt-get update && \
     apt-get install -y --no-install-recommends \
         ca-certificates curl wget espeak-ng libgomp1 \
-        ffmpeg libopenblas0 libopenblas-dev libopus0 sox \
-        hwdata && \
+        ffmpeg libopenblas0 libopenblas-dev libopus0 sox && \
     apt-get clean && \
     rm -rf /var/lib/apt/lists/*
 
@@ -175,17 +171,6 @@ RUN if [ "${BUILD_TYPE}" = "hipblas" ]; then \
     ln -s /opt/rocm-**/lib/llvm/lib/libomp.so /usr/lib/libomp.so \
     ; fi
 
-# ROCm's bundled libdrm_amdgpu is built with a hardcoded fallback lookup path
-# for the ASIC ID table (/opt/amdgpu/share/libdrm/amdgpu.ids), which only exists
-# if AMD's full amdgpu graphics/DKMS stack is installed. This compute-only image
-# doesn't have it, so hipblas/rocBLAS log "No such file or directory" on every
-# model load and can fail to identify the GPU. Point it at the equivalent file
-# Ubuntu's libdrm-common package already ships.
-RUN if [ "${BUILD_TYPE}" = "hipblas" ] && [ -f /usr/share/libdrm/amdgpu.ids ] && [ ! -e /opt/amdgpu/share/libdrm/amdgpu.ids ]; then \
-    mkdir -p /opt/amdgpu/share/libdrm && \
-    ln -s /usr/share/libdrm/amdgpu.ids /opt/amdgpu/share/libdrm/amdgpu.ids \
-    ; fi
-
 RUN expr "${BUILD_TYPE}" = intel && echo "intel" > /run/localai/capability || echo "not intel"
 
 # Cuda
@@ -393,12 +378,7 @@ RUN go install github.com/mikefarah/yq/v4@latest
 # If you cannot find a more suitable place for an addition, this layer is a suitable place for it.
 FROM requirements-drivers
 
-# Optional override for the HEALTHCHECK target. Left empty so healthcheck.sh
-# derives the endpoint from the mode the container is actually running — the
-# same image runs `local-ai run` (HTTP on 8080) and `local-ai worker` (HTTP on
-# the gRPC base port minus one), and a hardcoded default marked every worker
-# permanently unhealthy (#10987). Set it to pin an explicit URL.
-ENV HEALTHCHECK_ENDPOINT=""
+ENV HEALTHCHECK_ENDPOINT=http://localhost:8080/readyz
 
 ARG CUDA_MAJOR_VERSION=12
 ENV NVIDIA_DRIVER_CAPABILITIES=compute,utility
@@ -408,7 +388,6 @@ ENV NVIDIA_VISIBLE_DEVICES=all
 WORKDIR /
 
 COPY ./entrypoint.sh .
-COPY ./scripts/build/healthcheck.sh .
 
 # Copy the binary
 COPY --from=builder /build/local-ai ./
@@ -419,22 +398,9 @@ RUN --mount=from=builder,src=/build/,dst=/mnt/build \
 # Make sure the models directory exists
 RUN mkdir -p /models /backends /data
 
-# Define the health check command.
-#
-# --start-period is the knob for slow starts, not --timeout/--retries. Since
-# #10949 a frontend's startup preload materializes HuggingFace artifacts before
-# the HTTP server binds (31 GB observed on a live cluster), so a healthy replica
-# can legitimately fail probes for a long time. Failures inside the start period
-# leave the container `starting` instead of burning retries, and the period ends
-# early on the first success — so a generous value costs a fast-starting
-# container nothing. A process that actually died is handled by the restart
-# policy, not by health.
-#
-# --timeout is a per-probe deadline: 10m meant a wedged probe could hang for ten
-# minutes and stretch detection without bound. A localhost curl that has not
-# answered in 10s is itself the fault being detected.
-HEALTHCHECK --start-period=60m --interval=1m --timeout=10s --retries=3 \
-  CMD /healthcheck.sh
+# Define the health check command
+HEALTHCHECK --interval=1m --timeout=10m --retries=10 \
+  CMD curl -f ${HEALTHCHECK_ENDPOINT} || exit 1
 
 VOLUME /models /backends /configuration /data
 EXPOSE 8080

Makefile

@@ -1,5 +1,5 @@
 # Disable parallel execution for backend builds
-.NOTPARALLEL: backends/diffusers backends/llama-cpp backends/turboquant backends/bonsai backends/outetts backends/piper backends/stablediffusion-ggml backends/whisper backends/crispasr backends/parakeet-cpp backends/moss-transcribe-cpp backends/faster-whisper backends/silero-vad backends/local-store backends/cloud-proxy backends/huggingface backends/rfdetr backends/rfdetr-cpp backends/insightface backends/speaker-recognition backends/kitten-tts backends/kokoro backends/chatterbox backends/llama-cpp-darwin backends/neutts build-darwin-python-backend build-darwin-go-backend backends/mlx backends/diffuser-darwin backends/mlx-vlm backends/mlx-audio backends/mlx-distributed backends/stablediffusion-ggml-darwin backends/vllm backends/vllm-omni backends/longcat-video backends/sglang backends/moonshine backends/pocket-tts backends/qwen-tts backends/faster-qwen3-tts backends/qwen-asr backends/nemo backends/voxcpm backends/whisperx backends/ace-step backends/acestep-cpp backends/fish-speech backends/voxtral backends/opus backends/trl backends/llama-cpp-quantization backends/kokoros backends/sam3-cpp backends/qwen3-tts-cpp backends/moss-tts-cpp backends/magpie-tts-cpp backends/vllm-cpp backends/omnivoice-cpp backends/vibevoice-cpp backends/localvqe backends/tinygrad backends/sherpa-onnx backends/ds4 backends/ds4-darwin backends/liquid-audio backends/supertonic backends/depth-anything-cpp backends/privacy-filter backends/privacy-filter-darwin
+.NOTPARALLEL: backends/diffusers backends/llama-cpp backends/turboquant backends/outetts backends/piper backends/stablediffusion-ggml backends/whisper backends/crispasr backends/parakeet-cpp backends/faster-whisper backends/silero-vad backends/local-store backends/huggingface backends/rfdetr backends/rfdetr-cpp backends/insightface backends/speaker-recognition backends/kitten-tts backends/kokoro backends/chatterbox backends/llama-cpp-darwin backends/neutts build-darwin-python-backend build-darwin-go-backend backends/mlx backends/diffuser-darwin backends/mlx-vlm backends/mlx-audio backends/mlx-distributed backends/stablediffusion-ggml-darwin backends/vllm backends/vllm-omni backends/sglang backends/moonshine backends/pocket-tts backends/qwen-tts backends/faster-qwen3-tts backends/qwen-asr backends/nemo backends/voxcpm backends/whisperx backends/ace-step backends/acestep-cpp backends/fish-speech backends/voxtral backends/opus backends/trl backends/llama-cpp-quantization backends/kokoros backends/sam3-cpp backends/qwen3-tts-cpp backends/omnivoice-cpp backends/vibevoice-cpp backends/localvqe backends/tinygrad backends/sherpa-onnx backends/ds4 backends/ds4-darwin backends/liquid-audio backends/supertonic backends/depth-anything-cpp backends/privacy-filter
 
 GOCMD=go
 GOTEST=$(GOCMD) test
@@ -103,7 +103,7 @@ COVERAGE_E2E_LABELS?=!real-models
 COVERAGE_EXCLUDE_RE?=grpc/proto/.*[.]pb[.]go
 
 
-.PHONY: all test test-coverage test-coverage-baseline test-coverage-check test-backend-cpp test-build-scripts test-ui test-ui-coverage-baseline test-ui-coverage-check build vendor lint lint-all
+.PHONY: all test test-coverage test-coverage-baseline test-coverage-check test-ui test-ui-coverage-baseline test-ui-coverage-check install-hooks build vendor lint lint-all
 
 all: help
 
@@ -201,27 +201,6 @@ test: prepare-test
 	OPUS_SHIM_LIBRARY=$(abspath ./pkg/opus/shim/libopusshim.so) \
 	$(GOCMD) run github.com/onsi/ginkgo/v2/ginkgo --flake-attempts $(TEST_FLAKES) --fail-fast -v -r $(TEST_PATHS)
 
-## Compiles and runs the standalone C++ unit tests for the backends (pure
-## helpers that depend only on the stdlib + nlohmann/json, no full backend
-## build). Discovers every *_test.cpp under backend/cpp/ - see
-## backend/cpp/run-unit-tests.sh. Set NLOHMANN_INCLUDE to skip the header fetch.
-test-backend-cpp:
-	bash backend/cpp/run-unit-tests.sh
-
-## Runs the shell-level regression tests for the image packaging scripts
-## (scripts/build/*_test.sh). These guard invariants that only ever break
-## inside a container build - a missing transitive dep, a partial cuDNN
-## family - and that no Go test can observe. Needs only bash + gcc + ldd.
-test-build-scripts:
-	@set -e; for t in scripts/build/*_test.sh; do echo "== $$t"; bash "$$t"; done
-
-## Runs the unit tests for the CI helper scripts under scripts/lib/. Currently
-## the backend matrix path filter, whose failure mode is invisible in CI: it
-## emits an empty matrix, every job goes green, and the change ships to no
-## image at all (see PR #10946). Plain `node --test`, no dependencies.
-test-ci-scripts:
-	@set -e; for t in scripts/lib/*_test.mjs; do echo "== $$t"; node --test "$$t"; done
-
 ## Runs the core suite ($(TEST_PATHS)) with statement-coverage instrumentation
 ## and writes a merged profile to $(COVERAGE_PROFILE). Deliberately omits
 ## --fail-fast so a single failure doesn't truncate the coverage number, and
@@ -269,7 +248,8 @@ LINT_EXCLUDE_DIRS_RE=/(backend/go/(piper|silero-vad|llm)|cmd/launcher)(/|$$)
 
 ## Set LINT_NEW_FROM to a git ref to override .golangci.yml's
 ## new-from-merge-base (origin/master). Useful from a fork clone where
-## origin/master is stale relative to the canonical repo.
+## origin/master is stale relative to the canonical repo — the pre-commit
+## hook passes the resolved upstream ref here so local lint matches CI.
 LINT_NEW_FROM?=
 lint:
 	@command -v golangci-lint >/dev/null 2>&1 || { \
@@ -288,6 +268,17 @@ lint-all:
 	}
 	golangci-lint run --new=false --new-from-merge-base= --new-from-rev= $$(go list -e -f '{{.Dir}}' ./... | grep -vE '$(LINT_EXCLUDE_DIRS_RE)')
 
+########################################################
+## Git hooks
+########################################################
+## Points git at the versioned .githooks/ directory so the pre-commit hook
+## (lint + coverage gate) runs locally. Run once per clone. Undo with:
+## `git config --unset core.hooksPath`. Skip a single commit with
+## `git commit --no-verify`.
+install-hooks:
+	git config core.hooksPath .githooks
+	@echo 'Installed git hooks: core.hooksPath -> .githooks (pre-commit runs lint + test-coverage-check on Go changes)'
+
 ########################################################
 ## E2E AIO tests (uses standard image with pre-configured models)
 ########################################################
@@ -407,23 +398,6 @@ test-realtime: build-mock-backend
 	@echo 'Running realtime e2e tests (mock backend)'
 	$(GOCMD) run github.com/onsi/ginkgo/v2/ginkgo --label-filter="Realtime && !real-models" --flake-attempts $(TEST_FLAKES) -v -r ./tests/e2e
 
-# Verify the realtime state-machine implementations conform to their formal
-# designs (Go transition/rapid tests under -race + FizzBee model check of the
-# authoritative specs). See docs/design/realtime-state-machines.md (Part 6) and
-# docs/design/specs/README.md.
-test-realtime-conformance:
-	GOCMD=$(GOCMD) ./scripts/realtime-conformance.sh
-
-# Verify the shared model-loader shutdown behavior independently of any API
-# modality (focused loader/gRPC/distributed/worker tests under -race + FizzBee).
-test-model-lifecycle-conformance:
-	GOCMD=$(GOCMD) ./scripts/model-lifecycle-conformance.sh
-
-# Install the pinned, checksum-verified FizzBee model checker (into .tools/,
-# gitignored) used by the conformance targets. Idempotent; no-op if present.
-install-fizzbee:
-	./scripts/install-fizzbee.sh
-
 # Container-based real-model realtime testing. Build env vars / pipeline
 # definition kept here so test-realtime-models-docker can drive a fully wired
 # pipeline (VAD + STT + LLM + TTS) from inside a containerised runner.
@@ -572,7 +546,6 @@ prepare-test-extra: protogen-python
 	$(MAKE) -C backend/python/chatterbox
 	$(MAKE) -C backend/python/vllm
 	$(MAKE) -C backend/python/vllm-omni
-	$(MAKE) -C backend/python/longcat-video
 	$(MAKE) -C backend/python/sglang
 	$(MAKE) -C backend/python/vibevoice
 	$(MAKE) -C backend/python/liquid-audio
@@ -602,7 +575,6 @@ test-extra: prepare-test-extra
 	$(MAKE) -C backend/python/chatterbox test
 	$(MAKE) -C backend/python/vllm test
 	$(MAKE) -C backend/python/vllm-omni test
-	$(MAKE) -C backend/python/longcat-video test
 	$(MAKE) -C backend/python/vibevoice test
 	$(MAKE) -C backend/python/liquid-audio test
 	$(MAKE) -C backend/python/moonshine test
@@ -625,7 +597,6 @@ test-extra: prepare-test-extra
 	$(MAKE) -C backend/go/locate-anything-cpp test
 	$(MAKE) -C backend/go/depth-anything-cpp test
 	$(MAKE) -C backend/go/supertonic test
-	$(MAKE) -C backend/go/vllm-cpp test
 
 ##
 ## End-to-end gRPC tests that exercise a built backend container image.
@@ -655,9 +626,6 @@ test-extra: prepare-test-extra
 ## suite against it.
 ##
 BACKEND_TEST_MODEL_URL?=https://huggingface.co/Qwen/Qwen3-0.6B-GGUF/resolve/main/Qwen3-0.6B-Q8_0.gguf
-## Suite timeout for `go test`. Wrappers whose model download alone can eat
-## most of the default (multi-GB models on a slow HF CDN day) override this.
-BACKEND_TEST_TIMEOUT?=30m
 
 ## Generic target — runs the suite against whatever BACKEND_IMAGE points at.
 ## Depends on protogen-go so pkg/grpc/proto is generated before `go test`.
@@ -685,7 +653,7 @@ test-extra-backend: protogen-go
 	BACKEND_TEST_FACE_IMAGE_3_URL="$$BACKEND_TEST_FACE_IMAGE_3_URL" \
 	BACKEND_TEST_FACE_IMAGE_3_FILE="$$BACKEND_TEST_FACE_IMAGE_3_FILE" \
 	BACKEND_TEST_VERIFY_DISTANCE_CEILING="$$BACKEND_TEST_VERIFY_DISTANCE_CEILING" \
-	go test -v -timeout $(BACKEND_TEST_TIMEOUT) ./tests/e2e-backends/...
+	go test -v -timeout 30m ./tests/e2e-backends/...
 
 ## Convenience wrappers: build the image, then exercise it.
 test-extra-backend-llama-cpp: docker-build-llama-cpp
@@ -708,16 +676,6 @@ test-extra-backend-turboquant: docker-build-turboquant
 	BACKEND_TEST_CACHE_TYPE_V=turbo3 \
 	$(MAKE) test-extra-backend
 
-## bonsai: exercises the llama.cpp-fork backend with a real Q1_0 (1-bit) model —
-## the PrismML Bonsai-8B GGUF, whose weight quant is *only* decodable by the fork's
-## Q1_0 kernels. Loading it is what makes this backend distinct from stock llama-cpp;
-## a standard-quant model would only test the upstream code path the llama-cpp backend
-## already covers.
-test-extra-backend-bonsai: docker-build-bonsai
-	BACKEND_IMAGE=local-ai-backend:bonsai \
-	BACKEND_TEST_MODEL_URL=https://huggingface.co/prism-ml/Bonsai-8B-gguf/resolve/main/Bonsai-8B-Q1_0.gguf \
-	$(MAKE) test-extra-backend
-
 ## Audio transcription wrapper for the llama-cpp backend.
 ## Drives the new AudioTranscription / AudioTranscriptionStream RPCs against
 ## ggml-org/Qwen3-ASR-0.6B-GGUF (a small ASR model that requires its mmproj
@@ -732,16 +690,6 @@ test-extra-backend-llama-cpp-transcription: docker-build-llama-cpp
 	BACKEND_TEST_CTX_SIZE=2048 \
 	$(MAKE) test-extra-backend
 
-## privacy-filter: the PII/NER token-classification backend. Exercises the
-## TokenClassify RPC and asserts byte-correct, UTF-8-aligned span offsets
-## against the openai-privacy-filter multilingual GGUF (CPU-runnable, ~50M
-## active params). This is the live-backend coverage for the PII NER tier.
-test-extra-backend-privacy-filter: docker-build-privacy-filter
-	BACKEND_IMAGE=local-ai-backend:privacy-filter \
-	BACKEND_TEST_MODEL_URL=https://huggingface.co/LocalAI-io/privacy-filter-multilingual-GGUF/resolve/main/privacy-filter-multilingual-f16.gguf \
-	BACKEND_TEST_CAPS=health,load,token_classify \
-	$(MAKE) test-extra-backend
-
 ## vllm is resolved from a HuggingFace model id (no file download) and
 ## exercises Predict + streaming + tool-call extraction via the hermes parser.
 ## Requires a host CPU with the SIMD instructions the prebuilt vllm CPU
@@ -1035,7 +983,6 @@ test-extra-backend-vibevoice-cpp-tts: docker-build-vibevoice-cpp
 ## post-image disk budget.
 test-extra-backend-vibevoice-cpp-transcription: docker-build-vibevoice-cpp
 	BACKEND_IMAGE=local-ai-backend:vibevoice-cpp \
-	BACKEND_TEST_TIMEOUT=120m \
 	BACKEND_TEST_MODEL_URL='https://huggingface.co/mudler/vibevoice.cpp-models/resolve/main/vibevoice-asr-q4_k.gguf#vibevoice-asr-q4_k.gguf' \
 	BACKEND_TEST_EXTRA_FILES='https://huggingface.co/mudler/vibevoice.cpp-models/resolve/main/tokenizer.gguf#tokenizer.gguf' \
 	BACKEND_TEST_AUDIO_URL=https://github.com/ggml-org/whisper.cpp/raw/master/samples/jfk.wav \
@@ -1063,19 +1010,7 @@ test-extra-backend-whisper-transcription: docker-build-whisper
 ## is reachable.
 test-extra-backend-parakeet-cpp-transcription: docker-build-parakeet-cpp
 	BACKEND_IMAGE=local-ai-backend:parakeet-cpp \
-	BACKEND_TEST_MODEL_URL=https://huggingface.co/mudler/parakeet-cpp-gguf/resolve/main/realtime_eou_120m-v1-f16.gguf \
-	BACKEND_TEST_AUDIO_URL=https://github.com/ggml-org/whisper.cpp/raw/master/samples/jfk.wav \
-	BACKEND_TEST_CAPS=health,load,transcription \
-	$(MAKE) test-extra-backend
-
-## Audio transcription wrapper for the moss-transcribe-cpp (moss-transcribe.cpp
-## ggml port) backend. Mirrors test-extra-backend-parakeet-cpp-transcription:
-## drives the AudioTranscription RPC against a published MOSS GGUF using the JFK
-## 11s clip from whisper.cpp's CI samples. Not part of the default test suite -
-## run explicitly once the pinned model URL is reachable.
-test-extra-backend-moss-transcribe-cpp-transcription: docker-build-moss-transcribe-cpp
-	BACKEND_IMAGE=local-ai-backend:moss-transcribe-cpp \
-	BACKEND_TEST_MODEL_URL=https://huggingface.co/mudler/moss-transcribe.cpp-gguf/resolve/main/moss-transcribe-q5_k.gguf \
+	BACKEND_TEST_MODEL_URL=https://huggingface.co/mudler/parakeet-cpp-gguf/resolve/main/tdt_ctc-110m-f16.gguf \
 	BACKEND_TEST_AUDIO_URL=https://github.com/ggml-org/whisper.cpp/raw/master/samples/jfk.wav \
 	BACKEND_TEST_CAPS=health,load,transcription \
 	$(MAKE) test-extra-backend
@@ -1184,10 +1119,6 @@ backends/ds4-darwin: build
 	bash ./scripts/build/ds4-darwin.sh
 	./local-ai backends install "ocifile://$(abspath ./backend-images/ds4.tar)"
 
-backends/privacy-filter-darwin: build
-	bash ./scripts/build/privacy-filter-darwin.sh
-	./local-ai backends install "ocifile://$(abspath ./backend-images/privacy-filter.tar)"
-
 build-darwin-python-backend: build
 	bash ./scripts/build/python-darwin.sh
 
@@ -1229,10 +1160,6 @@ BACKEND_IK_LLAMA_CPP = ik-llama-cpp|ik-llama-cpp|.|false|false
 # turboquant is a llama.cpp fork with TurboQuant KV-cache quantization.
 # Reuses backend/cpp/llama-cpp grpc-server sources via a thin wrapper Makefile.
 BACKEND_TURBOQUANT = turboquant|turboquant|.|false|false
-# bonsai is a llama.cpp fork (PrismML) adding the Q1_0 (1-bit) and Q2_0 (ternary)
-# weight-quant kernels the Bonsai / Ternary-Bonsai models ship in. Reuses
-# backend/cpp/llama-cpp grpc-server sources via a thin wrapper Makefile.
-BACKEND_BONSAI = bonsai|bonsai|.|false|false
 # ds4 is antirez/ds4, a DeepSeek V4 Flash-specific inference engine.
 # Single-model; hardware-only validation lives at tests/e2e-backends/
 # (BACKEND_BINARY mode); see docs/superpowers/plans/2026-05-11-ds4-backend.md.
@@ -1252,14 +1179,10 @@ BACKEND_STABLEDIFFUSION_GGML = stablediffusion-ggml|golang|.|--progress=plain|tr
 BACKEND_WHISPER = whisper|golang|.|false|true
 BACKEND_CRISPASR = crispasr|golang|.|false|true
 BACKEND_PARAKEET_CPP = parakeet-cpp|golang|.|false|true
-BACKEND_MOSS_TRANSCRIBE_CPP = moss-transcribe-cpp|golang|.|false|true
 BACKEND_DEPTH_ANYTHING_CPP = depth-anything-cpp|golang|.|false|true
 BACKEND_VOXTRAL = voxtral|golang|.|false|true
 BACKEND_ACESTEP_CPP = acestep-cpp|golang|.|false|true
 BACKEND_QWEN3_TTS_CPP = qwen3-tts-cpp|golang|.|false|true
-BACKEND_MOSS_TTS_CPP = moss-tts-cpp|golang|.|false|true
-BACKEND_MAGPIE_TTS_CPP = magpie-tts-cpp|golang|.|false|true
-BACKEND_VLLM_CPP = vllm-cpp|golang|.|false|true
 BACKEND_OMNIVOICE_CPP = omnivoice-cpp|golang|.|false|true
 BACKEND_VIBEVOICE_CPP = vibevoice-cpp|golang|.|false|true
 BACKEND_LOCALVQE = localvqe|golang|.|false|true
@@ -1281,7 +1204,6 @@ BACKEND_NEUTTS = neutts|python|.|false|true
 BACKEND_KOKORO = kokoro|python|.|false|true
 BACKEND_VLLM = vllm|python|.|false|true
 BACKEND_VLLM_OMNI = vllm-omni|python|.|false|true
-BACKEND_LONGCAT_VIDEO = longcat-video|python|.|--progress=plain|true
 BACKEND_SGLANG = sglang|python|.|false|true
 BACKEND_DIFFUSERS = diffusers|python|.|--progress=plain|true
 BACKEND_CHATTERBOX = chatterbox|python|.|false|true
@@ -1339,7 +1261,6 @@ endef
 $(eval $(call generate-docker-build-target,$(BACKEND_LLAMA_CPP)))
 $(eval $(call generate-docker-build-target,$(BACKEND_IK_LLAMA_CPP)))
 $(eval $(call generate-docker-build-target,$(BACKEND_TURBOQUANT)))
-$(eval $(call generate-docker-build-target,$(BACKEND_BONSAI)))
 $(eval $(call generate-docker-build-target,$(BACKEND_DS4)))
 $(eval $(call generate-docker-build-target,$(BACKEND_PRIVACY_FILTER)))
 $(eval $(call generate-docker-build-target,$(BACKEND_PIPER)))
@@ -1351,7 +1272,6 @@ $(eval $(call generate-docker-build-target,$(BACKEND_STABLEDIFFUSION_GGML)))
 $(eval $(call generate-docker-build-target,$(BACKEND_WHISPER)))
 $(eval $(call generate-docker-build-target,$(BACKEND_CRISPASR)))
 $(eval $(call generate-docker-build-target,$(BACKEND_PARAKEET_CPP)))
-$(eval $(call generate-docker-build-target,$(BACKEND_MOSS_TRANSCRIBE_CPP)))
 $(eval $(call generate-docker-build-target,$(BACKEND_DEPTH_ANYTHING_CPP)))
 $(eval $(call generate-docker-build-target,$(BACKEND_VOXTRAL)))
 $(eval $(call generate-docker-build-target,$(BACKEND_OPUS)))
@@ -1368,7 +1288,6 @@ $(eval $(call generate-docker-build-target,$(BACKEND_NEUTTS)))
 $(eval $(call generate-docker-build-target,$(BACKEND_KOKORO)))
 $(eval $(call generate-docker-build-target,$(BACKEND_VLLM)))
 $(eval $(call generate-docker-build-target,$(BACKEND_VLLM_OMNI)))
-$(eval $(call generate-docker-build-target,$(BACKEND_LONGCAT_VIDEO)))
 $(eval $(call generate-docker-build-target,$(BACKEND_SGLANG)))
 $(eval $(call generate-docker-build-target,$(BACKEND_DIFFUSERS)))
 $(eval $(call generate-docker-build-target,$(BACKEND_CHATTERBOX)))
@@ -1386,9 +1305,6 @@ $(eval $(call generate-docker-build-target,$(BACKEND_WHISPERX)))
 $(eval $(call generate-docker-build-target,$(BACKEND_ACE_STEP)))
 $(eval $(call generate-docker-build-target,$(BACKEND_ACESTEP_CPP)))
 $(eval $(call generate-docker-build-target,$(BACKEND_QWEN3_TTS_CPP)))
-$(eval $(call generate-docker-build-target,$(BACKEND_MOSS_TTS_CPP)))
-$(eval $(call generate-docker-build-target,$(BACKEND_MAGPIE_TTS_CPP)))
-$(eval $(call generate-docker-build-target,$(BACKEND_VLLM_CPP)))
 $(eval $(call generate-docker-build-target,$(BACKEND_OMNIVOICE_CPP)))
 $(eval $(call generate-docker-build-target,$(BACKEND_VIBEVOICE_CPP)))
 $(eval $(call generate-docker-build-target,$(BACKEND_LOCALVQE)))
@@ -1408,7 +1324,7 @@ $(eval $(call generate-docker-build-target,$(BACKEND_SUPERTONIC)))
 docker-save-%: backend-images
 	docker save local-ai-backend:$* -o backend-images/$*.tar
 
-docker-build-backends: docker-build-llama-cpp docker-build-ik-llama-cpp docker-build-turboquant docker-build-bonsai docker-build-ds4 docker-build-rerankers docker-build-vllm docker-build-vllm-omni docker-build-longcat-video docker-build-sglang docker-build-transformers docker-build-outetts docker-build-diffusers docker-build-kokoro docker-build-faster-whisper docker-build-crispasr docker-build-coqui docker-build-chatterbox docker-build-vibevoice docker-build-liquid-audio docker-build-moonshine docker-build-pocket-tts docker-build-qwen-tts docker-build-fish-speech docker-build-faster-qwen3-tts docker-build-qwen-asr docker-build-nemo docker-build-voxcpm docker-build-whisperx docker-build-ace-step docker-build-acestep-cpp docker-build-voxtral docker-build-mlx-distributed docker-build-trl docker-build-llama-cpp-quantization docker-build-tinygrad docker-build-kokoros docker-build-sam3-cpp docker-build-rfdetr-cpp docker-build-qwen3-tts-cpp docker-build-moss-tts-cpp docker-build-magpie-tts-cpp docker-build-vllm-cpp docker-build-omnivoice-cpp docker-build-vibevoice-cpp docker-build-localvqe docker-build-insightface docker-build-speaker-recognition docker-build-sherpa-onnx docker-build-cloud-proxy docker-build-supertonic docker-build-depth-anything-cpp docker-build-moss-transcribe-cpp docker-build-privacy-filter
+docker-build-backends: docker-build-llama-cpp docker-build-ik-llama-cpp docker-build-turboquant docker-build-ds4 docker-build-rerankers docker-build-vllm docker-build-vllm-omni docker-build-sglang docker-build-transformers docker-build-outetts docker-build-diffusers docker-build-kokoro docker-build-faster-whisper docker-build-crispasr docker-build-coqui docker-build-chatterbox docker-build-vibevoice docker-build-liquid-audio docker-build-moonshine docker-build-pocket-tts docker-build-qwen-tts docker-build-fish-speech docker-build-faster-qwen3-tts docker-build-qwen-asr docker-build-nemo docker-build-voxcpm docker-build-whisperx docker-build-ace-step docker-build-acestep-cpp docker-build-voxtral docker-build-mlx-distributed docker-build-trl docker-build-llama-cpp-quantization docker-build-tinygrad docker-build-kokoros docker-build-sam3-cpp docker-build-rfdetr-cpp docker-build-qwen3-tts-cpp docker-build-omnivoice-cpp docker-build-vibevoice-cpp docker-build-localvqe docker-build-insightface docker-build-speaker-recognition docker-build-sherpa-onnx docker-build-cloud-proxy docker-build-supertonic docker-build-depth-anything-cpp docker-build-privacy-filter
 
 ########################################################
 ### Mock Backend for E2E Tests
@@ -1443,7 +1359,7 @@ test-ui-e2e: build-ui-test-server
 UI_TEST_WORKERS ?=
 PLAYWRIGHT_WORKERS_FLAG = $(if $(UI_TEST_WORKERS),--workers=$(UI_TEST_WORKERS),)
 
-## Fast Playwright e2e run for local React UI validation.
+## Fast Playwright e2e run used by the pre-commit hook on React UI changes.
 ## Force-rebuilds the (non-instrumented) dist so the suite tests the working
 ## tree — not a stale dist the `react-ui` skip-guard would leave — re-embeds
 ## it into ui-test-server, and runs the specs. Uses the nix-provided browser
@@ -1523,37 +1439,13 @@ docs: docs/static/gallery.html
 ########################################################
 
 ## fyne cross-platform build
-# Build LocalAI.app from the launcher via fyne (metadata read from cmd/launcher/FyneApp.toml).
-# Signing happens via contrib/macos/sign-and-notarize.sh, which is a no-op when the signing
-# secrets are unset, so unsigned local/fork builds keep working.
-build-launcher-darwin:
-	rm -rf dist/LocalAI.app cmd/launcher/LocalAI.app
-	mkdir -p dist
-	cd cmd/launcher && go run fyne.io/tools/cmd/fyne@latest package -os darwin -icon ../../core/http/static/logo.png --executable $(LAUNCHER_BINARY_NAME)
-	mv cmd/launcher/LocalAI.app dist/LocalAI.app
-	bash contrib/macos/sign-and-notarize.sh sign dist/LocalAI.app
-
-# Notarize + staple the .app itself, then wrap it into a drag-to-Applications
-# DMG via hdiutil and sign the DMG. The app is stapled BEFORE packaging so the
-# bundle carries its own ticket and verifies offline (a dmg-only staple leaves
-# the app relying on an online Gatekeeper check, which fails offline / once the
-# app is copied out of the dmg). No-op without notary secrets.
-dmg-launcher-darwin: build-launcher-darwin
-	bash contrib/macos/sign-and-notarize.sh notarize-app dist/LocalAI.app
-	rm -rf dist/dmg dist/LocalAI.dmg
-	mkdir -p dist/dmg
-	cp -R dist/LocalAI.app dist/dmg/LocalAI.app
-	ln -s /Applications dist/dmg/Applications
-	hdiutil create -volname "LocalAI" -srcfolder dist/dmg -ov -format UDZO dist/LocalAI.dmg
-	bash contrib/macos/sign-and-notarize.sh sign dist/LocalAI.dmg
-
-# Submit the DMG to Apple notarization and staple the ticket (no-op without notary secrets).
-notarize-launcher-darwin: dmg-launcher-darwin
-	bash contrib/macos/sign-and-notarize.sh notarize dist/LocalAI.dmg
-
-# Single entrypoint for CI: build -> sign app -> notarize+staple app -> dmg -> sign dmg -> notarize+staple dmg.
-release-launcher-darwin: notarize-launcher-darwin
-	@echo "dist/LocalAI.dmg is ready"
+build-launcher-darwin: build-launcher
+	go run github.com/tiagomelo/macos-dmg-creator/cmd/createdmg@latest \
+	--appName "LocalAI" \
+	--appBinaryPath "$(LAUNCHER_BINARY_NAME)" \
+	--bundleIdentifier "com.localai.launcher" \
+	--iconPath "core/http/static/logo.png" \
+	--outputDir "dist/"
 
 build-launcher-linux:
-	cd cmd/launcher && go run fyne.io/tools/cmd/fyne@latest package -os linux -icon ../../core/http/static/logo.png --executable $(LAUNCHER_BINARY_NAME)-linux && mv LocalAI.tar.xz ../../$(LAUNCHER_BINARY_NAME)-linux.tar.xz
+	cd cmd/launcher && go run fyne.io/tools/cmd/fyne@latest package -os linux -icon ../../core/http/static/logo.png --executable $(LAUNCHER_BINARY_NAME)-linux && mv launcher.tar.xz ../../$(LAUNCHER_BINARY_NAME)-linux.tar.xz

README.md

@@ -177,7 +177,7 @@ For more details, see the [Getting Started guide](https://localai.io/basics/gett
 
 ## Latest News
 
-- **June 2026**: New native biometric backends from the LocalAI team: [voice-detect.cpp](https://github.com/localai-org/voice-detect.cpp) for speaker recognition and voice analysis (ECAPA-TDNN, WeSpeaker, ERes2Net, CAM++, wav2vec2 age/gender/emotion) and [face-detect.cpp](https://github.com/mudler/face-detect.cpp) for face detection, recognition, demographics and anti-spoofing (SCRFD/ArcFace, YuNet/SFace). Both are from-scratch C++/ggml engines with no Python or onnxruntime at inference, self-contained GGUF weights, bit-exact parity with the reference, and GPU cuDNN parity, replacing the heavier Python `insightface` and `speaker-recognition` backends ([PR #10441](https://github.com/mudler/LocalAI/pull/10441)).
+- **June 2026**: New native biometric backends from the LocalAI team: [voice-detect.cpp](https://github.com/mudler/voice-detect.cpp) for speaker recognition and voice analysis (ECAPA-TDNN, WeSpeaker, ERes2Net, CAM++, wav2vec2 age/gender/emotion) and [face-detect.cpp](https://github.com/mudler/face-detect.cpp) for face detection, recognition, demographics and anti-spoofing (SCRFD/ArcFace, YuNet/SFace). Both are from-scratch C++/ggml engines with no Python or onnxruntime at inference, self-contained GGUF weights, bit-exact parity with the reference, and GPU cuDNN parity, replacing the heavier Python `insightface` and `speaker-recognition` backends ([PR #10441](https://github.com/mudler/LocalAI/pull/10441)).
 - **June 2026**: New [realtime voice assistant demo](https://github.com/localai-org/localai-realtime-demo) (a tiny Go client for the Realtime API with a full talk-back voice loop and tool calling), plus [streaming of the realtime LLM / TTS / transcription pipeline stages](https://github.com/mudler/LocalAI/pull/10176) and [configurable WebRTC ICE candidates](https://github.com/mudler/LocalAI/pull/10231).
 - **June 2026**: Big speech push: the [parakeet.cpp](https://github.com/mudler/parakeet.cpp) ASR engine gains [NeMo-faithful segment timestamps](https://github.com/mudler/LocalAI/pull/10207), a [multilingual streaming Nemotron-3.5 model](https://github.com/mudler/LocalAI/pull/10199), [dynamic batching for concurrent transcription](https://github.com/mudler/LocalAI/pull/10112) and [CUDA graphs](https://github.com/mudler/LocalAI/pull/10273); the new [CrispASR backend](https://github.com/mudler/LocalAI/pull/10099) adds multi-architecture ASR + TTS, and [60 Piper TTS voices across 42 languages](https://github.com/mudler/LocalAI/pull/10296) land in the gallery (plus [per-request TTS instructions and params](https://github.com/mudler/LocalAI/pull/10172)).
 - **June 2026**: New backends and models: [locate-anything.cpp](https://github.com/mudler/LocalAI/pull/10264) for open-vocabulary object detection via ggml, [Ideogram4 image generation](https://github.com/mudler/LocalAI/pull/10201) in stablediffusion-ggml, [llama.cpp video input](https://github.com/mudler/LocalAI/pull/10216), and the [Gemma 4 QAT family with MTP speculative-decoding pairs](https://github.com/mudler/LocalAI/pull/10215). Plus an [interactive CLI chat mode](https://github.com/mudler/LocalAI/pull/10226) and [RAG source citations in agent responses](https://github.com/mudler/LocalAI/pull/10228).
@@ -231,20 +231,13 @@ Most backends wrap a best-in-class upstream engine. A handful of them are native
 
 | Backend | What it does |
 |---------|-------------|
-| [vllm.cpp](https://github.com/mudler/vllm.cpp) | From-scratch C++20 port of vLLM for text generation: paged KV cache, continuous batching, prefix caching, safetensors + GGUF loading, engine-enforced structured output, on CPU, CUDA, Metal and Vulkan |
 | [parakeet.cpp](https://github.com/mudler/parakeet.cpp) | C++/GGML port of NVIDIA NeMo Parakeet ASR (tdt/ctc/rnnt/hybrid), with cache-aware streaming transcription |
-| [moss-transcribe.cpp](https://github.com/localai-org/moss-transcribe.cpp) | C++/GGML port of OpenMOSS MOSS-Transcribe-Diarize: joint long-form transcription, speaker diarization and timestamping in a single pass |
-| [moss-tts.cpp](https://github.com/mudler/moss-tts.cpp) | C++/GGML port of the OpenMOSS MOSS-TTS family: text-to-speech (MOSS-TTS-Local v1.5, 48 kHz stereo) with reference-audio voice cloning, through the MOSS-Audio-Tokenizer neural codec |
-| [magpie-tts.cpp](https://github.com/mudler/magpie-tts.cpp) | C++/GGML port of NVIDIA's Magpie TTS Multilingual 357M: 22.05 kHz mono text-to-speech in 5 voices and 9+ languages, with the NanoCodec neural codec and tokenizer/G2P embedded in a single GGUF |
-| [ced.cpp](https://github.com/localai-org/ced.cpp) | C++/GGML port of the CED audio-tagging models: sound-event classification (527-class AudioSet) over REST and the realtime API for live recognition |
-| [voice-detect.cpp](https://github.com/localai-org/voice-detect.cpp) | Speaker recognition and voice analysis (ECAPA-TDNN, WeSpeaker, ERes2Net, CAM++, wav2vec2 age/gender/emotion), replacing the Python speaker-recognition backend |
-| [voxtral-tts.c](https://github.com/mudler/voxtral-tts.c) | Voxtral Realtime 4B speech-to-text in pure C |
+| [ced.cpp](https://github.com/mudler/ced.cpp) | C++/GGML port of the CED audio-tagging models: sound-event classification (527-class AudioSet) over REST and the realtime API for live recognition |
+| [voxtral.c](https://github.com/mudler/voxtral.c) | Voxtral Realtime 4B speech-to-text in pure C |
 | [vibevoice.cpp](https://github.com/mudler/vibevoice.cpp) | Native port of Microsoft VibeVoice for TTS (voice cloning) and long-form ASR with speaker diarization |
-| [rf-detr.cpp](https://github.com/localai-org/rf-detr.cpp) | Native RF-DETR object detection and instance segmentation |
+| [rf-detr.cpp](https://github.com/mudler/rf-detr.cpp) | Native RF-DETR object detection and instance segmentation |
 | [locate-anything.cpp](https://github.com/mudler/locate-anything.cpp) | Open-vocabulary object detection and visual grounding (LocateAnything-3B) |
 | [depth-anything.cpp](https://github.com/mudler/depth-anything.cpp) | Depth Anything 3 monocular metric depth + camera pose estimation |
-| [face-detect.cpp](https://github.com/mudler/face-detect.cpp) | Face detection, recognition, demographics and anti-spoofing (SCRFD/ArcFace, YuNet/SFace), replacing the Python insightface backend |
-| [free-splatter.cpp](https://github.com/localai-org/free-splatter.cpp) | Pose-free 3D reconstruction (FreeSplatter): turns a handful of plain photos into 3D Gaussians, no camera poses or GPU required |
 | [privacy-filter.cpp](https://github.com/localai-org/privacy-filter.cpp) | Standalone GGML PII/NER token-classification engine powering LocalAI's PII redaction tier |
 | [LocalVQE](https://github.com/localai-org/LocalVQE) | Joint acoustic echo cancellation, noise suppression, and dereverberation |
 | [local-store](https://github.com/mudler/LocalAI) | Local-first vector database for embeddings (shipped in-tree) |

backend/Dockerfile.bonsai

@@ -1,160 +0,0 @@
-ARG BASE_IMAGE=ubuntu:24.04
-# BUILDER_BASE_IMAGE defaults to BASE_IMAGE so the Dockerfile parses even
-# when no prebuilt base is supplied. The builder-prebuilt stage is only
-# entered when BUILDER_TARGET=builder-prebuilt, so a "wrong" fallback
-# content here is harmless — BuildKit prunes the unreferenced builder.
-ARG BUILDER_BASE_IMAGE=${BASE_IMAGE}
-# BUILDER_TARGET selects which builder stage the final scratch image copies
-# package output from. Declared at global scope (before any FROM) so it's
-# usable in `FROM ${BUILDER_TARGET}` below. Default keeps local
-# `make backends/bonsai` on the from-source path.
-ARG BUILDER_TARGET=builder-fromsource
-ARG APT_MIRROR=""
-ARG APT_PORTS_MIRROR=""
-
-
-# ============================================================================
-# Stage: builder-fromsource — self-contained build path.
-# Runs .docker/install-base-deps.sh (apt deps + cmake + protoc + gRPC +
-# conditional CUDA/ROCm/Vulkan), copies /opt/grpc to /usr/local, then
-# compiles the variant. Used when BUILDER_TARGET=builder-fromsource (the
-# default; local `make backends/bonsai`).
-#
-# The install script is the same one that backend/Dockerfile.base-grpc-builder
-# runs, so the result is bit-equivalent to the prebuilt-base path
-# (builder-prebuilt below).
-# ============================================================================
-FROM ${BASE_IMAGE} AS builder-fromsource
-ARG BUILD_TYPE
-ARG CUDA_MAJOR_VERSION
-ARG CUDA_MINOR_VERSION
-ARG CMAKE_FROM_SOURCE=false
-# CUDA Toolkit 13.x compatibility: CMake 3.31.9+ fixes toolchain detection/arch table issues
-ARG CMAKE_VERSION=3.31.10
-ARG GRPC_VERSION=v1.65.0
-ARG GRPC_MAKEFLAGS="-j4 -Otarget"
-ARG SKIP_DRIVERS=false
-ARG TARGETARCH
-ARG TARGETVARIANT
-ARG GO_VERSION=1.25.4
-ARG UBUNTU_VERSION=2404
-ARG APT_MIRROR
-ARG APT_PORTS_MIRROR
-ARG AMDGPU_TARGETS=""
-ARG BACKEND=rerankers
-# CUDA target archs, e.g. --build-arg CUDA_DOCKER_ARCH='75;86;89;120'
-ARG CUDA_DOCKER_ARCH
-ARG CMAKE_ARGS
-
-ENV BUILD_TYPE=${BUILD_TYPE} \
-    CUDA_MAJOR_VERSION=${CUDA_MAJOR_VERSION} \
-    CUDA_MINOR_VERSION=${CUDA_MINOR_VERSION} \
-    CMAKE_FROM_SOURCE=${CMAKE_FROM_SOURCE} \
-    CMAKE_VERSION=${CMAKE_VERSION} \
-    GRPC_VERSION=${GRPC_VERSION} \
-    GRPC_MAKEFLAGS=${GRPC_MAKEFLAGS} \
-    SKIP_DRIVERS=${SKIP_DRIVERS} \
-    TARGETARCH=${TARGETARCH} \
-    UBUNTU_VERSION=${UBUNTU_VERSION} \
-    APT_MIRROR=${APT_MIRROR} \
-    APT_PORTS_MIRROR=${APT_PORTS_MIRROR} \
-    AMDGPU_TARGETS=${AMDGPU_TARGETS} \
-    CUDA_DOCKER_ARCH=${CUDA_DOCKER_ARCH} \
-    CMAKE_ARGS=${CMAKE_ARGS} \
-    DEBIAN_FRONTEND=noninteractive
-
-# CUDA on PATH (no-op when CUDA isn't installed)
-ENV PATH=/usr/local/cuda/bin:${PATH}
-# HipBLAS / ROCm on PATH (no-op when ROCm isn't installed)
-ENV PATH=/opt/rocm/bin:${PATH}
-
-WORKDIR /build
-
-# Install everything via the shared script — the same one that
-# backend/Dockerfile.base-grpc-builder runs, so the prebuilt CI base and
-# this from-source path are bit-equivalent.
-RUN --mount=type=bind,source=.docker/install-base-deps.sh,target=/usr/local/sbin/install-base-deps \
-    --mount=type=bind,source=.docker/apt-mirror.sh,target=/usr/local/sbin/apt-mirror \
-    bash /usr/local/sbin/install-base-deps
-
-# Mirror builder-prebuilt: copy gRPC from /opt/grpc to /usr/local so
-# CMake's find_package finds it at the canonical prefix the Makefile expects.
-RUN cp -a /opt/grpc/. /usr/local/
-
-COPY . /LocalAI
-
-# BuildKit cache mount for ccache. See Dockerfile.llama-cpp (commit 9228e5b4)
-# for rationale. bonsai is a llama.cpp fork that reuses
-# backend/cpp/llama-cpp source via a thin wrapper Makefile, so MOST TUs
-# are content-identical to the upstream llama-cpp build. Sharing a cache
-# id with llama-cpp could give cross-fork hits — but for now keep them
-# separate so a regression in one doesn't poison the other. Revisit
-# sharing after measuring the actual hit rate.
-#
-# The compile body is shared with builder-prebuilt via .docker/bonsai-compile.sh.
-RUN --mount=type=bind,source=.docker/bonsai-compile.sh,target=/usr/local/sbin/compile.sh \
-    --mount=type=cache,target=/root/.ccache,id=bonsai-ccache-${TARGETARCH}-${BUILD_TYPE},sharing=locked \
-    bash /usr/local/sbin/compile.sh
-
-
-# Copy libraries using a script to handle architecture differences
-RUN make -BC /LocalAI/backend/cpp/bonsai package
-
-
-# ============================================================================
-# Stage: builder-prebuilt — uses the pre-built base from
-# quay.io/go-skynet/ci-cache:base-grpc-* (built by .github/workflows/base-images.yml).
-# That image already has gRPC at /opt/grpc + apt deps + CUDA/ROCm/Vulkan
-# pre-installed, so we just copy gRPC to /usr/local and compile. Used when
-# BUILDER_TARGET=builder-prebuilt (CI when the matrix entry sets
-# builder-base-image).
-# ============================================================================
-FROM ${BUILDER_BASE_IMAGE} AS builder-prebuilt
-
-ARG BUILD_TYPE
-ENV BUILD_TYPE=${BUILD_TYPE}
-ARG CUDA_DOCKER_ARCH
-ENV CUDA_DOCKER_ARCH=${CUDA_DOCKER_ARCH}
-ARG CMAKE_ARGS
-ENV CMAKE_ARGS=${CMAKE_ARGS}
-# AMDGPU_TARGETS must be forwarded into the env here too — backend/cpp/llama-cpp/Makefile
-# (which the bonsai Makefile reuses via a sibling build dir) errors out when the var
-# is empty on a hipblas build, and the prebuilt path is what CI exercises most of the
-# time. The builder-fromsource stage above already does this; mirror it here.
-ARG AMDGPU_TARGETS
-ENV AMDGPU_TARGETS=${AMDGPU_TARGETS}
-ARG TARGETARCH
-ARG TARGETVARIANT
-
-# The base-grpc-* image installs gRPC to /opt/grpc but doesn't copy it to
-# /usr/local. Mirror what the from-source path does so the compile step
-# can find gRPC at the canonical prefix the Makefile expects.
-RUN cp -a /opt/grpc/. /usr/local/
-
-COPY . /LocalAI
-
-RUN --mount=type=bind,source=.docker/bonsai-compile.sh,target=/usr/local/sbin/compile.sh \
-    --mount=type=cache,target=/root/.ccache,id=bonsai-ccache-${TARGETARCH}-${BUILD_TYPE},sharing=locked \
-    bash /usr/local/sbin/compile.sh
-
-RUN make -BC /LocalAI/backend/cpp/bonsai package
-
-
-# ============================================================================
-# Final stage — copies package output from one of the two builders.
-# BUILDER_TARGET selects which one. BuildKit prunes the unreferenced builder.
-#
-# BuildKit doesn't support variable expansion in `COPY --from=` directly,
-# so we resolve the ARG by aliasing the chosen builder to a fixed stage
-# name via `FROM ${BUILDER_TARGET} AS builder` and then COPY --from=builder.
-# BUILDER_TARGET itself is declared as a global ARG at the top of this
-# file (required for use in FROM), so we just re-import it into this
-# stage's scope before the FROM directive.
-# ============================================================================
-FROM ${BUILDER_TARGET} AS builder
-
-FROM scratch
-
-
-# Copy all available binaries (the build process only creates the appropriate ones for the target architecture)
-COPY --from=builder /LocalAI/backend/cpp/bonsai/package/. ./

backend/Dockerfile.golang

@@ -221,33 +221,6 @@ RUN if [ "${BACKEND}" = "crispasr" ]; then \
     apt-get clean && rm -rf /var/lib/apt/lists/*; \
 fi
 
-# sherpa-onnx links onnxruntime's CUDA execution provider, and
-# libonnxruntime_providers_cuda.so has cuDNN as a hard DT_NEEDED. The
-# onnxruntime GPU tarball does not ship cuDNN itself, so without this the
-# builder has none (the arm64 + CUDA 13 branch above is the only other place
-# that installs it) and package-gpu-libs.sh correctly refuses to produce a
-# package that references cuDNN with no cuDNN available to it.
-#
-# Installed per-backend rather than for every cublas build: the auto-detection
-# in package-gpu-libs.sh bundles only what a package actually references, so
-# the ggml backends would not grow either way, but they would all pay ~1.1 GB
-# of builder layer and registry cache for a library they never call.
-#
-# Runtime package only, no -dev: sherpa-onnx consumes onnxruntime's prebuilt
-# CUDA provider and never compiles against cuDNN headers. libcudnn9-cuda-N
-# carries the dispatcher plus all seven dlopen()ed sublibraries, which is what
-# complete_cudnn_family needs to assemble a whole bundle.
-RUN <<EOT bash
-    if [ "${BACKEND}" = "sherpa-onnx" ] && [ "${BUILD_TYPE}" = "cublas" ] && [ "${SKIP_DRIVERS}" = "false" ]; then
-        apt-get update && \
-        apt-get install -y --no-install-recommends \
-            libcudnn9-cuda-${CUDA_MAJOR_VERSION} && \
-        ldconfig && \
-        apt-get clean && \
-        rm -rf /var/lib/apt/lists/*
-    fi
-EOT
-
 COPY . /LocalAI
 
 RUN git config --global --add safe.directory /LocalAI

backend/Dockerfile.llama-cpp

@@ -111,10 +111,6 @@ RUN make -BC /LocalAI/backend/cpp/llama-cpp package
 # ============================================================================
 FROM ${BUILDER_BASE_IMAGE} AS builder-prebuilt
 
-ARG APT_MIRROR
-ENV APT_MIRROR=${APT_MIRROR}
-ARG APT_PORTS_MIRROR
-ENV APT_PORTS_MIRROR=${APT_PORTS_MIRROR}
 ARG BUILD_TYPE
 ENV BUILD_TYPE=${BUILD_TYPE}
 ARG CUDA_DOCKER_ARCH

backend/Dockerfile.python

@@ -224,11 +224,7 @@ ARG DEPS_REFRESH=initial
 
 RUN cd /${BACKEND} && PORTABLE_PYTHON=true make
 
-# Package GPU libraries into the backend's lib directory.
-#
-# Must stay after the venv is built above: package-gpu-libs.sh inspects
-# /${BACKEND}/venv to decide whether this backend already carries a complete
-# cuDNN from pip, and bundles one only when it does not (issue #10905).
+# Package GPU libraries into the backend's lib directory
 RUN mkdir -p /${BACKEND}/lib && \
     TARGET_LIB_DIR="/${BACKEND}/lib" BUILD_TYPE="${BUILD_TYPE}" CUDA_MAJOR_VERSION="${CUDA_MAJOR_VERSION}" \
     bash /package-gpu-libs.sh "/${BACKEND}/lib"

backend/README.md

@@ -46,7 +46,6 @@ The backend system provides language-specific Dockerfiles that handle the build
 - **vllm**: High-performance LLM inference
 - **mlx**: Apple Silicon optimization
 - **diffusers**: Stable Diffusion models
-- **longcat-video**: CUDA text/image-to-video and speech-driven avatar generation
 - **Audio**: coqui, faster-whisper, kitten-tts
 - **Vision**: mlx-vlm, rfdetr
 - **Specialized**: rerankers, chatterbox, kokoro

backend/backend.proto

@@ -18,18 +18,6 @@ service Backend {
   rpc GenerateVideo(GenerateVideoRequest) returns (Result) {}
   rpc AudioTranscription(TranscriptRequest) returns (TranscriptResult) {}
   rpc AudioTranscriptionStream(TranscriptRequest) returns (stream TranscriptStreamResponse) {}
-  // AudioTranscriptionLive is the bidirectional live-microphone ASR RPC. The
-  // first message MUST carry a Config; subsequent messages carry Audio frames
-  // (mono float PCM at config.sample_rate, 16 kHz default). After a
-  // successful open the backend replies with a single ready ack
-  // (TranscriptLiveResponse{ready:true}); backends or models without
-  // cache-aware streaming support return UNIMPLEMENTED instead. Newly
-  // finalized text streams back as deltas; eou=true marks the model's
-  // end-of-utterance token. One stream spans many utterances (the decoder
-  // resets itself after each EOU). Closing the send side finalizes: the
-  // backend flushes the decoder tail and emits a terminal message carrying
-  // final_result. A second Config mid-stream resets the decode session.
-  rpc AudioTranscriptionLive(stream TranscriptLiveRequest) returns (stream TranscriptLiveResponse) {}
   rpc TTS(TTSRequest) returns (Result) {}
   rpc TTSStream(TTSRequest) returns (stream Reply) {}
   rpc SoundGeneration(SoundGenerationRequest) returns (Result) {}
@@ -136,10 +124,6 @@ message MetricsResponse {
 message TokenClassifyRequest {
   string text = 1;
   float threshold = 2;
-  // ModelIdentity names the model this request is for; see
-  // PredictOptions.ModelIdentity for the full rationale. Empty means "no
-  // identity supplied" and backends MUST skip the check.
-  string ModelIdentity = 3;
 }
 
 // TokenClassifyEntity is one detected entity span. Byte offsets are
@@ -177,17 +161,6 @@ message ScoreRequest {
   // candidates differ in length and the consumer wants a per-token
   // measure comparable across them (PMI-style scoring).
   bool length_normalize = 4;
-  // ModelIdentity names the model this request is for; see
-  // PredictOptions.ModelIdentity for the full rationale. Empty means "no
-  // identity supplied" and backends MUST skip the check.
-  string ModelIdentity = 5;
-  // Byte length of the prompt prefix that stays identical across
-  // repeated scoring calls (e.g. a classifier's option-list system
-  // prompt — everything before the per-turn probe text). Backends that
-  // snapshot state (hybrid/recurrent models cannot rewind otherwise)
-  // use it to place a reuse point exactly at the boundary, so the next
-  // call re-processes only the tokens after it. 0 means unknown.
-  int32 stable_prefix_len = 6;
 }
 
 // CandidateScore is one row in the ScoreResponse, matching by index
@@ -219,10 +192,6 @@ message RerankRequest {
   string query = 1;
   repeated string documents = 2;
   int32 top_n = 3;
-  // ModelIdentity names the model this request is for; see
-  // PredictOptions.ModelIdentity for the full rationale. Empty means "no
-  // identity supplied" and backends MUST skip the check.
-  string ModelIdentity = 4;
 }
 
 message RerankResult {
@@ -334,39 +303,6 @@ message PredictOptions {
   int32 TopLogprobs = 51;  // Number of top logprobs to return per token (maps to OpenAI top_logprobs parameter)
   map<string, string> Metadata = 52;  // Generic per-request metadata (e.g., enable_thinking)
   float MinP = 53;  // Minimum probability sampling threshold (0.0 = disabled)
-
-  // ModelIdentity names the model this request is for, so a backend can reject
-  // a request that reached it by mistake instead of answering from whatever
-  // model it happens to hold. In distributed mode a worker can recycle a
-  // stopped backend's gRPC port for a different model's backend, and a
-  // liveness-only health probe cannot tell that apart from a valid cached
-  // route (#10952).
-  //
-  // The value is the controller's ModelConfig.Model, the SAME expression that
-  // produces ModelOptions.Model at LoadModel time, so the two are equal by
-  // construction rather than by convention.
-  //
-  // Empty means "no identity supplied": backends MUST skip the check. That
-  // keeps an old controller talking to a new backend working, and covers
-  // callers that legitimately synthesize a PredictOptions internally.
-  //
-  // Do NOT reuse TTSRequest.model or SoundGenerationRequest.model for this
-  // purpose. FileStagingClient already rewrites those to worker-local absolute
-  // paths (core/services/nodes/file_staging_client.go), so in distributed mode
-  // they already differ from the load-time value and comparing them would
-  // reject valid requests. Extending identity to those RPCs needs a separate
-  // field carrying the untranslated value - which is exactly what
-  // TTSRequest.ModelIdentity and SoundGenerationRequest.ModelIdentity are.
-  //
-  // Every other request message that reaches a backend through the distributed
-  // router now carries the same ModelIdentity field, populated from the same
-  // ModelConfig.Model. FileStagingClient rewrites Src/Dst/Voice/Model/
-  // StartImage/EndImage/Audio and never ModelIdentity, so what the backend
-  // compares is always what the controller sent.
-  string ModelIdentity = 54;
-
-  // 24 was never assigned; reserve it so it is not silently reused.
-  reserved 24;
 }
 
 // ToolCallDelta represents an incremental tool call update from the C++ parser.
@@ -500,11 +436,6 @@ message ModelOptions {
   // Proxy carries the cloud-proxy backend's per-model configuration.
   // Empty for non-proxy backends.
   ProxyOptions Proxy = 74;
-
-  // EnableScore reserves backend resources for the Score RPC. It is derived
-  // from the model's explicit `known_usecases: [score]` declaration so models
-  // that never score retain their ordinary serving footprint.
-  bool EnableScore = 75;
 }
 
 // ProxyOptions configures the cloud-proxy backend. UpstreamURL and
@@ -520,12 +451,6 @@ message ProxyOptions {
   string api_key_file = 5;
   string upstream_model = 6;
   int32 request_timeout_seconds = 7;
-  // cache_prompt enables automatic Anthropic prompt-cache breakpoints
-  // (cache_control: ephemeral) on the stable prefix — system, tools, and
-  // the last message block — when translating to the Anthropic provider.
-  // Cuts input cost on repeated/agentic calls (cache read = 0.1x). Only
-  // meaningful for mode=translate + provider=anthropic; ignored otherwise.
-  bool cache_prompt = 8;
 }
 
 message Result {
@@ -547,10 +472,6 @@ message TranscriptRequest {
   float temperature = 8;
   repeated string timestamp_granularities = 9;
   bool stream = 10;
-  // ModelIdentity names the model this request is for; see
-  // PredictOptions.ModelIdentity for the full rationale. Empty means "no
-  // identity supplied" and backends MUST skip the check.
-  string ModelIdentity = 11;
 }
 
 message TranscriptResult {
@@ -558,10 +479,6 @@ message TranscriptResult {
   string text = 2;
   string language = 3;
   float duration = 4;
-  // True when the decode ended on the model's end-of-utterance special token
-  // (<EOU>/<EOB>, emitted by cache-aware streaming models such as
-  // parakeet_realtime_eou_120m-v1). The marker itself is stripped from text.
-  bool eou = 5;
 }
 
 message TranscriptStreamResponse {
@@ -569,34 +486,6 @@ message TranscriptStreamResponse {
   TranscriptResult final_result = 2;
 }
 
-// === AudioTranscriptionLive messages =====================================
-
-message TranscriptLiveRequest {
-  oneof payload {
-    TranscriptLiveConfig config = 1;
-    TranscriptLiveAudio  audio  = 2;
-  }
-}
-
-message TranscriptLiveConfig {
-  string language = 1;             // "" => model default
-  int32 sample_rate = 2;           // 0 => 16000; backends may reject others
-  map<string, string> params = 3;  // backend-specific tuning
-}
-
-message TranscriptLiveAudio {
-  repeated float pcm = 1;          // mono PCM in [-1,1] at config.sample_rate
-}
-
-message TranscriptLiveResponse {
-  bool ready = 1;                       // open ack: sent once, before any delta
-  string delta = 2;                     // newly-finalized text since previous response
-  bool eou = 3;                         // <EOU> fired during this feed (the user yielded the turn)
-  repeated TranscriptWord words = 4;    // words finalized by this feed (stream-relative ns)
-  TranscriptResult final_result = 5;    // terminal message only, after the send side closes
-  bool eob = 6;                         // <EOB> fired: a backchannel ("uh-huh") ended — NOT a turn boundary
-}
-
 message TranscriptWord {
   int64 start = 1;
   int64 end = 2;
@@ -629,10 +518,6 @@ message GenerateImageRequest {
 
   // Reference images for models that support them (e.g., Flux Kontext)
   repeated string ref_images = 12;
-  // ModelIdentity names the model this request is for; see
-  // PredictOptions.ModelIdentity for the full rationale. Empty means "no
-  // identity supplied" and backends MUST skip the check.
-  string ModelIdentity = 13;
 }
 
 message GenerateVideoRequest {
@@ -648,14 +533,6 @@ message GenerateVideoRequest {
   float cfg_scale = 10;    // Classifier-free guidance scale
   int32 step = 11;         // Number of inference steps
   string dst = 12;        // Output path for the generated video
-  string audio = 13;      // Path to staged audio for audio-conditioned video
-  // Backend-specific per-request generation parameters. Values are strings
-  // and are validated/coerced by the selected backend.
-  map<string, string> params = 14;
-  // ModelIdentity names the model this request is for; see
-  // PredictOptions.ModelIdentity for the full rationale. Empty means "no
-  // identity supplied" and backends MUST skip the check.
-  string ModelIdentity = 15;
 }
 
 message TTSRequest {
@@ -673,26 +550,10 @@ message TTSRequest {
   // (e.g. Chatterbox exaggeration/cfg_weight/temperature). Values are strings and
   // coerced by the backend; unset leaves the backend's configured defaults.
   map<string, string> params = 7;
-  // ModelIdentity is a SEPARATE field from `model` above and carries the
-  // UNTRANSLATED controller-side ModelConfig.Model, so a backend can reject a
-  // request that reached it through a stale distributed route (#10952).
-  //
-  // `model` cannot be reused for this: FileStagingClient.TTS/.TTSStream and the
-  // SoundGeneration path rewrite it into a worker-local absolute path
-  // (core/services/nodes/file_staging_client.go), while the load-time value is
-  // untranslated. In distributed mode - exactly the configuration this guards -
-  // the two already differ, so comparing them would reject valid requests.
-  //
-  // Empty means "no identity supplied" and backends MUST skip the check.
-  string ModelIdentity = 8;
 }
 
 message VADRequest {
   repeated float audio = 1;
-  // ModelIdentity names the model this request is for; see
-  // PredictOptions.ModelIdentity for the full rationale. Empty means "no
-  // identity supplied" and backends MUST skip the check.
-  string ModelIdentity = 2;
 }
 
 message VADSegment {
@@ -724,10 +585,6 @@ message DiarizeRequest {
   float  min_duration_on = 8;          // discard segments shorter than this (seconds); 0 = backend default
   float  min_duration_off = 9;         // merge gaps shorter than this (seconds); 0 = backend default
   bool   include_text = 10;            // when the backend can emit per-segment transcript for free, ask it to populate `text`
-  // ModelIdentity names the model this request is for; see
-  // PredictOptions.ModelIdentity for the full rationale. Empty means "no
-  // identity supplied" and backends MUST skip the check.
-  string ModelIdentity = 11;
 }
 
 message DiarizeSegment {
@@ -762,18 +619,6 @@ message SoundGenerationRequest {
   optional string language = 14;
   optional string timesignature = 15;
   optional bool instrumental = 17;
-  // ModelIdentity is a SEPARATE field from `model` above and carries the
-  // UNTRANSLATED controller-side ModelConfig.Model, so a backend can reject a
-  // request that reached it through a stale distributed route (#10952).
-  //
-  // `model` cannot be reused for this: FileStagingClient.TTS/.TTSStream and the
-  // SoundGeneration path rewrite it into a worker-local absolute path
-  // (core/services/nodes/file_staging_client.go), while the load-time value is
-  // untranslated. In distributed mode - exactly the configuration this guards -
-  // the two already differ, so comparing them would reject valid requests.
-  //
-  // Empty means "no identity supplied" and backends MUST skip the check.
-  string ModelIdentity = 18;
 }
 
 message TokenizationResponse {
@@ -813,10 +658,6 @@ message DetectOptions {
   repeated float points = 3;   // Point coordinates as [x1, y1, label1, x2, y2, label2, ...] (label: 1=pos, 0=neg)
   repeated float boxes = 4;    // Box coordinates as [x1, y1, x2, y2, ...]
   float threshold = 5;         // Detection confidence threshold
-  // ModelIdentity names the model this request is for; see
-  // PredictOptions.ModelIdentity for the full rationale. Empty means "no
-  // identity supplied" and backends MUST skip the check.
-  string ModelIdentity = 6;
 }
 
 message Detection {
@@ -839,10 +680,6 @@ message SoundDetectionRequest {
   string src = 1;       // audio file path (LocalAI writes the upload to disk)
   int32 top_k = 2;      // number of top tags to return (0 = all classes)
   float threshold = 3;  // optional: drop tags scoring below this
-  // ModelIdentity names the model this request is for; see
-  // PredictOptions.ModelIdentity for the full rationale. Empty means "no
-  // identity supplied" and backends MUST skip the check.
-  string ModelIdentity = 4;
 }
 
 message SoundClass {
@@ -867,10 +704,6 @@ message DepthRequest {
   bool include_points = 7;         // back-project to a 3D point cloud (DualDPT)
   float points_conf_thresh = 8;    // keep points with confidence >= this threshold
   repeated string exports = 9;     // requested exports: "glb", "colmap"
-  // ModelIdentity names the model this request is for; see
-  // PredictOptions.ModelIdentity for the full rationale. Empty means "no
-  // identity supplied" and backends MUST skip the check.
-  string ModelIdentity = 10;
 }
 
 message DepthResponse {
@@ -902,10 +735,6 @@ message FaceVerifyRequest {
   string img2 = 2;              // base64-encoded image
   float  threshold = 3;         // cosine-distance threshold; 0 = use backend default
   bool   anti_spoofing = 4;     // run MiniFASNet liveness on each image; failed liveness forces verified=false
-  // ModelIdentity names the model this request is for; see
-  // PredictOptions.ModelIdentity for the full rationale. Empty means "no
-  // identity supplied" and backends MUST skip the check.
-  string ModelIdentity = 5;
 }
 
 message FaceVerifyResponse {
@@ -927,10 +756,6 @@ message FaceAnalyzeRequest {
   string          img = 1;          // base64-encoded image
   repeated string actions = 2;      // subset of ["age","gender","emotion","race"]; empty = all-supported
   bool            anti_spoofing = 3;
-  // ModelIdentity names the model this request is for; see
-  // PredictOptions.ModelIdentity for the full rationale. Empty means "no
-  // identity supplied" and backends MUST skip the check.
-  string ModelIdentity = 4;
 }
 
 message FaceAnalysis {
@@ -963,10 +788,6 @@ message VoiceVerifyRequest {
   string audio2 = 2;            // path to second audio clip
   float  threshold = 3;         // cosine-distance threshold; 0 = use backend default
   bool   anti_spoofing = 4;     // reserved for future AASIST bolt-on
-  // ModelIdentity names the model this request is for; see
-  // PredictOptions.ModelIdentity for the full rationale. Empty means "no
-  // identity supplied" and backends MUST skip the check.
-  string ModelIdentity = 5;
 }
 
 message VoiceVerifyResponse {
@@ -981,10 +802,6 @@ message VoiceVerifyResponse {
 message VoiceAnalyzeRequest {
   string          audio = 1;        // path to audio clip
   repeated string actions = 2;      // subset of ["age","gender","emotion"]; empty = all-supported
-  // ModelIdentity names the model this request is for; see
-  // PredictOptions.ModelIdentity for the full rationale. Empty means "no
-  // identity supplied" and backends MUST skip the check.
-  string ModelIdentity = 3;
 }
 
 message VoiceAnalysis {
@@ -1003,10 +820,6 @@ message VoiceAnalyzeResponse {
 
 message VoiceEmbedRequest {
   string audio = 1;              // path to audio clip
-  // ModelIdentity names the model this request is for; see
-  // PredictOptions.ModelIdentity for the full rationale. Empty means "no
-  // identity supplied" and backends MUST skip the check.
-  string ModelIdentity = 2;
 }
 
 message VoiceEmbedResponse {
@@ -1101,10 +914,6 @@ message AudioTransformRequest {
   string reference_path = 2;         // optional auxiliary; empty => zero-fill
   string dst = 3;                    // required, output file path
   map<string, string> params = 4;    // backend-specific tuning
-  // ModelIdentity names the model this request is for; see
-  // PredictOptions.ModelIdentity for the full rationale. Empty means "no
-  // identity supplied" and backends MUST skip the check.
-  string ModelIdentity = 5;
 }
 
 message AudioTransformResult {
@@ -1403,3 +1212,4 @@ message ForwardReply {
   repeated ForwardHeader headers = 2;
   bytes body_chunk = 3;
 }
+

backend/cpp/bonsai/Makefile

@@ -1,107 +0,0 @@
-
-# Pinned to the HEAD of the `prism` branch on https://github.com/PrismML-Eng/llama.cpp.
-# Auto-bumped nightly by .github/workflows/bump_deps.yaml.
-BONSAI_VERSION?=7529fdaaf99ffdc5ca71ace9c7409a56b27ad92f
-LLAMA_REPO?=https://github.com/PrismML-Eng/llama.cpp
-
-CMAKE_ARGS?=
-BUILD_TYPE?=
-NATIVE?=false
-ONEAPI_VARS?=/opt/intel/oneapi/setvars.sh
-TARGET?=--target grpc-server
-JOBS?=$(shell nproc 2>/dev/null || sysctl -n hw.ncpu 2>/dev/null || echo 1)
-ARCH?=$(shell uname -m)
-
-CURRENT_MAKEFILE_DIR := $(dir $(abspath $(lastword $(MAKEFILE_LIST))))
-LLAMA_CPP_DIR := $(CURRENT_MAKEFILE_DIR)/../llama-cpp
-
-GREEN := \033[0;32m
-RESET := \033[0m
-
-# bonsai is a llama.cpp fork (PrismML) adding the Q1_0 (1-bit) and Q2_0 (ternary)
-# weight-quantization kernels that the Bonsai / Ternary-Bonsai models ship in. Rather
-# than duplicating grpc-server.cpp / CMakeLists.txt / prepare.sh we reuse the ones in
-# backend/cpp/llama-cpp, and only swap which repo+sha the fetch step pulls. Each flavor
-# target copies ../llama-cpp into a sibling ../bonsai-<flavor>-build directory, then
-# invokes llama-cpp's own build with LLAMA_REPO/LLAMA_VERSION overridden to point at the
-# fork.
-#
-# The Q1_0/Q2_0 additions are model *weight* types decoded inside libllama, transparent
-# to the reused gRPC server, so (unlike turboquant's KV-cache types) no grpc-server.cpp
-# allow-list patch is needed. The fork branched from upstream before a few API changes
-# the shared grpc-server.cpp depends on; those are carried as patch files under
-# backend/cpp/bonsai/patches/ and applied to the cloned fork by apply-patches.sh.
-PATCHES_DIR := $(CURRENT_MAKEFILE_DIR)/patches
-
-define bonsai-build
-	rm -rf $(CURRENT_MAKEFILE_DIR)/../bonsai-$(1)-build
-	cp -rf $(LLAMA_CPP_DIR) $(CURRENT_MAKEFILE_DIR)/../bonsai-$(1)-build
-	# Drop patches vendored for upstream llama.cpp: the fork tree diverges, so
-	# they reject there. Fork-specific patches live in backend/cpp/bonsai/patches/
-	# and are applied by apply-patches.sh below.
-	rm -rf $(CURRENT_MAKEFILE_DIR)/../bonsai-$(1)-build/patches
-	$(MAKE) -C $(CURRENT_MAKEFILE_DIR)/../bonsai-$(1)-build purge
-	bash $(LLAMA_CPP_DIR)/disable-score-task.sh $(CURRENT_MAKEFILE_DIR)/../bonsai-$(1)-build/grpc-server.cpp
-	$(info $(GREEN)I bonsai build info:$(1)$(RESET))
-	LLAMA_REPO=$(LLAMA_REPO) LLAMA_VERSION=$(BONSAI_VERSION) \
-	$(MAKE) -C $(CURRENT_MAKEFILE_DIR)/../bonsai-$(1)-build llama.cpp
-	bash $(CURRENT_MAKEFILE_DIR)/apply-patches.sh $(CURRENT_MAKEFILE_DIR)/../bonsai-$(1)-build/llama.cpp $(PATCHES_DIR)
-	CMAKE_ARGS="$(CMAKE_ARGS) $(2)" TARGET="$(3)" \
-	LLAMA_REPO=$(LLAMA_REPO) LLAMA_VERSION=$(BONSAI_VERSION) \
-	$(MAKE) -C $(CURRENT_MAKEFILE_DIR)/../bonsai-$(1)-build grpc-server
-	cp -rfv $(CURRENT_MAKEFILE_DIR)/../bonsai-$(1)-build/grpc-server bonsai-$(1)
-endef
-
-bonsai-avx2:
-	$(call bonsai-build,avx2,-DGGML_AVX=on -DGGML_AVX2=on -DGGML_AVX512=off -DGGML_FMA=on -DGGML_F16C=on,--target grpc-server)
-
-bonsai-avx512:
-	$(call bonsai-build,avx512,-DGGML_AVX=on -DGGML_AVX2=off -DGGML_AVX512=on -DGGML_FMA=on -DGGML_F16C=on,--target grpc-server)
-
-bonsai-avx:
-	$(call bonsai-build,avx,-DGGML_AVX=on -DGGML_AVX2=off -DGGML_AVX512=off -DGGML_FMA=off -DGGML_F16C=off -DGGML_BMI2=off,--target grpc-server)
-
-bonsai-fallback:
-	$(call bonsai-build,fallback,-DGGML_AVX=off -DGGML_AVX2=off -DGGML_AVX512=off -DGGML_FMA=off -DGGML_F16C=off -DGGML_BMI2=off,--target grpc-server)
-
-# Single-build CPU backend via ggml CPU_ALL_VARIANTS (mirrors llama-cpp-cpu-all).
-# bonsai reuses backend/cpp/llama-cpp's CMakeLists.txt (hw_grpc_proto STATIC) and
-# Makefile (SHARED_LIBS make-var + EXTRA_CMAKE_ARGS), so this passes the same overrides
-# through to the copied build: SHARED_LIBS=ON, the DL flags, and --target ggml (which
-# pulls in the per-microarch libggml-cpu-*.so via ggml's add_dependencies). The .so set
-# is collected for package.sh to bundle into package/lib.
-bonsai-cpu-all:
-	rm -rf $(CURRENT_MAKEFILE_DIR)/../bonsai-cpu-all-build
-	cp -rf $(LLAMA_CPP_DIR) $(CURRENT_MAKEFILE_DIR)/../bonsai-cpu-all-build
-	# Drop patches vendored for upstream llama.cpp: the fork tree diverges, so
-	# they reject there. Fork-specific patches live in backend/cpp/bonsai/patches/
-	# and are applied by apply-patches.sh below.
-	rm -rf $(CURRENT_MAKEFILE_DIR)/../bonsai-cpu-all-build/patches
-	$(MAKE) -C $(CURRENT_MAKEFILE_DIR)/../bonsai-cpu-all-build purge
-	bash $(LLAMA_CPP_DIR)/disable-score-task.sh $(CURRENT_MAKEFILE_DIR)/../bonsai-cpu-all-build/grpc-server.cpp
-	$(info $(GREEN)I bonsai build info:cpu-all-variants$(RESET))
-	LLAMA_REPO=$(LLAMA_REPO) LLAMA_VERSION=$(BONSAI_VERSION) \
-	$(MAKE) -C $(CURRENT_MAKEFILE_DIR)/../bonsai-cpu-all-build llama.cpp
-	bash $(CURRENT_MAKEFILE_DIR)/apply-patches.sh $(CURRENT_MAKEFILE_DIR)/../bonsai-cpu-all-build/llama.cpp $(PATCHES_DIR)
-	SHARED_LIBS=ON EXTRA_CMAKE_ARGS="-DGGML_BACKEND_DL=ON -DGGML_CPU_ALL_VARIANTS=ON" TARGET="--target grpc-server --target ggml" \
-	LLAMA_REPO=$(LLAMA_REPO) LLAMA_VERSION=$(BONSAI_VERSION) \
-	$(MAKE) -C $(CURRENT_MAKEFILE_DIR)/../bonsai-cpu-all-build grpc-server
-	cp -rfv $(CURRENT_MAKEFILE_DIR)/../bonsai-cpu-all-build/grpc-server bonsai-cpu-all
-	rm -rf ggml-shared-libs && mkdir -p ggml-shared-libs
-	find $(CURRENT_MAKEFILE_DIR)/../bonsai-cpu-all-build/llama.cpp/build \( -name '*.so*' -o -name '*.dylib' \) -exec cp -av {} ggml-shared-libs/ \;
-	@echo "Collected ggml shared backends:" && ls -la ggml-shared-libs/
-
-bonsai-grpc:
-	$(call bonsai-build,grpc,-DGGML_RPC=ON -DGGML_AVX=off -DGGML_AVX2=off -DGGML_AVX512=off -DGGML_FMA=off -DGGML_F16C=off -DGGML_BMI2=off,--target grpc-server --target rpc-server)
-
-bonsai-rpc-server: bonsai-grpc
-	cp -rf $(CURRENT_MAKEFILE_DIR)/../bonsai-grpc-build/llama.cpp/build/bin/rpc-server bonsai-rpc-server
-
-package:
-	bash package.sh
-
-purge:
-	rm -rf $(CURRENT_MAKEFILE_DIR)/../bonsai-*-build
-	rm -rf bonsai-* package
-
-clean: purge

backend/cpp/bonsai/apply-patches.sh

@@ -1,48 +0,0 @@
-#!/bin/bash
-# Apply the bonsai patch series to a cloned PrismML llama.cpp (prism branch) checkout.
-#
-# The prism fork branched from upstream llama.cpp before a number of API changes that the
-# shared backend/cpp/llama-cpp/grpc-server.cpp depends on. We carry those upstream commits
-# as patch files under backend/cpp/bonsai/patches/ and apply them here so the reused
-# grpc-server source compiles against the fork unmodified.
-#
-# Drop the corresponding patch from patches/ whenever the fork catches up with upstream —
-# the build will fail fast if a patch stops applying, which is the signal to retire it.
-
-set -euo pipefail
-
-if [[ $# -ne 2 ]]; then
-    echo "usage: $0 <llama.cpp-src-dir> <patches-dir>" >&2
-    exit 2
-fi
-
-SRC_DIR=$1
-PATCHES_DIR=$2
-
-if [[ ! -d "$SRC_DIR" ]]; then
-    echo "source dir does not exist: $SRC_DIR" >&2
-    exit 2
-fi
-
-if [[ ! -d "$PATCHES_DIR" ]]; then
-    echo "no patches dir at $PATCHES_DIR, nothing to apply"
-    exit 0
-fi
-
-shopt -s nullglob
-patches=("$PATCHES_DIR"/*.patch)
-shopt -u nullglob
-
-if [[ ${#patches[@]} -eq 0 ]]; then
-    echo "no .patch files in $PATCHES_DIR, nothing to apply"
-    exit 0
-fi
-
-cd "$SRC_DIR"
-
-for patch in "${patches[@]}"; do
-    echo "==> applying $patch"
-    git apply --verbose "$patch"
-done
-
-echo "all bonsai patches applied successfully"

backend/cpp/bonsai/package.sh

@@ -1,66 +0,0 @@
-#!/bin/bash
-
-# Script to copy the appropriate libraries based on architecture
-# This script is used in the final stage of the Dockerfile
-
-set -e
-
-CURDIR=$(dirname "$(realpath $0)")
-REPO_ROOT="${CURDIR}/../../.."
-
-# Create lib directory
-mkdir -p $CURDIR/package/lib
-
-cp -avrf $CURDIR/bonsai-* $CURDIR/package/
-cp -rfv $CURDIR/run.sh $CURDIR/package/
-
-# Bundle the ggml shared backends from the CPU_ALL_VARIANTS build into package/lib. ggml
-# discovers the per-microarch libggml-cpu-*.so by scanning the executable directory, which
-# (via the bundled lib/ld.so that run.sh launches through) resolves to lib/. See the
-# matching comment in backend/cpp/llama-cpp/package.sh. No-op on the fallback/ROCm builds.
-if [ -d "$CURDIR/ggml-shared-libs" ]; then
-    echo "Bundling ggml shared backends (CPU_ALL_VARIANTS)..."
-    cp -avf $CURDIR/ggml-shared-libs/*.so* $CURDIR/package/lib/
-fi
-
-# Detect architecture and copy appropriate libraries
-if [ -f "/lib64/ld-linux-x86-64.so.2" ]; then
-    # x86_64 architecture
-    echo "Detected x86_64 architecture, copying x86_64 libraries..."
-    cp -arfLv /lib64/ld-linux-x86-64.so.2 $CURDIR/package/lib/ld.so
-    cp -arfLv /lib/x86_64-linux-gnu/libc.so.6 $CURDIR/package/lib/libc.so.6
-    cp -arfLv /lib/x86_64-linux-gnu/libgcc_s.so.1 $CURDIR/package/lib/libgcc_s.so.1
-    cp -arfLv /lib/x86_64-linux-gnu/libstdc++.so.6 $CURDIR/package/lib/libstdc++.so.6
-    cp -arfLv /lib/x86_64-linux-gnu/libm.so.6 $CURDIR/package/lib/libm.so.6
-    cp -arfLv /lib/x86_64-linux-gnu/libgomp.so.1 $CURDIR/package/lib/libgomp.so.1
-    cp -arfLv /lib/x86_64-linux-gnu/libdl.so.2 $CURDIR/package/lib/libdl.so.2
-    cp -arfLv /lib/x86_64-linux-gnu/librt.so.1 $CURDIR/package/lib/librt.so.1
-    cp -arfLv /lib/x86_64-linux-gnu/libpthread.so.0 $CURDIR/package/lib/libpthread.so.0
-elif [ -f "/lib/ld-linux-aarch64.so.1" ]; then
-    # ARM64 architecture
-    echo "Detected ARM64 architecture, copying ARM64 libraries..."
-    cp -arfLv /lib/ld-linux-aarch64.so.1 $CURDIR/package/lib/ld.so
-    cp -arfLv /lib/aarch64-linux-gnu/libc.so.6 $CURDIR/package/lib/libc.so.6
-    cp -arfLv /lib/aarch64-linux-gnu/libgcc_s.so.1 $CURDIR/package/lib/libgcc_s.so.1
-    cp -arfLv /lib/aarch64-linux-gnu/libstdc++.so.6 $CURDIR/package/lib/libstdc++.so.6
-    cp -arfLv /lib/aarch64-linux-gnu/libm.so.6 $CURDIR/package/lib/libm.so.6
-    cp -arfLv /lib/aarch64-linux-gnu/libgomp.so.1 $CURDIR/package/lib/libgomp.so.1
-    cp -arfLv /lib/aarch64-linux-gnu/libdl.so.2 $CURDIR/package/lib/libdl.so.2
-    cp -arfLv /lib/aarch64-linux-gnu/librt.so.1 $CURDIR/package/lib/librt.so.1
-    cp -arfLv /lib/aarch64-linux-gnu/libpthread.so.0 $CURDIR/package/lib/libpthread.so.0
-else
-    echo "Error: Could not detect architecture"
-    exit 1
-fi
-
-# Package GPU libraries based on BUILD_TYPE
-GPU_LIB_SCRIPT="${REPO_ROOT}/scripts/build/package-gpu-libs.sh"
-if [ -f "$GPU_LIB_SCRIPT" ]; then
-    echo "Packaging GPU libraries for BUILD_TYPE=${BUILD_TYPE:-cpu}..."
-    source "$GPU_LIB_SCRIPT" "$CURDIR/package/lib"
-    package_gpu_libs
-fi
-
-echo "Packaging completed successfully"
-ls -liah $CURDIR/package/
-ls -liah $CURDIR/package/lib/

backend/cpp/bonsai/patches/README.md

@@ -1,19 +0,0 @@
-# bonsai fork skew patches
-
-The `bonsai` backend reuses `backend/cpp/llama-cpp/grpc-server.cpp` (written against
-LocalAI's pinned *upstream* llama.cpp) but compiles it against the PrismML `prism` fork,
-which branched from upstream some commits earlier. Any upstream API change that the shared
-gRPC server depends on, but that the fork does not yet carry, is back-ported here as a
-`*.patch` file and applied to the cloned fork checkout by `../apply-patches.sh`.
-
-CI treats both this directory and `backend/cpp/llama-cpp/` as Bonsai inputs, since
-the wrapper copies and builds the shared llama.cpp backend sources.
-
-Rules:
-
-- One upstream commit (or minimal hunk) per patch, named `NNNN-short-description.patch`.
-- Patches are applied with `git apply` from the fork's checkout root.
-- `apply-patches.sh` fails fast if a patch stops applying cleanly — that is the signal the
-  fork has caught up (or diverged), so re-cut or drop the patch.
-- Keep this set as small as possible; the long-term fix is the fork rebasing onto a newer
-  upstream (or Q1_0/Q2_0 landing in mainline llama.cpp, retiring this backend entirely).

backend/cpp/bonsai/run.sh

@@ -1,56 +0,0 @@
-#!/bin/bash
-set -ex
-
-# Get the absolute current dir where the script is located
-CURDIR=$(dirname "$(realpath "$0")")
-
-cd /
-
-echo "CPU info:"
-grep -e "model\sname" /proc/cpuinfo | head -1
-grep -e "flags" /proc/cpuinfo | head -1
-
-BINARY=bonsai-fallback
-
-# x86/arm64 ship a single bonsai-cpu-all built with ggml CPU_ALL_VARIANTS: ggml's
-# backend registry dlopens the best libggml-cpu-*.so for this host, so no shell-side
-# probing. ROCm ships only bonsai-fallback, so fall back to it when cpu-all is absent.
-if [ -e "$CURDIR"/bonsai-cpu-all ]; then
-	BINARY=bonsai-cpu-all
-fi
-
-if [ -n "$LLAMACPP_GRPC_SERVERS" ]; then
-	if [ -e "$CURDIR"/bonsai-grpc ]; then
-		BINARY=bonsai-grpc
-	fi
-fi
-
-# Extend ld library path with the dir where this script is located/lib
-if [ "$(uname)" == "Darwin" ]; then
-	export DYLD_LIBRARY_PATH="$CURDIR"/lib:$DYLD_LIBRARY_PATH
-else
-	export LD_LIBRARY_PATH="$CURDIR"/lib:$LD_LIBRARY_PATH
-	# Tell rocBLAS where to find TensileLibrary data (GPU kernel tuning files)
-	if [ -d "$CURDIR/lib/rocblas/library" ]; then
-		export ROCBLAS_TENSILE_LIBPATH="$CURDIR"/lib/rocblas/library
-	fi
-	# Same for hipBLASLt (rocblaslt): the bundled libhipblaslt.so resolves its
-	# TensileLibrary_lazy_gfx*.dat kernel data relative to itself, so point it at
-	# the bundled data or it falls back to slow generic kernels (issue #10660).
-	if [ -d "$CURDIR/lib/hipblaslt/library" ]; then
-		export HIPBLASLT_TENSILE_LIBPATH="$CURDIR"/lib/hipblaslt/library
-	fi
-fi
-
-# If there is a lib/ld.so, use it
-if [ -f "$CURDIR"/lib/ld.so ]; then
-	echo "Using lib/ld.so"
-	echo "Using binary: $BINARY"
-	exec "$CURDIR"/lib/ld.so "$CURDIR"/$BINARY "$@"
-fi
-
-echo "Using binary: $BINARY"
-exec "$CURDIR"/$BINARY "$@"
-
-# We should never reach this point, however just in case we do, run fallback
-exec "$CURDIR"/bonsai-fallback "$@"

backend/cpp/ds4/CMakeLists.txt

@@ -76,13 +76,12 @@ elseif(DS4_GPU STREQUAL "cpu")
     set(DS4_OBJS "${DS4_DIR}/ds4_cpu.o")
 endif()
 
-# Upstream splits distributed inference, tensor-parallel transport, the SSD
-# expert cache, and layer placement into GPU-agnostic translation units. Link
-# them regardless of DS4_GPU.
+# ds4.c now references ds4_distributed.c (distributed inference) and ds4_ssd.c
+# (SSD expert-cache), each split into its own translation unit upstream. Both
+# are GPU-agnostic objects shared by every GPU mode, so link them in regardless
+# of DS4_GPU.
 list(APPEND DS4_OBJS "${DS4_DIR}/ds4_distributed.o")
-list(APPEND DS4_OBJS "${DS4_DIR}/ds4_tp.o")
 list(APPEND DS4_OBJS "${DS4_DIR}/ds4_ssd.o")
-list(APPEND DS4_OBJS "${DS4_DIR}/ds4_layer_pack.o")
 
 add_executable(${TARGET}
     grpc-server.cpp

backend/cpp/ds4/Makefile

@@ -1,10 +1,10 @@
 # ds4 backend Makefile.
 #
-# Upstream pin lives below as DS4_VERSION?=54b36ed9ba42da31b24f2d1a5feb075c2475dbb1
+# Upstream pin lives below as DS4_VERSION?=80ebbc396aee40eedc1d829222f3362d10fa4c6c
 # (.github/bump_deps.sh) can find and update it - matches the
 # llama-cpp / ik-llama-cpp / turboquant convention.
 
-DS4_VERSION?=54b36ed9ba42da31b24f2d1a5feb075c2475dbb1
+DS4_VERSION?=80ebbc396aee40eedc1d829222f3362d10fa4c6c
 DS4_REPO?=https://github.com/antirez/ds4
 
 CURRENT_MAKEFILE_DIR := $(dir $(abspath $(lastword $(MAKEFILE_LIST))))
@@ -18,19 +18,20 @@ UNAME_S := $(shell uname -s)
 
 CMAKE_ARGS ?= -DCMAKE_BUILD_TYPE=Release
 
-# Upstream splits distributed inference, tensor-parallel transport, the SSD
-# expert cache, and layer placement into GPU-agnostic translation units. They
-# are shared by every GPU mode, so append them unconditionally below.
+# ds4_distributed.o and ds4_ssd.o are GPU-agnostic translation units that
+# ds4.c/ds4_cpu.o now reference (upstream split distributed inference and the
+# SSD expert-cache into their own .c files). Both objects are shared by every
+# GPU mode, so they are appended unconditionally below.
 ifeq ($(BUILD_TYPE),cublas)
     CMAKE_ARGS += -DDS4_GPU=cuda
-    DS4_OBJ_TARGET := ds4.o ds4_cuda.o ds4_distributed.o ds4_tp.o ds4_ssd.o ds4_layer_pack.o
+    DS4_OBJ_TARGET := ds4.o ds4_cuda.o ds4_distributed.o ds4_ssd.o
 else ifeq ($(UNAME_S),Darwin)
     CMAKE_ARGS += -DDS4_GPU=metal
-    DS4_OBJ_TARGET := ds4.o ds4_metal.o ds4_distributed.o ds4_tp.o ds4_ssd.o ds4_layer_pack.o
+    DS4_OBJ_TARGET := ds4.o ds4_metal.o ds4_distributed.o ds4_ssd.o
 else
     # CPU reference path (Linux only - macOS CPU path is broken by VM bug per ds4 README).
     CMAKE_ARGS += -DDS4_GPU=cpu
-    DS4_OBJ_TARGET := ds4_cpu.o ds4_distributed.o ds4_tp.o ds4_ssd.o ds4_layer_pack.o
+    DS4_OBJ_TARGET := ds4_cpu.o ds4_distributed.o ds4_ssd.o
 endif
 
 ifneq ($(NATIVE),true)
@@ -55,11 +56,11 @@ ds4:
 # the right per-platform compile flags (Objective-C/Metal on Darwin, nvcc on Linux+CUDA).
 ds4/ds4.o: ds4
 ifeq ($(BUILD_TYPE),cublas)
-	+$(MAKE) -C ds4 ds4.o ds4_cuda.o ds4_distributed.o ds4_tp.o ds4_ssd.o ds4_layer_pack.o
+	+$(MAKE) -C ds4 ds4.o ds4_cuda.o ds4_distributed.o ds4_ssd.o
 else ifeq ($(UNAME_S),Darwin)
-	+$(MAKE) -C ds4 ds4.o ds4_metal.o ds4_distributed.o ds4_tp.o ds4_ssd.o ds4_layer_pack.o
+	+$(MAKE) -C ds4 ds4.o ds4_metal.o ds4_distributed.o ds4_ssd.o
 else
-	+$(MAKE) -C ds4 ds4_cpu.o ds4_distributed.o ds4_tp.o ds4_ssd.o ds4_layer_pack.o
+	+$(MAKE) -C ds4 ds4_cpu.o ds4_distributed.o ds4_ssd.o
 endif
 
 grpc-server: ds4/ds4.o