Cyrene_v2/internal/runtime/model/persona_router_test.go

package model

import (
	"testing"

	"git.yeij.top/AskaEth/Cyrene_v2/internal/config/runtimeconfig"
)

// TestRouter_RouteRequestForPersona pins 裁决 03.4.1: the "role" of per-role
// routing is the persona a turn answers as, and a persona without a binding keeps
// the message-role behavior.
func TestRouter_RouteRequestForPersona(t *testing.T) {
	t.Parallel()
	r := NewRouter("default",
		WithRoleModel(RoleUser, "user-model"),
		WithPersonaModel("cyrene", "persona-model"),
		WithPersonaProvider("cyrene", ProviderAnthropic),
		WithDefaultProvider(ProviderOpenAI),
	)
	req := Request{Messages: []Message{TextMessage(RoleUser, "hi")}}

	if got, _ := r.RouteRequestForPersona("cyrene", req); got != "persona-model" {
		t.Errorf("RouteRequestForPersona(cyrene) = %q, want persona-model", got)
	}
	if got, _ := r.RouteRequestForPersona("other", req); got != "user-model" {
		t.Errorf("RouteRequestForPersona(other) = %q, want user-model (role fallback)", got)
	}
	if got, _ := r.RouteRequestForPersona("", req); got != "user-model" {
		t.Errorf("RouteRequestForPersona(\"\") = %q, want user-model", got)
	}
	if got := r.RouteForPersona("cyrene"); got != "persona-model" {
		t.Errorf("RouteForPersona(cyrene) = %q, want persona-model", got)
	}
	if got := r.RouteProviderForPersona("cyrene"); got != ProviderAnthropic {
		t.Errorf("RouteProviderForPersona(cyrene) = %q, want anthropic", got)
	}
	if got := r.RouteProviderForPersona("other"); got != ProviderOpenAI {
		t.Errorf("RouteProviderForPersona(other) = %q, want the default provider openai", got)
	}
}

// TestRouter_PersonaBindingIgnoresBlankAndImageDoesNotSwitch pins two edges: a
// blank persona/model cannot create a binding, and a persona-routed image request
// is not silently re-routed to a vision model (that decision belongs to
// vision.Router, 裁决 14.4.1/14.4.5).
func TestRouter_PersonaBindingIgnoresBlankAndImageDoesNotSwitch(t *testing.T) {
	t.Parallel()
	r := NewRouter("default",
		WithPersonaModel("  ", "x"),
		WithPersonaModel("cyrene", ""),
		WithVisionModel("vision-model"),
	)
	if got := r.RouteForPersona("cyrene"); got != "default" {
		t.Errorf("RouteForPersona(cyrene) = %q, want default (no binding stored)", got)
	}
	img := Request{Messages: []Message{ImageMessage(RoleUser, "", "data:image/png;base64,abc")}}
	got, needsVision := r.RouteRequestForPersona("cyrene", img)
	if !needsVision {
		t.Error("needsVision = false, want true for an image-bearing request")
	}
	if got == "vision-model" {
		t.Errorf("RouteRequestForPersona = %q, want the persona/role model, not the vision model", got)
	}
}

// TestRuntimeLLM_PersonaRoutesFromModelsJSON pins the carrier: a per-persona
// binding written on the models.json group reaches the router through the hot
// snapshot, and a reload picks up a changed binding (裁决 03.4.1 载体 = models.json)。
func TestRuntimeLLM_PersonaRoutesFromModelsJSON(t *testing.T) {
	path := writeRTFile(t, []runtimeconfig.Group{{
		ID: "openai", Provider: ProviderOpenAI, BaseURL: "https://x", Model: "group-model",
		PersonaModels:    map[string]string{"cyrene": "persona-model"},
		PersonaProviders: map[string]string{"cyrene": ProviderAnthropic},
	}})
	m := NewRuntimeLLM(path, rtEnv(), nil)

	req := Request{Messages: []Message{TextMessage(RoleUser, "hi")}}
	got, _ := m.RouteRequestForPersona("cyrene", req)
	if got != "persona-model" {
		t.Fatalf("RouteRequestForPersona(cyrene) = %q, want persona-model", got)
	}
	if got, _ := m.RouteRequestForPersona("other", req); got != "group-model" {
		t.Fatalf("RouteRequestForPersona(other) = %q, want group-model", got)
	}

	if err := runtimeconfig.SaveModels(path, []runtimeconfig.Group{{
		ID: "openai", Provider: ProviderOpenAI, BaseURL: "https://x", Model: "group-model",
	}}); err != nil {
		t.Fatalf("SaveModels: %v", err)
	}
	if err := m.Reload(); err != nil {
		t.Fatalf("Reload: %v", err)
	}
	if got, _ := m.RouteRequestForPersona("cyrene", req); got != "group-model" {
		t.Fatalf("after reload RouteRequestForPersona(cyrene) = %q, want group-model (binding removed)", got)
	}
}

// TestRuntimeLLM_NoVisionPreemptionOnImage pins that the runtime snapshot no longer
// carries the env vision model: a configured LLM_VISION_MODEL must not switch an
// image-bearing request to another model, because image routing is owned by
// vision.Router (裁决 14.4.1/14.4.5).
func TestRuntimeLLM_NoVisionPreemptionOnImage(t *testing.T) {
	path := writeRTFile(t, []runtimeconfig.Group{{
		ID: "openai", Provider: ProviderOpenAI, BaseURL: "https://x", Model: "group-model",
	}})
	env := rtEnv()
	env.VisionModel = "vision-model"
	m := NewRuntimeLLM(path, env, nil)

	req := Request{Messages: []Message{ImageMessage(RoleUser, "", "data:image/png;base64,abc")}}
	got, needsVision := m.RouteRequest(req)
	if !needsVision {
		t.Error("needsVision = false, want true for an image-bearing request")
	}
	if got != "group-model" {
		t.Errorf("RouteRequest = %q, want group-model (no vision pre-emption)", got)
	}
}