The cluster page and the console say which picture and 3D models are here, and add them

A site whose catalog had no flux-schnell or triposr showed no Images or 3D
page, and nothing said they were one click away. The cluster page now has
a Pictures and 3D models card under the models: each preset, what it
makes, the classes of card here it fits, whether and by whom it was
added, and why the leader has not added it by itself; an Add button, which
says first when it would install ComfyUI on the GPU nodes and restart the
control planes; and the switch for presets.auto. The console's models
screen shows the same under its table: A adds one, asking first in the
same case, and P turns automatic adding on or off.

`ctl model add PRESET` and `ctl model presets` go through the presets API,
so the control plane keeps who added one, and `ctl model presets auto
on|off` flips the setting; against a control plane from before, add sends
the entry as v0.14.4 did.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Ilker ManapandClaude Opus 5.5 committed 2026-10-13 20:40:19 +02:00
1 parent e0adcc5c4e
commit 85a2bdd0e3
16 files changed
+746 -21

No files matched your search

+16 -1
View File
@@ -3,6 +3,7 @@ package cli
import (
"encoding/json"
"fmt"
"net/url"
"os"
"os/user"
"slices"
@@ -32,7 +33,7 @@ func newModelCmd(client func() *ctlClient, asJSON *bool) *cobra.Command {
Use: "model",
Short: "Add or remove models while the cluster is running",
}
c.AddCommand(newModelAddCmd(client), newModelPresetsCmd(), newModelRemoveCmd(client), newModelPlanCmd(client),
c.AddCommand(newModelAddCmd(client), newModelPresetsCmd(client, asJSON), newModelRemoveCmd(client), newModelPlanCmd(client),
newResourcesCmd(client), newClassCmd(client), newOwnerCmd(client),
newTargetCmd(client, asJSON), newAdaptersCmd(client),
newModelServeCmd(client), newModelUpdatesCmd(client, asJSON), newModelUpdateCmd(client),
@@ -73,6 +74,20 @@ func newModelAddCmd(client func() *ctlClient) *cobra.Command {
return fmt.Errorf("no preset %q: there are %s; any other model is added from a file (-f)",
args[0], strings.Join(catalog.PresetNames(), ", "))
}
// The control plane adds it, and keeps that it was added as
// a preset, by whom; one from before it could is sent the
// entry, as it was then.
var res adminapi.ModelAdded
err := client().post(cmd.Context(), "/api/v1/presets/"+url.PathEscape(p.Model.Name), []byte("{}"), &res)
if err == nil {
fmt.Fprintf(cmd.OutOrStdout(),
"%s added, and ComfyUI with it where the cluster had none. It is placed on the next\n"+
"reconcile pass and loads when first asked for; watch it with:\n llmgw ctl models\n", p.Model.Name)
return nil
}
if !olderControlPlane(err) {
return err
}
m = p.Model
case path == "":
return fmt.Errorf("a preset (%s) or --file, the model definition as YAML",
+93 -10
View File
@@ -1,7 +1,9 @@
package cli
import (
"encoding/json"
"fmt"
"strings"
"github.com/spf13/cobra"
@@ -11,25 +13,106 @@ import (
"gitea.mynodes.xyz/ilker/llmgw/internal/settings"
)
func newModelPresetsCmd() *cobra.Command {
return &cobra.Command{
func newModelPresetsCmd(client func() *ctlClient, asJSON *bool) *cobra.Command {
c := &cobra.Command{
Use: "presets",
Short: "The models that come with llmgw, added by name",
Short: "The models that come with llmgw: whether each fits and is here",
Long: "Each is a catalog entry whose workflow, custom nodes, packages and licence\n" +
"were found and tried, and whose profile says the card it needs rather than\n" +
"a class, so it places on any site's cards. Add one with\n" +
"`llmgw ctl model add NAME`.",
"`llmgw ctl model add NAME`.\n\n" +
"While presets.auto is on, the leader adds one by itself when a card fits it\n" +
"and the catalog has nothing that makes what it makes; one somebody removed\n" +
"is not added again by itself.",
Args: cobra.NoArgs,
RunE: func(cmd *cobra.Command, _ []string) error {
w := tabTo(cmd.OutOrStdout())
fmt.Fprintln(w, "NAME\tMAKES\tCARD\tLICENCE\tWHAT IT IS FOR")
for _, p := range catalog.Presets() {
fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\n", p.Model.Name, p.Makes, presetCard(p.Model),
presetLicence(p.Model), p.Model.Description)
var v adminapi.PresetsView
err := client().get(cmd.Context(), "/api/v1/presets", &v)
if err != nil && !olderControlPlane(err) {
return err
}
return w.Flush()
if *asJSON && err == nil {
return emitJSON(v)
}
w := tabTo(cmd.OutOrStdout())
if err != nil {
// A control plane from before it kept them: what this
// release has, with nothing about the cluster.
fmt.Fprintln(w, "NAME\tMAKES\tCARD\tLICENCE\tWHAT IT IS FOR")
for _, p := range catalog.Presets() {
fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\n", p.Model.Name, p.Makes, presetCard(p.Model),
presetLicence(p.Model), p.Model.Description)
}
return w.Flush()
}
fmt.Fprintln(w, "NAME\tMAKES\tCARD\tLICENCE\tFITS\tHERE\tWHAT IT IS FOR")
for _, p := range v.Presets {
fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\t%s\t%s\n", p.Name, p.Makes, p.Card, licenceText(p.Licence),
orDash(strings.Join(p.FitsClasses, ",")), presetState(p), p.Description)
}
if err := w.Flush(); err != nil {
return err
}
if v.Auto {
fmt.Fprintln(cmd.OutOrStdout(), "\nAdded by themselves where a card fits (presets.auto); "+
"llmgw ctl model presets auto off stops it.")
} else {
fmt.Fprintln(cmd.OutOrStdout(), "\nNot added by themselves; llmgw ctl model presets auto on starts it.")
}
return nil
},
}
c.AddCommand(&cobra.Command{
Use: "auto on|off",
Short: "Whether the leader adds a preset by itself where a card fits it",
Args: cobra.ExactArgs(1),
ValidArgs: []string{"on", "off"},
RunE: func(cmd *cobra.Command, args []string) error {
if args[0] != "on" && args[0] != "off" {
return fmt.Errorf("on or off, not %q", args[0])
}
body, _ := json.Marshal(adminapi.PresetsAutoRequest{On: args[0] == "on"})
var v adminapi.PresetsView
if err := client().put(cmd.Context(), "/api/v1/presets/auto", body, &v); err != nil {
return err
}
if v.Auto {
fmt.Fprintln(cmd.OutOrStdout(), "Presets are added by themselves where a card fits.")
} else {
fmt.Fprintln(cmd.OutOrStdout(), "Presets are no longer added by themselves.")
}
return nil
},
})
return c
}
// olderControlPlane is an error from a control plane that has no such path:
// one from before it was added.
func olderControlPlane(err error) bool {
s := err.Error()
return strings.Contains(s, "answered with a page") || strings.HasPrefix(s, "404 Not Found: 404 page not found")
}
func presetState(p adminapi.PresetView) string {
switch {
case p.InCatalog && p.AddedBy == "auto":
return "added by itself"
case p.InCatalog && p.AddedBy != "":
return "added by " + p.AddedBy
case p.InCatalog:
return "here"
case p.Declined:
return "removed; stays out"
}
return "—"
}
func licenceText(l catalog.License) string {
if l.Commercial != nil && !*l.Commercial {
return l.Name + ", not commercial"
}
return l.Name
}
func presetCard(m catalog.Model) string {
+21
View File
@@ -17,6 +17,10 @@ import (
// presetAdmin is an admin API holding settings, which records the models
// added and the settings put.
type presetAdmin struct {
// api is a control plane that adds presets itself; without it, one
// from before, which answers their paths with a 404.
api bool
byAPI []string
mu sync.Mutex
settings string
added []catalog.Model
@@ -30,6 +34,10 @@ func (a *presetAdmin) client(t *testing.T) func() *ctlClient {
body, _ := io.ReadAll(r.Body)
w.Header().Set("Content-Type", "application/json")
switch {
case a.api && r.Method == http.MethodPost && strings.HasPrefix(r.URL.Path, "/api/v1/presets/"):
name := strings.TrimPrefix(r.URL.Path, "/api/v1/presets/")
a.byAPI = append(a.byAPI, name)
_ = json.NewEncoder(w).Encode(adminapi.ModelAdded{Added: name})
case r.Method == http.MethodPost && r.URL.Path == "/api/v1/models":
var m catalog.Model
_ = json.Unmarshal(body, &m)
@@ -62,6 +70,19 @@ func runModelAdd(t *testing.T, client func() *ctlClient, args ...string) (string
return out.String(), err
}
func TestAPresetIsAddedByTheControlPlane(t *testing.T) {
a := &presetAdmin{api: true}
out, err := runModelAdd(t, a.client(t), "triposr")
if err != nil {
t.Fatalf("%v\n%s", err, out)
}
if len(a.byAPI) != 1 || a.byAPI[0] != "triposr" || len(a.added) != 0 || len(a.put) != 0 {
t.Errorf("by the API %v; sent the entry %v; settings %v", a.byAPI, a.added, a.put)
}
}
// A control plane from before presets were its own is sent the entry, and
// ComfyUI set beside it, as the release that brought presets did.
func TestAPresetIsAddedByNameAndHasTheNodesInstallComfyUI(t *testing.T) {
a := &presetAdmin{settings: "router:\n retries: 2\n"}
out, err := runModelAdd(t, a.client(t), "triposr")
+17 -2
View File
@@ -90,7 +90,10 @@ type consoleData struct {
// federation is the other llmgw clusters whose models are offered
// here; empty on a control plane without a store.
federation adminapi.FederationView
err error
// presets is the models that come with llmgw as they stand here; nil
// from a control plane that cannot say.
presets *adminapi.PresetsView
err error
}
type (
@@ -275,6 +278,10 @@ func (m consoleModel) fetch() tea.Cmd {
_ = c.get(ctx, "/api/v1/jobs", &d.jobs)
_ = c.get(ctx, "/api/v1/audit?since=7d&limit=300", &d.audit)
_ = c.get(ctx, "/api/v1/federation", &d.federation)
var presets adminapi.PresetsView
if c.get(ctx, "/api/v1/presets", &presets) == nil {
d.presets = &presets
}
return consoleDataMsg(d)
}
}
@@ -599,6 +606,10 @@ func (m consoleModel) key(k tea.KeyMsg) (tea.Model, tea.Cmd) {
m.hf.models, m.hf.err, m.row = nil, nil, 0
return m, m.fetchHF()
}
case "p":
if m.menu == cModels && m.inPanel && m.data.presets != nil {
m.autoPresetsConfirm()
}
case "a":
switch m.menu {
case cQuotas:
@@ -1238,8 +1249,12 @@ func (m consoleModel) panel() (title, body, keys string) {
}
if m.inPanel {
keys = "↑↓ row · Enter actions · A add a model · ← back · Q leave"
if m.data.presets != nil {
keys = "↑↓ row · Enter actions · A add a model · P pictures and 3D added by themselves · ← back · Q leave"
}
}
return "Models", "\n" + table([]string{"MODEL", "READY", "STATUS", "CLASS", "PROFILES", "UPDATE", ""}, rows, m.row, pw, m.inPanel), keys
return "Models", "\n" + table([]string{"MODEL", "READY", "STATUS", "CLASS", "PROFILES", "UPDATE", ""}, rows, m.row, pw, m.inPanel) +
presetsBlock(m.data.presets, pw), keys
case cReplicas:
var rows [][]string
for _, r := range m.data.replicas {
+7 -2
View File
@@ -269,15 +269,20 @@ func (m *consoleModel) addModelForm() {
}
note.WriteString("A ComfyUI one has the nodes install ComfyUI if the cluster has none.\n" +
"Or a definition file: the YAML a model takes in server.yaml's models.")
var choices []string
for _, n := range catalog.PresetNames() {
choices = append(choices, presetChoice(m.data.presets, n))
}
m.openForm(&formDialog{title: "Add a model",
note: note.String(),
fields: []formField{
choiceF("model", append(catalog.PresetNames(), fromFile), catalog.PresetNames()[0]),
choiceF("model", append(choices, fromFile), choices[0]),
textF("file", "", "for "+fromFile+": like /root/qwen.yaml"),
},
submit: func(m *consoleModel, v []string) (tea.Cmd, error) {
if v[0] != fromFile {
return m.runCLI("Add "+v[0], "ctl", server, "model", "add", v[0]), nil
// The name, without what the choice says beside it.
return m.addPreset(strings.Fields(v[0])[0]), nil
}
if v[1] == "" {
return nil, fmt.Errorf("a file, or a model that comes with llmgw")
+128
View File
@@ -0,0 +1,128 @@
package cli
import (
"encoding/json"
"net/http"
"net/url"
"strings"
tea "github.com/charmbracelet/bubbletea"
"gitea.mynodes.xyz/ilker/llmgw/internal/control/adminapi"
)
// presetsBlock is the models that come with llmgw, under the models table:
// whether each fits a card here and whether it is in the catalog, and
// whether the leader adds them by itself. Empty from a control plane that
// cannot say.
func presetsBlock(v *adminapi.PresetsView, width int) string {
if v == nil || len(v.Presets) == 0 {
return ""
}
var rows [][]string
var why []string
for _, p := range v.Presets {
rows = append(rows, []string{p.Name, p.Makes, orDash(strings.Join(p.FitsClasses, ",")), presetState(p)})
// Why the leader leaves it, under the table: a reason is longer than
// any column the panel has room for. Automatic adding being off is
// said once, below.
if p.Blocked != "" && !strings.HasPrefix(p.Blocked, "presets.auto") && !p.Declined {
why = append(why, " "+wrap(p.Name+": "+p.Blocked, width-4, " "))
}
}
auto := "Added by themselves where a card fits · P stops that"
if !v.Auto {
auto = "Not added by themselves · P starts that · A adds one"
}
out := "\n\n Pictures and 3D models that come with llmgw\n" +
table([]string{"PRESET", "MAKES", "FITS", "HERE"}, rows, -1, width, false)
if len(why) > 0 {
out += "\n" + sDim.Render(strings.Join(why, "\n"))
}
return out + "\n " + sDim.Render(auto)
}
// presetChoice is how a preset is offered in the add dialog: its name, and
// where it stands when that is worth knowing before choosing it.
func presetChoice(v *adminapi.PresetsView, name string) string {
if v == nil {
return name
}
for _, p := range v.Presets {
if p.Name != name {
continue
}
switch {
case p.InCatalog:
return name + " (already here)"
case presetAddsComfyUI(v, p):
return name + " (installs ComfyUI too)"
case !p.Fits:
return name + " (no card here fits it)"
case p.Declined:
return name + " (removed before)"
}
}
return name
}
// presetAddsComfyUI is whether adding a preset by hand also sets
// engines.comfyui, which has the GPU nodes install it and the control planes
// restart on the setting.
func presetAddsComfyUI(v *adminapi.PresetsView, p adminapi.PresetView) bool {
return v != nil && !p.InCatalog && v.ComfyUI == ""
}
// addPreset adds a preset through the control plane, or, from one from
// before it could, the way the release that brought presets did. One whose
// adding installs ComfyUI and restarts the control planes is asked about
// first.
func (m *consoleModel) addPreset(name string) tea.Cmd {
if m.data.presets != nil {
for _, p := range m.data.presets.Presets {
if p.Name == name && presetAddsComfyUI(m.data.presets, p) {
m.confirmD = &confirmDialog{title: "Add " + name + " and ComfyUI",
text: "The cluster installs no ComfyUI yet. Adding " + name + " sets engines.comfyui:\n" +
"every GPU node installs it, about 10 GB each, and the control planes restart\n" +
"on the setting, standbys first. Engines keep serving.",
yes: func(m *consoleModel) tea.Cmd { return m.postPreset(name) }}
return nil
}
}
}
return m.postPreset(name)
}
func (m *consoleModel) postPreset(name string) tea.Cmd {
if m.data.presets == nil {
return m.runCLI("Add "+name, "ctl", "--server="+m.client.base, "model", "add", name)
}
return m.call("Add "+name, http.MethodPost, "/api/v1/presets/"+url.PathEscape(name), map[string]string{},
func(_ json.RawMessage) string {
return name + " is added, and ComfyUI with it where the cluster had none.\n" +
"It is placed on the next pass, and loads when first asked for."
})
}
// autoPresetsConfirm turns the adding of presets by themselves on or off,
// after saying what that does.
func (m *consoleModel) autoPresetsConfirm() {
on := !m.data.presets.Auto
title, text := "Stop adding pictures and 3D models by themselves",
"Presets already added stay. A preset is added only when somebody adds it."
if on {
title, text = "Add pictures and 3D models by themselves",
"Where a card fits one and the catalog has nothing that makes what it makes, the leader adds it.\n"+
"That also has every GPU node install ComfyUI, about 10 GB each, and the mirror fetch its weights.\n"+
"A preset somebody removed is not added again."
}
m.confirmD = &confirmDialog{title: title, text: text, yes: func(m *consoleModel) tea.Cmd {
return m.call(title, http.MethodPut, "/api/v1/presets/auto", adminapi.PresetsAutoRequest{On: on},
func(_ json.RawMessage) string {
if on {
return "Presets are added by themselves where a card fits."
}
return "Presets are no longer added by themselves."
})
}}
}
+63
View File
@@ -0,0 +1,63 @@
package cli
import (
"strings"
"testing"
tea "github.com/charmbracelet/bubbletea"
"gitea.mynodes.xyz/ilker/llmgw/internal/control/adminapi"
)
func presetsHere() *adminapi.PresetsView {
return &adminapi.PresetsView{Auto: true, Presets: []adminapi.PresetView{
{Name: "flux-schnell", Makes: "pictures", Card: "cc 7.0+, 24 GB+", Fits: true, FitsClasses: []string{"v100-32g"},
Blocked: "the cluster installs no ComfyUI (engines.comfyui); adding it by hand sets that"},
{Name: "triposr", Makes: "meshes", Card: "cc 7.0+, 8 GB+", Fits: true, InCatalog: true, AddedBy: "auto"},
}}
}
func TestThePresetsAreOnTheModelsScreen(t *testing.T) {
m, _ := consoleWith(t, cModels)
m.data.presets = presetsHere()
v := m.View()
for _, want := range []string{"Pictures and 3D models that come with llmgw", "flux-schnell", "v100-32g",
"installs no ComfyUI", "added by itself", "P pictures and 3D"} {
if !strings.Contains(v, want) {
t.Errorf("%q not shown:\n%s", want, v)
}
}
// A control plane that cannot say shows none of it.
m.data.presets = nil
if v := m.View(); strings.Contains(v, "come with llmgw") || strings.Contains(v, "P pictures") {
t.Errorf("presets shown from nothing:\n%s", v)
}
}
func TestAPresetThatInstallsComfyUIIsAddedOnlyWhenConfirmed(t *testing.T) {
m, s := consoleWith(t, cModels)
m.data.presets = presetsHere()
var tm tea.Model = m
tm = press(tm, "a")
f := tm.(consoleModel).formD
if f == nil || !strings.Contains(f.fields[0].value(), "installs ComfyUI too") {
t.Fatalf("no add dialog saying what flux-schnell brings: %+v", f)
}
tm = press(tm, "enter", "enter", "enter")
if tm.(consoleModel).confirmD == nil || s.last() != "" {
t.Fatalf("added without asking: %q", s.last())
}
tm = pressRun(tm, "y")
if got := s.last(); got != "POST /api/v1/presets/flux-schnell {}" {
t.Fatalf("sent %q", got)
}
tm = press(tm, "esc", "p") // past what the add said
if c := tm.(consoleModel).confirmD; c == nil || !strings.HasPrefix(c.title, "Stop adding") {
t.Fatalf("P did not ask to stop: %+v", c)
}
_ = pressRun(tm, "y")
if got := s.last(); got != `PUT /api/v1/presets/auto {"on":false}` {
t.Fatalf("sent %q", got)
}
}