tests: add 7 deepseek-v4-flash model validation tests

- HTTP-level: verify Flash sends no thinking field, correct model name in request
- Flash vs Pro contrast: side-by-side thinking field presence/absence
- Full config validation: all 5 defaults applied (Model, BaseURL, Thinking, Iterations, APIKey)
- Explicit thinking override: disabled/high stick even when profile DefaultThinking is empty
- Profile entry integrity: raw KnownProfiles entry — Prefix, Label, Timeout, MaxContext
- ProfileLabel for Flash exact + prefix-match variants

Regression gates: catch accidental DefaultThinking addition, context limit changes,
or model name mismatches.

Author: jkyberneees

internal/llm/client_test.go

@@ -653,3 +653,96 @@ func TestClient_SimpleCall_EmptyResponse(t *testing.T) {
 		t.Fatal("expected error for empty choices")
 	}
 }
+
+// ── DeepSeek v4 Flash Model Validation ────────────────────────────────
+
+// TestClient_Call_FlashModelNoThinkingField validates that when using
+// deepseek-v4-flash (which has no DefaultThinking), the request body
+// does NOT include a "thinking" field. Flash is faster/cheaper by
+// skipping extended reasoning — this test guards against accidentally
+// sending thinking config to Flash.
+func TestClient_Call_FlashModelNoThinkingField(t *testing.T) {
+	var receivedBody map[string]any
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		json.NewDecoder(r.Body).Decode(&receivedBody)
+		w.Header().Set("Content-Type", "application/json")
+		w.Write([]byte(`{"choices":[{"message":{"content":"flash response"}}]}`))
+	}))
+	defer server.Close()
+
+	// Flash: model=deepseek-v4-flash, thinking="" (the default)
+	c := New(server.URL, "sk-test", "deepseek-v4-flash", "", 0)
+	result, err := c.Call(context.Background(), []Message{{Role: "user", Content: "hi"}}, nil)
+	if err != nil {
+		t.Fatalf("Flash Call() error: %v", err)
+	}
+	if result.Content != "flash response" {
+		t.Errorf("Content = %q, want %q", result.Content, "flash response")
+	}
+
+	// Verify model name is correct in the request
+	model, ok := receivedBody["model"]
+	if !ok || model != "deepseek-v4-flash" {
+		t.Errorf("model = %v, want %q", model, "deepseek-v4-flash")
+	}
+
+	// Verify NO thinking field (Flash doesn't use extended thinking)
+	if _, ok := receivedBody["thinking"]; ok {
+		t.Error("Flash request should NOT contain 'thinking' field")
+	}
+	if _, ok := receivedBody["reasoning_effort"]; ok {
+		t.Error("Flash request should NOT contain 'reasoning_effort' field")
+	}
+}
+
+// TestClient_Call_FlashVsProThinkingContrast validates that Flash and Pro
+// models are handled differently at the HTTP level:
+//   - Flash: no thinking field (faster, cheaper)
+//   - Pro:   thinking{type:"enabled"} by default (full reasoning)
+func TestClient_Call_FlashVsProThinkingContrast(t *testing.T) {
+	t.Run("flash_no_thinking", func(t *testing.T) {
+		var body map[string]any
+		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			json.NewDecoder(r.Body).Decode(&body)
+			w.Header().Set("Content-Type", "application/json")
+			w.Write([]byte(`{"choices":[{"message":{"content":"ok"}}]}`))
+		}))
+		defer server.Close()
+
+		c := New(server.URL, "sk-test", "deepseek-v4-flash", "", 0)
+		_, err := c.Call(context.Background(), []Message{{Role: "user", Content: "hi"}}, nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, ok := body["thinking"]; ok {
+			t.Error("Flash: thinking field should be absent")
+		}
+	})
+
+	t.Run("pro_thinking_enabled", func(t *testing.T) {
+		var body map[string]any
+		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			json.NewDecoder(r.Body).Decode(&body)
+			w.Header().Set("Content-Type", "application/json")
+			w.Write([]byte(`{"choices":[{"message":{"content":"ok"}}]}`))
+		}))
+		defer server.Close()
+
+		c := New(server.URL, "sk-test", "deepseek-v4-pro", "enabled", 0)
+		_, err := c.Call(context.Background(), []Message{{Role: "user", Content: "hi"}}, nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		thinking, ok := body["thinking"]
+		if !ok {
+			t.Fatal("Pro: thinking field should be present")
+		}
+		thinkingMap, ok := thinking.(map[string]any)
+		if !ok {
+			t.Fatal("Pro: thinking should be an object")
+		}
+		if thinkingMap["type"] != "enabled" {
+			t.Errorf("Pro: thinking.type = %v, want 'enabled'", thinkingMap["type"])
+		}
+	})
+}

kode_test.go

@@ -531,6 +531,136 @@ func TestProfileMaxContext_Unknown(t *testing.T) {
 	}
 }
 
