feat(config): update fallback model handling to support multiple models

internal/ai/compat/client_test.go

@@ -123,13 +123,13 @@ func TestExtractMetadataFallbackModel(t *testing.T) {
 	defer server.Close()
 
 	client := New(Config{
-		Name:                  "test",
-		BaseURL:               server.URL,
-		APIKey:                "secret",
-		MetadataModel:         "primary-model",
-		FallbackMetadataModel: "fallback-model",
-		HTTPClient:            server.Client(),
-		Log:                   discardLogger(),
+		Name:                   "test",
+		BaseURL:                server.URL,
+		APIKey:                 "secret",
+		MetadataModel:          "primary-model",
+		FallbackMetadataModels: []string{"fallback-model"},
+		HTTPClient:             server.Client(),
+		Log:                    discardLogger(),
 	})
 
 	metadata, err := client.ExtractMetadata(context.Background(), "hello")
@@ -265,13 +265,13 @@ func TestExtractMetadataFallsBackToHeuristicsWhenModelsFail(t *testing.T) {
 	defer server.Close()
 
 	client := New(Config{
-		Name:                  "test",
-		BaseURL:               server.URL,
-		APIKey:                "secret",
-		MetadataModel:         "primary",
-		FallbackMetadataModel: "secondary",
-		HTTPClient:            server.Client(),
-		Log:                   discardLogger(),
+		Name:                   "test",
+		BaseURL:                server.URL,
+		APIKey:                 "secret",
+		MetadataModel:          "primary",
+		FallbackMetadataModels: []string{"secondary"},
+		HTTPClient:             server.Client(),
+		Log:                    discardLogger(),
 	})
 
 	input := "Personal profile - Hein (Warkanum):\n- Born: 23 May 1989\n- Wife: Cindy, born 16 November 1994"
@@ -341,3 +341,66 @@ func TestExtractMetadataRetriesEmptyResponse(t *testing.T) {
 		t.Fatalf("metadata type = %q, want observation", metadata.Type)
 	}
 }
+
+func TestExtractMetadataBypassesModelAfterRepeatedEmptyResponses(t *testing.T) {
+	var primaryCalls atomic.Int32
+	var fallbackCalls atomic.Int32
+
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		var req chatCompletionsRequest
+		_ = json.NewDecoder(r.Body).Decode(&req)
+
+		switch req.Model {
+		case "primary":
+			primaryCalls.Add(1)
+			_ = json.NewEncoder(w).Encode(map[string]any{
+				"choices": []map[string]any{
+					{"message": map[string]any{"content": ""}},
+				},
+			})
+		case "fallback":
+			fallbackCalls.Add(1)
+			_ = json.NewEncoder(w).Encode(map[string]any{
+				"choices": []map[string]any{
+					{"message": map[string]any{"content": "{\"people\":[],\"action_items\":[],\"dates_mentioned\":[],\"topics\":[\"mcp\"],\"type\":\"observation\",\"source\":\"mcp\"}"}},
+				},
+			})
+		default:
+			t.Fatalf("unexpected model %q", req.Model)
+		}
+	}))
+	defer server.Close()
+
+	client := New(Config{
+		Name:                   "test",
+		BaseURL:                server.URL,
+		APIKey:                 "secret",
+		MetadataModel:          "primary",
+		FallbackMetadataModels: []string{"fallback"},
+		HTTPClient:             server.Client(),
+		Log:                    discardLogger(),
+	})
+
+	// First three calls should probe primary and then use fallback.
+	for i := 0; i < 3; i++ {
+		if _, err := client.ExtractMetadata(context.Background(), "hello"); err != nil {
+			t.Fatalf("ExtractMetadata() error = %v", err)
+		}
+	}
+
+	primaryBefore := primaryCalls.Load()
+	if primaryBefore == 0 {
+		t.Fatal("expected primary model to be called before bypass")
+	}
+
+	// Fourth call should bypass primary (no additional primary calls).
+	if _, err := client.ExtractMetadata(context.Background(), "hello"); err != nil {
+		t.Fatalf("ExtractMetadata() error = %v", err)
+	}
+	if primaryCalls.Load() != primaryBefore {
+		t.Fatalf("primary calls increased after bypass: before=%d after=%d", primaryBefore, primaryCalls.Load())
+	}
+	if fallbackCalls.Load() < 4 {
+		t.Fatalf("fallback calls = %d, want at least 4", fallbackCalls.Load())
+	}
+}