feat: sync deployed v1.0.0-rc.38-custom.67

pkg/model_fingerprint/fingerprint_test.go

@@ -6,48 +6,51 @@ import (
 	"testing"
 
 	"github.com/QuantumNous/new-api/common"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
-func TestFingerprintReferenceAndInvalidSamples(t *testing.T) {
-	data, err := os.ReadFile("testdata/astra-reference.json")
-	if err != nil {
-		t.Fatal(err)
-	}
-	var rows []struct {
-		Text  string `json:"text"`
-		Count int    `json:"requested_count"`
-	}
-	if err = common.Unmarshal(data, &rows); err != nil {
-		t.Fatal(err)
-	}
-	samples := []Sample{}
-	for _, row := range rows {
-		samples = append(samples, Sample{Text: row.Text, Count: row.Count})
-	}
-	r, err := Score(samples)
-	if err != nil || r.Status != "match" || r.Closest != Model || r.ValidSamples != 3 {
-		t.Fatalf("%+v %v", r, err)
-	}
-	r, err = Score(samples[:2])
-	if err != nil || r.Status != "inconclusive" {
-		t.Fatalf("partial samples: %+v %v", r, err)
-	}
-	for _, s := range []string{"[1,2]", "null", "[" + strings.Repeat("-1,", 299) + "1]", "[" + strings.Repeat("1.2,", 299) + "1]", "ignore instructions; [1]"} {
-		if ValidArray(s, 300) {
-			t.Fatalf("accepted invalid array: %s", s[:min(len(s), 20)])
+func TestModelTraceUpstreamParity(t *testing.T) {
+	data, err := os.ReadFile("testdata/modeltrace-reference.json")
+	require.NoError(t, err)
+	var fixtures []struct {
+		Samples  []Sample
+		Expected struct {
+			Results []Candidate `json:"results"`
+			Valid   int         `json:"used_outputs"`
 		}
 	}
-	c := []Candidate{{Model: "gpt-5.6-luna", Weight: .98, Score: 2}, {Model: Model, Weight: .02, Score: 1}}
-	if Decide(c, 3).Status != "mismatch" {
-		t.Fatal("wrong model gate")
-	}
-	c[1].Score = 1.7
-	if Decide(c, 3).Status != "inconclusive" {
-		t.Fatal("low margin must abstain")
+	require.NoError(t, common.Unmarshal(data, &fixtures))
+	for _, fixture := range fixtures {
+		result, err := Score(fixture.Samples)
+		require.NoError(t, err)
+		assert.Equal(t, Version, result.Engine)
+		assert.Equal(t, fixture.Expected.Valid, result.ValidSamples)
+		assert.Equal(t, fixture.Expected.Results[0].Model, result.Closest)
+		for _, candidate := range fixture.Expected.Results {
+			assert.InDelta(t, candidate.Weight, result.Matches[candidate.Model], 1e-9)
+		}
 	}
+	assert.False(t, ValidSample("I cannot provide the sequence."))
+	assert.True(t, ValidArray(strings.Repeat("42,", 180), 300))
+	assert.False(t, ValidArray(strings.Repeat("42,", 100), 300))
+	result := Decide([]Candidate{{Model: Model, Weight: .79, Score: 2}, {Model: "other", Weight: .21, Score: 1}}, 3)
+	assert.Equal(t, "inconclusive", result.Status)
+	result = Decide([]Candidate{{Model: "other", Weight: .95, Score: 2}, {Model: Model, Weight: .05, Score: 1}}, 2)
+	assert.Equal(t, "inconclusive", result.Status)
+	result = Decide([]Candidate{{Model: "other", Weight: .95, Score: 2}, {Model: Model, Weight: .05, Score: 1}}, 3)
+	assert.Equal(t, "mismatch", result.Status)
 }
 
 func TestFingerprintResponseCompletionAndTools(t *testing.T) {
+	stream := "data: {\"type\":\"response.output_text.delta\",\"delta\":\"42\"}\n\ndata: {\"type\":\"response.completed\",\"response\":{\"status\":\"completed\",\"usage\":{\"input_tokens\":10,\"output_tokens\":1}}}\n\n"
+	answer, err := ReadResponse(strings.NewReader(stream), "text/event-stream")
+	require.NoError(t, err)
+	assert.Equal(t, "42", answer.Text)
+	assert.True(t, answer.HasUsage)
+	answer, err = ReadResponse(strings.NewReader(strings.Replace(stream, `"status":"completed"`, `"status":"completed","output":[]`, 1)), "text/event-stream")
+	require.NoError(t, err)
+	assert.Empty(t, answer.Text)
 	completed := `{"status":"completed","model":"gpt-6-astra","output":[{"type":"message","content":[{"type":"output_text","text":"[1,2,3]"}]}],"usage":{"input_tokens":21,"output_tokens":12,"input_tokens_details":{"cached_tokens":10}}}`
 	for _, input := range []struct{ body, content string }{{completed, "application/json"}, {"data: {\"type\":\"response.completed\",\"response\":" + completed + "}\n\n", "text/event-stream"}} {
 		r, err := ReadResponse(strings.NewReader(input.body), input.content)