fix(provider): include full catalog in model picker, gate by credentials

Active() captured Catalog into a package var initializer, which runs
before the init() functions in catalog_builtin.go/extra_models.go append
the extended catalog. The picker therefore only ever saw the curated
seed list, dropping openrouter and every other extra provider. Defer the
Catalog read to call time so Active() reflects the fully-assembled list.

Also make the model dialog filter strictly by logged-in providers: an
empty credential set now yields an empty picker (with a /login hint)
instead of dumping the entire ~900-model catalog.

commit: edbbcc1086ea497e96a97b13a6213c40cade145b
author: patriceckhart · 4mo ago · 2026-05-29 09:26 UTC
parent: 5470345
signature: unsigned

2 files · +39 -19

M packages/agent/modes/model_dialog.go +19 -14


@@ -48,21 +48,22 @@ func newModelDialog() *modelDialog {
48	48		// it can be pre-selected.
49	49		func (d *modelDialog) Open(current string, loggedInProviders []string) {
50	50		d.active = true
51		-	all := provider.Active()
52		-	if len(loggedInProviders) > 0 {
53		-	provSet := map[string]bool{}
54		-	for _, p := range loggedInProviders {
55		-	provSet[p] = true
56		-	}
57		-	var filtered []provider.Model
58		-	for _, m := range all {
59		-	if provSet[m.Provider] {
60		-	filtered = append(filtered, m)
61		-	}
	51	+	// Only surface models the user can actually reach: a provider is
	52	+	// shown only when it has a resolvable credential (api key, oauth
	53	+	// subscription, or the always-available ollama). An empty
	54	+	// loggedInProviders list therefore yields an empty picker rather
	55	+	// than dumping the entire ~900-model catalog.
	56	+	provSet := map[string]bool{}
	57	+	for _, p := range loggedInProviders {
	58	+	provSet[p] = true
	59	+	}
	60	+	var filtered []provider.Model
	61	+	for _, m := range provider.Active() {
	62	+	if provSet[m.Provider] {
	63	+	filtered = append(filtered, m)
62	64		}
63		-	all = filtered
64	65		}
65		-	d.all = sortedModels(all)
	66	+	d.all = sortedModels(filtered)
66	67		d.current = current
67	68		d.query = ""
68	69		d.provW, d.idW = columnWidths(d.all)

@@ -148,7 +149,11 @@ func (d *modelDialog) Render(th tui.Theme, width int) []string {
148	149		lines = append(lines, th.FG256(th.Muted, hint))
149	150
150	151		if len(d.view) == 0 {
151		-	lines = append(lines, th.FG256(th.Muted, " no models match "+fmt.Sprintf("%q", d.query)))
	152	+	msg := " no models match " + fmt.Sprintf("%q", d.query)
	153	+	if len(d.all) == 0 {
	154	+	msg = " no credentials found - run /login to add an api key or subscription"
	155	+	}
	156	+	lines = append(lines, th.FG256(th.Muted, msg))
152	157		lines = append(lines, frameRule(th, width))
153	158		return lines
154	159		}

 // it can be pre-selected.
 func (d *modelDialog) Open(current string, loggedInProviders []string) {
 	d.active = true
-	all := provider.Active()
+	// Only surface models the user can actually reach: a provider is
-	if len(loggedInProviders) > 0 {
+	// shown only when it has a resolvable credential (api key, oauth
-		provSet := map[string]bool{}
+	// subscription, or the always-available ollama). An empty
-		for _, p := range loggedInProviders {
+	// loggedInProviders list therefore yields an empty picker rather
-			provSet[p] = true
+	// than dumping the entire ~900-model catalog.
-		}
+	provSet := map[string]bool{}
-		var filtered []provider.Model
+	for _, p := range loggedInProviders {
-		for _, m := range all {
+		provSet[p] = true
-			if provSet[m.Provider] {
+	}
-				filtered = append(filtered, m)
+	var filtered []provider.Model
-			}
+	for _, m := range provider.Active() {
+		if provSet[m.Provider] {
+			filtered = append(filtered, m)
 		}
-		all = filtered
 	}
-	d.all = sortedModels(all)
+	d.all = sortedModels(filtered)
 	d.current = current
 	d.query = ""
 	d.provW, d.idW = columnWidths(d.all)
 	lines = append(lines, th.FG256(th.Muted, hint))
 	if len(d.view) == 0 {
-		lines = append(lines, th.FG256(th.Muted, "  no models match "+fmt.Sprintf("%q", d.query)))
+		msg := "  no models match " + fmt.Sprintf("%q", d.query)
+		if len(d.all) == 0 {
+			msg = "  no credentials found - run /login to add an api key or subscription"
+		}
+		lines = append(lines, th.FG256(th.Muted, msg))
 		lines = append(lines, frameRule(th, width))
 		return lines
 	}

M packages/provider/models.go +20 -5


@@ -332,8 +332,9 @@ var DefaultModel = Catalog[0] // claude-sonnet-4-5
332	332		// models loaded via SetLiveModels.
333	333
334	334		var (
335		-	activeMu sync.RWMutex
336		-	active []Model = Catalog // default: just the static catalog
	335	+	activeMu sync.RWMutex
	336	+	active []Model // live overlay merged in via SetLiveModels; nil = none yet
	337	+	activeSet bool // true once SetLiveModels has run (even with empty live)
337	338		)
338	339
339	340		// SetLiveModels replaces the "live" overlay used by the active catalog.

@@ -342,19 +343,33 @@ var (
342	343		func SetLiveModels(live []Model) {
343	344		activeMu.Lock()
344	345		defer activeMu.Unlock()
	346	+	activeSet = true
345	347		if len(live) == 0 {
346		-	active = Catalog
	348	+	active = nil
347	349		return
348	350		}
349	351		active = MergeCatalog(live)
350	352		}
351	353
352	354		// Active returns the current merged catalog.
	355	+	//
	356	+	// When no live overlay has been set it returns the fully-assembled
	357	+	// static Catalog. Reading Catalog here (rather than capturing it into
	358	+	// a package-level var initializer) is load-bearing: the extended
	359	+	// catalog in catalog_builtin.go / extra_models.go is appended from
	360	+	// init() functions, which run AFTER package-level var initializers.
	361	+	// Snapshotting Catalog at var-init time would freeze the picker to the
	362	+	// curated seed list and drop every extra provider (openrouter, groq,
	363	+	// xai, ...). Deferring the read to call time avoids that ordering trap.
353	364		func Active() []Model {
354	365		activeMu.RLock()
355	366		defer activeMu.RUnlock()
356		-	out := make([]Model, len(active))
357		-	copy(out, active)
	367	+	src := active
	368	+	if !activeSet \|\| src == nil {
	369	+	src = Catalog
	370	+	}
	371	+	out := make([]Model, len(src))
	372	+	copy(out, src)
358	373		return out
359	374		}
360	375

 // models loaded via SetLiveModels.
 var (
-	activeMu sync.RWMutex
+	activeMu  sync.RWMutex
-	active   []Model = Catalog // default: just the static catalog
+	active    []Model // live overlay merged in via SetLiveModels; nil = none yet
+	activeSet bool    // true once SetLiveModels has run (even with empty live)
 )
 // SetLiveModels replaces the "live" overlay used by the active catalog.
 func SetLiveModels(live []Model) {
 	activeMu.Lock()
 	defer activeMu.Unlock()
+	activeSet = true
 	if len(live) == 0 {
-		active = Catalog
+		active = nil
 		return
 	}
 	active = MergeCatalog(live)
 }
 // Active returns the current merged catalog.
+//
+// When no live overlay has been set it returns the fully-assembled
+// static Catalog. Reading Catalog here (rather than capturing it into
+// a package-level var initializer) is load-bearing: the extended
+// catalog in catalog_builtin.go / extra_models.go is appended from
+// init() functions, which run AFTER package-level var initializers.
+// Snapshotting Catalog at var-init time would freeze the picker to the
+// curated seed list and drop every extra provider (openrouter, groq,
+// xai, ...). Deferring the read to call time avoids that ordering trap.
 func Active() []Model {
 	activeMu.RLock()
 	defer activeMu.RUnlock()
-	out := make([]Model, len(active))
+	src := active
-	copy(out, active)
+	if !activeSet || src == nil {
+		src = Catalog
+	}
+	out := make([]Model, len(src))
+	copy(out, src)
 	return out
 }