fix(opencodego): reasoning fallback + simplify OpenCode Go catalog (#33)

* refactor: remove opencodego client and legacy model tier configs

Drop the OpenCode Go provider and hawk ModelKey tier tables in favor of
live catalog data and deployment routing.

* feat(opencodego): OpenAI-compatible client with live model discovery

Reuse chat/completions and GET /models like other gateways: thin
OpenCodeGoClient wrapper, dynamic catalog fetch, and filter out models
that require the messages API (MiniMax, Qwen3.x).

* feat(opencodego): dual-protocol routing with shared DualProtocolPair

Route MiniMax/Qwen via /v1/messages with chat/completions fallback, discover all models live, and centralize OpenAI/Anthropic switching for OpenCode Go and MiMo.

* refactor(client): rename DualProtocolPair to ProtocolRouter

Reuse OpenAIClient and AnthropicClient directly for chat-first OpenCode Go models; keep ProtocolRouter for shared fallback orchestration only.

* fix(opencodego): recover reasoning-only MiniMax streams via chat fallback

When /v1/messages streams thinking without answer text, retry through
non-streaming chat/completions before streaming fallback so MiniMax M3
returns usable replies on OpenCode Go.

* fix(ci): satisfy lint after main merge

Remove redundant nil checks in ProtocolRouter and delete unused tier helpers.

* fix(ci): remove unused contains helper

Author: Patel230

catalog/catalog_test.go

@@ -35,18 +35,27 @@ func TestGetModelMarketingName(t *testing.T) {
 	}
 }
 