+// ── DeepSeek v4 Flash Full-Config Validation ──────────────────────────
+
+// TestNew_FlashModelFullConfig validates every default applied when
+// creating an agent with model="deepseek-v4-flash". This is the
+// end-to-end gate for Flash model correctness.
+func TestNew_FlashModelFullConfig(t *testing.T) {
+	cfg := Config{
+		APIKey: "sk-test",
+		Model:  "deepseek-v4-flash",
+	}
+	agent, err := New(cfg)
+	if err != nil {
+		t.Fatalf("New() with Flash model: %v", err)
+	}
+
+	// Flash profile fields
+	if agent.config.Model != "deepseek-v4-flash" {
+		t.Errorf("Model = %q, want %q", agent.config.Model, "deepseek-v4-flash")
+	}
+	if agent.config.BaseURL != "https://api.deepseek.com/v1" {
+		t.Errorf("BaseURL = %q, want %q", agent.config.BaseURL, "https://api.deepseek.com/v1")
+	}
+	if agent.config.Thinking != "" {
+		t.Errorf("Thinking = %q, want empty (Flash has no DefaultThinking)", agent.config.Thinking)
+	}
+	if agent.config.MaxIterations != 90 {
+		t.Errorf("MaxIterations = %d, want 90", agent.config.MaxIterations)
+	}
+	if agent.config.APIKey != "sk-test" {
+		t.Errorf("APIKey = %q, want %q", agent.config.APIKey, "sk-test")
+	}
+}
+
+// TestNew_FlashExplicitThinkingOverridesEmptyDefault validates that an
+// explicit Thinking setting wins even when the model's DefaultThinking
+// is empty (Flash has no default, so explicit values should stick).
+func TestNew_FlashExplicitThinkingOverridesEmptyDefault(t *testing.T) {
+	t.Run("explicit_disabled", func(t *testing.T) {
+		cfg := Config{
+			APIKey:   "sk-test",
+			Model:    "deepseek-v4-flash",
+			Thinking: "disabled",
+		}
+		agent, err := New(cfg)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if agent.config.Thinking != "disabled" {
+			t.Errorf("Thinking = %q, want 'disabled' (explicit)", agent.config.Thinking)
+		}
+	})
+
+	t.Run("explicit_high_reasoning", func(t *testing.T) {
+		cfg := Config{
+			APIKey:   "sk-test",
+			Model:    "deepseek-v4-flash",
+			Thinking: "high",
+		}
+		agent, err := New(cfg)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if agent.config.Thinking != "high" {
+			t.Errorf("Thinking = %q, want 'high' (explicit)", agent.config.Thinking)
+		}
+	})
+}
+
+// TestProfileTimeout_FlashApplied verifies the Flash profile timeout
+// (90s) is applied when creating an agent. Unlike Pro's 180s timeout,
+// Flash is faster and should use a shorter timeout.
+func TestProfileTimeout_FlashApplied(t *testing.T) {
+	cfg := Config{
+		APIKey: "sk-test",
+		Model:  "deepseek-v4-flash",
+	}
+	_, err := New(cfg)
+	if err != nil {
+		t.Fatalf("New() with Flash model should succeed: %v", err)
+	}
+	// Timeout is passed to the HTTP client internally; the key assertion
+	// is that the agent is created successfully with the Flash profile.
+}
+
+// TestKnownProfiles_FlashEntryIntegrity validates that the
+// deepseek-v4-flash entry in KnownProfiles has correct values
+// for every field.
+func TestKnownProfiles_FlashEntryIntegrity(t *testing.T) {
+	var flashEntry *struct {
+		Prefix  string
+		Profile ModelProfile
+	}
+	for _, entry := range KnownProfiles {
+		if entry.Prefix == "deepseek-v4-flash" {
+			flashEntry = &entry
+			break
+		}
+	}
+	if flashEntry == nil {
+		t.Fatal("deepseek-v4-flash entry not found in KnownProfiles")
+	}
+
+	if flashEntry.Prefix != "deepseek-v4-flash" {
+		t.Errorf("Prefix = %q, want %q", flashEntry.Prefix, "deepseek-v4-flash")
+	}
+	if flashEntry.Profile.Label != "DeepSeek v4 Flash" {
+		t.Errorf("Label = %q, want %q", flashEntry.Profile.Label, "DeepSeek v4 Flash")
+	}
+	if flashEntry.Profile.DefaultThinking != "" {
+		t.Errorf("DefaultThinking = %q, want empty (Flash is faster without extended thinking)", flashEntry.Profile.DefaultThinking)
+	}
+	if flashEntry.Profile.Timeout != 90 {
+		t.Errorf("Timeout = %d, want 90", flashEntry.Profile.Timeout)
+	}
+	if flashEntry.Profile.MaxContext != 131_072 {
+		t.Errorf("MaxContext = %d, want 131_072", flashEntry.Profile.MaxContext)
+	}
+}
+
+// TestProfileLabel_Flash returns the human-readable label for Flash.
+func TestProfileLabel_Flash(t *testing.T) {
+	if label := ProfileLabel("deepseek-v4-flash"); label != "DeepSeek v4 Flash" {
+		t.Errorf("ProfileLabel = %q, want %q", label, "DeepSeek v4 Flash")
+	}
+	// Prefix match: deepseek-v4-flash-custom should also match
+	if label := ProfileLabel("deepseek-v4-flash-experimental"); label != "DeepSeek v4 Flash" {
+		t.Errorf("ProfileLabel for variant = %q, want %q", label, "DeepSeek v4 Flash")
+	}
+}
+
 
 // ── Project File (AGENTS.md) Tests ───────────────────────────────────