Stop shipping a placeholder that looks like a value, and say what is served
CI / test (push) Successful in 1m23s

A user copied the curl from the profile page and sent it as it stood. Every
other field in that snippet is filled in for them — the base URL, the key
they had just been issued — so "model": "MODEL" reads as a value rather
than a blank, and they got:

  no endpoint serves "MODEL"

which is true and useless. It reads the same whether the name was a typo,
a placeholder left in from the documentation, or a real outage, and it
never says what would have worked.

The message now lists what is being served, capped at ten with a count for
the rest, and says plainly when nothing is. That list is what /v1/models
already returns to the same caller, so it discloses nothing new.

The profile page's example now names a model that is actually running,
real ones before simulated — the point of an example someone can run is
that it runs, and sending a first request to the sim engine would answer
in Greek letters. The landing and claim pages keep a placeholder, because
they are served without a key and deliberately say nothing about what is
here; theirs is <model-name>, which cannot be mistaken for a value, with a
line saying where to get the real one.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Ilker ManapandClaude Opus 5 committed 2026-09-16 18:23:19 +02:00
1 parent 6f3bde099e
commit 082d52bc97
8 files changed
+170 -6

No files matched your search

+49
View File
@@ -5,6 +5,7 @@ import (
"context"
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
"slices"
@@ -107,6 +108,9 @@ func (r *Router) Handler() http.Handler {
// authenticated by a session cookie, not by an API key, which is why
// they are exempt below.
pages := web.NewAccountPages(r.accounts, r.store, r.store, version.Version, r.log)
// So the example on the profile page names a model that is actually
// running, rather than a placeholder that gets sent as-is.
pages.ServedModels(r.exampleModels)
pages.Register(mux)
r.registerChat(mux, pages)
@@ -460,6 +464,51 @@ func injectIncludeUsage(body []byte) ([]byte, bool) {
return out, true
}
// noEndpointFor explains that nothing serves a model, and says what does.
//
// "no endpoint serves \"MODEL\"" was all a client got, which is true and
// useless: it reads the same whether the name was a typo, a placeholder left
// in from the documentation, or a real outage. Someone copying the curl from
// the account page sent the literal word MODEL and had nothing to go on.
//
// The list is what /v1/models already returns to the same caller, so naming it
// here discloses nothing new. It is capped because a large catalog would turn
// an error message into a page.
func noEndpointFor(model string, served []string) string {
if len(served) == 0 {
return fmt.Sprintf("no endpoint serves %q, and no model is currently being served", model)
}
const showAt = 10
shown := served
suffix := ""
if len(shown) > showAt {
shown, suffix = shown[:showAt], fmt.Sprintf(" and %d more", len(served)-showAt)
}
return fmt.Sprintf("no endpoint serves %q; available models are %s%s",
model, strings.Join(shown, ", "), suffix)
}
// exampleModels is servedModels with the ones that answer for real first.
//
// The profile page takes the first name for its copy-pasteable example, and
// handing it a simulated model would send someone's first request to an engine
// that replies in Greek letters.
func (r *Router) exampleModels() []string {
names := r.servedModels()
slices.SortStableFunc(names, func(a, b string) int {
as, bs := r.models[a].Simulated(), r.models[b].Simulated()
switch {
case as == bs:
return 0
case bs:
return -1
default:
return 1
}
})
return names
}
// servedModels lists the canonical models at least one endpoint serves.
func (r *Router) servedModels() []string {
seen := map[string]struct{}{}
+1 -1
View File
@@ -419,7 +419,7 @@ var errNoCapacity = errors.New("no endpoint available")
func (r *Router) dispatchOne(ctx context.Context, w http.ResponseWriter, req *parsedRequest, model string, entry catalog.Model) dispatchResult {
candidates := r.reg.Snapshots(model)
if len(candidates) == 0 {
return dispatchResult{err: fmt.Errorf("%w: no endpoint serves %q", errNoCapacity, model)}
return dispatchResult{err: fmt.Errorf("%w: %s", errNoCapacity, noEndpointFor(model, r.servedModels()))}
}
profile := r.profileFor(entry, req.ProfileOverride)
+52
View File
@@ -363,3 +363,55 @@ func TestSessionHeaderFallsBackToUser(t *testing.T) {
t.Errorf("the header should win, got %q", got)
}
}
func TestUnknownModelErrorNamesWhatIsAvailable(t *testing.T) {
// Reported by a user who copied the curl from the account page and sent
// its placeholder unchanged. "no endpoint serves \"MODEL\"" is true and
// useless: it reads the same for a typo, a placeholder and a real outage.
e := newFakeEngine(t, "m")
rt := newTestRouter(t, baseConfig(config.Endpoint{ID: "a", URL: e.srv.URL, Models: []string{"m"}}))
rec := post(t, rt.Handler(), map[string]any{"model": "MODEL", "messages": []any{}}, nil)
if rec.Code != http.StatusServiceUnavailable {
t.Fatalf("status %d, expected 503", rec.Code)
}
var body struct {
Error struct {
Message string `json:"message"`
} `json:"error"`
}
if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
t.Fatalf("error body is not JSON: %q", rec.Body.String())
}
if !strings.Contains(body.Error.Message, `"MODEL"`) {
t.Errorf("the message does not repeat what was asked for: %q", body.Error.Message)
}
if !strings.Contains(body.Error.Message, "m") ||
!strings.Contains(body.Error.Message, "available") {
t.Errorf("the message does not say what is available: %q", body.Error.Message)
}
}
func TestTheErrorDoesNotBecomeAPage(t *testing.T) {
// A large catalog must not turn one error into a wall of names.
var many []string
for i := range 40 {
many = append(many, fmt.Sprintf("model-%02d", i))
}
msg := noEndpointFor("nope", many)
if !strings.Contains(msg, "and 30 more") {
t.Errorf("the list was not capped: %q", msg)
}
if strings.Contains(msg, "model-11") {
t.Errorf("more than the cap was listed: %q", msg)
}
}
func TestTheErrorIsHonestWhenNothingIsServed(t *testing.T) {
// Listing nothing as "available models are " would read as a truncated
// message rather than an empty cluster.
msg := noEndpointFor("m", nil)
if !strings.Contains(msg, "no model is currently being served") {
t.Errorf("an empty fleet is not explained: %q", msg)
}
}