-func TestGetProviderModelCandidates_LiveSetupProvidersEmpty(t *testing.T) {
-	if got := GetProviderModelCandidates("anthropic", TierSonnet); len(got) != 0 {
-		t.Fatalf("anthropic tier candidates should be empty, got %v", got)
+func TestGetProviderModelCandidates_AllProvidersNil(t *testing.T) {
+	// All providers return nil candidates (fully dynamic)
+	allProviders := []string{
+		"anthropic", "openai", "gemini", "grok", "bedrock", "kimi",
+	}
+	for _, provider := range allProviders {
+		if got := GetProviderModelCandidates(provider, TierSonnet); got != nil {
+			t.Fatalf("%s tier candidates should be nil, got %v", provider, got)
+		}
 	}
 }
 
-func TestGetProviderDefaultModel_LiveSetupProvidersEmptyWithoutCatalog(t *testing.T) {
-	if got := GetProviderDefaultModel("anthropic", nil); got != "" {
-		t.Fatalf("anthropic default should be empty without catalog, got %q", got)
+func TestGetProviderDefaultModel_AllProvidersEmptyWithoutCatalog(t *testing.T) {
+	// All providers return empty without a catalog (fully dynamic)
+	allProviders := []string{
+		"anthropic", "openai", "gemini", "grok", "bedrock", "kimi",
 	}
-	if got := GetProviderDefaultModel("openai", nil); got != "" {
-		t.Fatalf("openai default should be empty without catalog, got %q", got)
+	for _, provider := range allProviders {
+		if got := GetProviderDefaultModel(provider, nil); got != "" {
+			t.Fatalf("%s default should be empty without catalog, got %q", provider, got)
+		}
 	}
 }
 
@@ -76,17 +85,3 @@ func TestModelsForProvider(t *testing.T) {
 		t.Error("expected no models for nil catalog")
 	}
 }
-
-func TestCanonicalModelIDs(t *testing.T) {
-	ids := CanonicalModelIDs()
-	if len(ids) != len(AllModelConfigs) {
-		t.Errorf("expected %d canonical IDs, got %d", len(AllModelConfigs), len(ids))
-	}
-}
-
-func TestCanonicalIDToKey(t *testing.T) {
-	m := CanonicalIDToKey()
-	if _, ok := m["claude-sonnet-4-6"]; !ok {
-		t.Error("expected claude-sonnet-4-6 in canonical ID to key map")
-	}
-}

catalog/live/fetchers.go

@@ -13,6 +13,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/GrayCodeAI/eyrie/catalog/opencodego"
 	"github.com/GrayCodeAI/eyrie/catalog/xiaomi"
 )
 
@@ -24,7 +25,7 @@ const (
 	DefaultZAIBaseURL        = "https://api.z.ai/api/paas/v4"
 	DefaultOpenAIBaseURL     = "https://api.openai.com/v1"
 	DefaultGrokBaseURL       = "https://api.x.ai/v1"
-	DefaultOpenCodeGoBaseURL = "https://opencode.ai/zen/go/v1"
+	DefaultOpenCodeGoBaseURL = opencodego.DefaultBaseURL
 	DefaultKimiBaseURL       = "https://api.moonshot.ai/v1"
 	DefaultXiaomiBaseURL     = "https://api.xiaomimimo.com/v1"
 )
@@ -489,11 +490,18 @@ func FetchCanopyWave(env map[string]string) ([]Entry, error) {
 }
 
 func FetchOpenCodeGo(env map[string]string) ([]Entry, error) {
-	return fetchOpenAICompatModels(
+	entries, err := fetchOpenAICompatModels(
 		context.Background(),
 		envOr(env, "OPENCODEGO_BASE_URL", DefaultOpenCodeGoBaseURL),
 		env["OPENCODEGO_API_KEY"], "Bearer",
 	)
+	if err != nil {
+		return nil, err
+	}
+	for i := range entries {
+		entries[i].ID = opencodego.NativeModelID(entries[i].ID)
+	}
+	return entries, nil
 }
 
 func FetchKimi(env map[string]string) ([]Entry, error) {

catalog/live/opencodego_test.go

@@ -21,7 +21,9 @@ func TestFetchOpenCodeGo_MockHTTPServer(t *testing.T) {
 			Data []json.RawMessage `json:"data"`
 		}{
 			Data: []json.RawMessage{
-				json.RawMessage(`{"id":"ocg/model-1","display_name":"OCG Model 1","status":1}`),
+				json.RawMessage(`{"id":"kimi-k2.6","owned_by":"opencode"}`),
+				json.RawMessage(`{"id":"minimax-m2.7","owned_by":"opencode"}`),
+				json.RawMessage(`{"id":"qwen3.7-max","owned_by":"opencode"}`),
 			},
 		}
 		_ = json.NewEncoder(w).Encode(resp)
@@ -35,15 +37,12 @@ func TestFetchOpenCodeGo_MockHTTPServer(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	if len(entries) != 1 {
-		t.Fatalf("expected 1 model, got %d", len(entries))
+	if len(entries) != 3 {
+		t.Fatalf("expected all 3 models, got %d", len(entries))
 	}
-	if entries[0].ID != "ocg/model-1" {
+	if entries[0].ID != "kimi-k2.6" {
 		t.Fatalf("id = %q", entries[0].ID)
 	}
-	if len(entries[0].RawJSON) == 0 {
-		t.Fatal("expected RawJSON to be preserved")
-	}
 }
 
 func TestFetchOpenCodeGo_NoKey(t *testing.T) {

catalog/live_catalog.go

@@ -10,10 +10,10 @@ import (
 // LiveCatalogStaleDuration is how long a cache remains fresh after live provider APIs were merged.
 const LiveCatalogStaleDuration = 24 * time.Hour
 
-// IsLiveOnlyProvider reports setup providers that list models from live APIs only (not static tiers).
+// IsLiveOnlyProvider reports whether a provider uses live API discovery only.
+// All providers are now fully dynamic.
 func IsLiveOnlyProvider(providerID string) bool {
-	_, ok := registry.SpecByProviderID(normalizeLiveProviderID(providerID))
-	return ok
+	return true
 }
 
 // DeploymentIDForLiveCatalogKey maps a live fetch catalog key to a deployment ID.

catalog/live_catalog_test.go

@@ -7,14 +7,15 @@ import (
 )
 
 func TestIsLiveOnlyProvider(t *testing.T) {
-	if !catalog.IsLiveOnlyProvider("canopywave") {
-		t.Fatal("canopywave should be live-only")
+	// All providers are now fully dynamic
+	allProviders := []string{
+		"anthropic", "openai", "gemini", "grok", "canopywave", "z-ai", "openrouter", "ollama", "opencodego",
+		"azure", "bedrock", "vertex", "kimi", "xiaomi_mimo_payg", "xiaomi_mimo_token_plan", "deepseek",
 	}
-	if !catalog.IsLiveOnlyProvider("z-ai") {
-		t.Fatal("z-ai should be live-only")
-	}
-	if !catalog.IsLiveOnlyProvider("anthropic") {
-		t.Fatal("anthropic should be live-only")
+	for _, p := range allProviders {
+		if !catalog.IsLiveOnlyProvider(p) {
+			t.Fatalf("%s should be live-only (all providers are fully dynamic)", p)
+		}
 	}
 }
 
@@ -30,8 +31,14 @@ func TestFirstModelForProvider(t *testing.T) {
 	}
 }
 
-func TestGetProviderDefaultModel_LiveOnlySkipsHardcoded(t *testing.T) {
-	if got := catalog.GetProviderDefaultModel("canopywave", &catalog.ModelCatalog{}); got != "" {
-		t.Fatalf("expected empty default without catalog, got %q", got)
+func TestGetProviderDefaultModel_AllProvidersEmptyWithoutCatalog(t *testing.T) {
+	// All providers return empty without a catalog (fully dynamic)
+	allProviders := []string{
+		"anthropic", "openai", "gemini", "grok", "bedrock", "kimi",
+	}
+	for _, p := range allProviders {
+		if got := catalog.GetProviderDefaultModel(p, &catalog.ModelCatalog{}); got != "" {
+			t.Fatalf("%s: expected empty default without catalog, got %q", p, got)
+		}
 	}
 }