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

Sync production source including routing, billing, Astra detection and public uptime. Update custom build instructions and license packaging.

pkg/model_fingerprint/LICENSE-ModelTrace.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 xqy2006
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pkg/model_fingerprint/LICENSE-gpt-model-check.txt

@@ -0,0 +1,24 @@
+MIT License
+
+Copyright (c) 2026 gpt-model-check contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+ModelTrace bank and scorer retain the license in assets/LICENSE-ModelTrace.txt.
+Native probe transport adaptations retain assets/LICENSE-is-gpt-nerfed.txt.

pkg/model_fingerprint/LICENSE-is-gpt-nerfed.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 is-gpt-nerfed contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pkg/model_fingerprint/fingerprint.go

@@ -0,0 +1,146 @@
+// Numerical fingerprint scorer adapted from Katao123/gpt-model-check (MIT),
+// commit 3d6716a0903cf061daea001d5d44ee410846634e. See the adjacent licenses.
+package model_fingerprint
+
+import (
+	_ "embed"
+	"errors"
+	"math"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/QuantumNous/new-api/common"
+	"github.com/grafana/sobek"
+)
+
+const Model = "gpt-6-astra"
+const Version = "modeltrace-20260905-gmc-3d6716a"
+
+//go:embed bank.json
+var bankJSON string
+
+//go:embed scorer.js
+var scorerJS string
+
+var compileOnce sync.Once
+var program *sobek.Program
+var compileErr error
+
+type Sample struct {
+	Text  string `json:"text"`
+	Count int    `json:"expected_count"`
+}
+
+type Candidate struct {
+	Model  string  `json:"model"`
+	Weight float64 `json:"probability"`
+	Score  float64 `json:"score"`
+}
+
+type Result struct {
+	Status       string  `json:"status"`
+	ValidSamples int     `json:"valid_samples"`
+	Closest      string  `json:"closest,omitempty"`
+	Weight       float64 `json:"relative_weight,omitempty"`
+	Gap          float64 `json:"score_gap,omitempty"`
+}
+
+func ValidArray(text string, count int) bool {
+	if len(text) > 16384 || count <= 0 {
+		return false
+	}
+	text = strings.TrimSpace(text)
+	if strings.HasPrefix(text, "```") && strings.HasSuffix(text, "```") {
+		if i := strings.IndexByte(text, '\n'); i >= 0 {
+			text = strings.TrimSpace(text[i+1 : len(text)-3])
+		}
+	}
+	var numbers []int
+	if common.Unmarshal([]byte(text), &numbers) != nil {
+		return false
+	}
+	if len(numbers) < max(80, int(math.Ceil(float64(count)*.55))) || len(numbers) > count*2 {
+		return false
+	}
+	for _, number := range numbers {
+		if number < 1 || number > 355 {
+			return false
+		}
+	}
+	return true
+}
+
+func Decide(candidates []Candidate, valid int) Result {
+	r := Result{Status: "inconclusive", ValidSamples: valid}
+	if len(candidates) < 2 {
+		return r
+	}
+	top := candidates[0]
+	r.Closest = top.Model
+	r.Weight = top.Weight
+	r.Gap = top.Score - candidates[1].Score
+	if valid != 3 || math.IsNaN(r.Gap) || math.IsInf(r.Gap, 0) || top.Weight < .8 || r.Gap < .5 {
+		return r
+	}
+	if top.Model == Model {
+		r.Status = "match"
+		return r
+	}
+	for _, candidate := range candidates {
+		if candidate.Model == Model && candidate.Weight <= .2 && top.Score-candidate.Score >= .5 {
+			r.Status = "mismatch"
+		}
+	}
+	return r
+}
+
+// Score runs only the embedded, pinned scorer. No filesystem, network or host
+// functions are exposed to the VM; upstream text is data, never JavaScript.
+func Score(samples []Sample) (Result, error) {
+	valid := make([]Sample, 0, 3)
+	for _, sample := range samples {
+		if ValidArray(sample.Text, sample.Count) {
+			valid = append(valid, sample)
+		}
+	}
+	if len(valid) == 0 {
+		return Result{Status: "inconclusive"}, nil
+	}
+	compileOnce.Do(func() {
+		program, compileErr = sobek.Compile("fingerprint", strings.ReplaceAll(scorerJS, "export ", ""), true)
+	})
+	if compileErr != nil {
+		return Result{}, compileErr
+	}
+	vm := sobek.New()
+	timer := time.AfterFunc(3*time.Second, func() { vm.Interrupt("fingerprint scoring timeout") })
+	defer timer.Stop()
+	if _, err := vm.RunProgram(program); err != nil {
+		return Result{}, err
+	}
+	if err := vm.Set("bankJSON", bankJSON); err != nil {
+		return Result{}, err
+	}
+	encoded, err := common.Marshal(valid)
+	if err != nil {
+		return Result{}, err
+	}
+	if err = vm.Set("samplesJSON", string(encoded)); err != nil {
+		return Result{}, err
+	}
+	value, err := vm.RunString("JSON.stringify(analyzeGlobalOutputs(JSON.parse(samplesJSON), JSON.parse(bankJSON)))")
+	if err != nil {
+		return Result{}, err
+	}
+	var analysis struct {
+		Results []Candidate `json:"results"`
+	}
+	if err = common.Unmarshal([]byte(value.String()), &analysis); err != nil {
+		return Result{}, err
+	}
+	if len(analysis.Results) < 2 {
+		return Result{}, errors.New("missing fingerprint candidates")
+	}
+	return Decide(analysis.Results, len(valid)), nil
+}

pkg/model_fingerprint/fingerprint_test.go

@@ -0,0 +1,68 @@
+package model_fingerprint
+
+import (
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/QuantumNous/new-api/common"
+)
+
+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)])
+		}
+	}
+	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")
+	}
+}
+
+func TestFingerprintResponseCompletionAndTools(t *testing.T) {
+	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)
+		if err != nil || r.Text != "[1,2,3]" || r.CachedTokens != 10 || !r.HasUsage {
+			t.Fatalf("%+v %v", r, err)
+		}
+	}
+	for _, body := range []string{
+		"data: {\"type\":\"response.output_text.delta\",\"delta\":\"[1,2,3]\"}\n\n",
+		"data: {\"type\":\"response.output_item.added\",\"item\":{\"type\":\"function_call\"}}\n\n",
+		strings.Replace(completed, "completed", "incomplete", 1),
+		strings.Replace(completed, "\"type\":\"message\"", "\"type\":\"function_call\"", 1),
+	} {
+		if _, err := ReadResponse(strings.NewReader(body), "application/json"); err == nil {
+			t.Fatal("accepted tool or incomplete sample")
+		}
+	}
+}

pkg/model_fingerprint/response.go

@@ -0,0 +1,124 @@
+package model_fingerprint
+
+import (
+	"bufio"
+	"errors"
+	"io"
+	"strings"
+
+	"github.com/tidwall/gjson"
+)
+
+var ErrInvalidSample = errors.New("invalid probe answer")
+var ErrIncomplete = errors.New("probe response incomplete")
+
+type ProbeResponse struct {
+	Text             string `json:"-"`
+	DeclaredModel    string `json:"declared_model,omitempty"`
+	InputTokens      int64  `json:"input_tokens"`
+	OutputTokens     int64  `json:"output_tokens"`
+	CachedTokens     int64  `json:"cached_tokens"`
+	CacheWriteTokens int64  `json:"cache_write_tokens"`
+	HasUsage         bool   `json:"has_usage"`
+}
+
+func completedResponse(response gjson.Result) (ProbeResponse, error) {
+	r := ProbeResponse{}
+	r.DeclaredModel = response.Get("model").String()
+	if len(r.DeclaredModel) > 128 {
+		r.DeclaredModel = ""
+	}
+	usage := response.Get("usage")
+	r.HasUsage = usage.Get("input_tokens").Type == gjson.Number && usage.Get("output_tokens").Type == gjson.Number
+	r.InputTokens = usage.Get("input_tokens").Int()
+	r.OutputTokens = usage.Get("output_tokens").Int()
+	r.CachedTokens = usage.Get("input_tokens_details.cached_tokens").Int()
+	r.CacheWriteTokens = max(usage.Get("input_tokens_details.cached_creation_tokens").Int(), usage.Get("input_tokens_details.cache_creation_tokens").Int())
+	if response.Get("status").String() != "completed" {
+		return r, ErrIncomplete
+	}
+	for _, item := range response.Get("output").Array() {
+		switch item.Get("type").String() {
+		case "reasoning":
+		case "message":
+			for _, content := range item.Get("content").Array() {
+				if content.Get("type").String() != "output_text" {
+					return r, ErrInvalidSample
+				}
+				r.Text += content.Get("text").String()
+				if len(r.Text) > 16384 {
+					return ProbeResponse{}, ErrInvalidSample
+				}
+			}
+		default:
+			return r, ErrInvalidSample
+		}
+	}
+	return r, nil
+}
+
+// Only a complete response is a sample. Partial deltas, tool calls and a
+// truncated stream cannot become a model verdict. Total bytes are bounded.
+func ReadResponse(reader io.Reader, contentType string) (ProbeResponse, error) {
+	limited := &io.LimitedReader{R: reader, N: 8 << 20}
+	buffered := bufio.NewReader(limited)
+	peek, _ := buffered.Peek(1)
+	if !strings.Contains(contentType, "text/event-stream") && len(peek) > 0 && peek[0] == '{' {
+		data, err := io.ReadAll(buffered)
+		if err != nil {
+			return ProbeResponse{}, err
+		}
+		if limited.N == 0 || !gjson.ValidBytes(data) {
+			return ProbeResponse{}, ErrInvalidSample
+		}
+		return completedResponse(gjson.ParseBytes(data))
+	}
+	scanner := bufio.NewScanner(buffered)
+	scanner.Buffer(make([]byte, 4096), 2<<20)
+	var data strings.Builder
+	for scanner.Scan() {
+		line := scanner.Text()
+		if strings.HasPrefix(line, "data:") {
+			if data.Len() > 0 {
+				data.WriteByte('\n')
+			}
+			data.WriteString(strings.TrimSpace(strings.TrimPrefix(line, "data:")))
+			if data.Len() > 2<<20 {
+				return ProbeResponse{}, ErrInvalidSample
+			}
+			continue
+		}
+		if line != "" || data.Len() == 0 {
+			continue
+		}
+		payload := data.String()
+		data.Reset()
+		if payload == "[DONE]" {
+			break
+		}
+		if !gjson.Valid(payload) {
+			return ProbeResponse{}, ErrInvalidSample
+		}
+		event := gjson.Parse(payload)
+		typ := event.Get("type").String()
+		if typ == "response.output_item.added" || typ == "response.output_item.done" {
+			itemType := event.Get("item.type").String()
+			if itemType != "message" && itemType != "reasoning" {
+				return ProbeResponse{}, ErrInvalidSample
+			}
+		}
+		if typ == "response.completed" {
+			return completedResponse(event.Get("response"))
+		}
+		if typ == "response.failed" || typ == "response.incomplete" {
+			return completedResponse(event.Get("response"))
+		}
+		if typ == "error" {
+			return ProbeResponse{}, ErrIncomplete
+		}
+	}
+	if err := scanner.Err(); err != nil {
+		return ProbeResponse{}, err
+	}
+	return ProbeResponse{}, ErrIncomplete
+}

pkg/model_fingerprint/scorer.js

@@ -0,0 +1,212 @@
+export const VALUE_MIN = 1;
+export const VALUE_MAX = 355;
+export const DIMENSION = VALUE_MAX - VALUE_MIN + 1;
+export const ALPHA = 0.5;
+export const ORDERED_BLOCK_WEIGHT = 0.25;
+
+export function parseNumbers(text) {
+  const runs = [];
+  let current = [];
+  let previousEnd = 0;
+  for (const match of String(text).matchAll(/\d+/g)) {
+    const separator = String(text).slice(previousEnd, match.index);
+    const value = Number(match[0]);
+    if (current.length && /\p{L}/u.test(separator)) {
+      runs.push(current);
+      current = [];
+    }
+    if (value >= VALUE_MIN && value <= VALUE_MAX) current.push(value);
+    previousEnd = match.index + match[0].length;
+  }
+  if (current.length) runs.push(current);
+  return runs.reduce((best, run) => run.length > best.length ? run : best, []);
+}
+
+export function countNumbers(numbers) {
+  const counts = Array(DIMENSION).fill(0);
+  numbers.forEach((number) => { counts[number - VALUE_MIN] += 1; });
+  return counts;
+}
+
+function mean(values) {
+  return values.reduce((total, value) => total + value, 0) / values.length;
+}
+
+function standardize(values) {
+  const center = mean(values);
+  const variance = mean(values.map((value) => (value - center) ** 2));
+  const scale = Math.max(Math.sqrt(variance), 1e-12);
+  return values.map((value) => (value - center) / scale);
+}
+
+function dot(left, right) {
+  let value = 0;
+  for (let index = 0; index < left.length; index += 1) value += left[index] * right[index];
+  return value;
+}
+
+function norm(values) {
+  return Math.sqrt(dot(values, values));
+}
+
+function normalized(values) {
+  const scale = Math.max(norm(values), 1e-12);
+  return values.map((value) => value / scale);
+}
+
+function subtractBasis(values, basis) {
+  const output = values.slice();
+  for (const vector of basis || []) {
+    const projection = dot(output, vector);
+    for (let index = 0; index < output.length; index += 1) output[index] -= projection * vector[index];
+  }
+  return output;
+}
+
+function hellingerFeature(counts) {
+  const total = counts.reduce((sum, value) => sum + value, 0) + ALPHA * DIMENSION;
+  return counts.map((value) => Math.sqrt((value + ALPHA) / total));
+}
+
+function splitIntoFour(values) {
+  const base = Math.floor(values.length / 4);
+  const remainder = values.length % 4;
+  const chunks = [];
+  let start = 0;
+  for (let index = 0; index < 4; index += 1) {
+    const size = base + (index < remainder ? 1 : 0);
+    chunks.push(values.slice(start, start + size));
+    start += size;
+  }
+  return chunks;
+}
+
+function orderedBlockFeature(numbers) {
+  const pieces = [];
+  for (const chunk of splitIntoFour(numbers)) {
+    const bins = Array(16).fill(0.5);
+    for (const value of chunk) {
+      const index = Math.min(15, Math.floor(((value - 1) / 355) * 16));
+      bins[index] += 1;
+    }
+    const total = bins.reduce((sum, value) => sum + value, 0);
+    pieces.push(...bins.map((value) => Math.sqrt(value / total)));
+  }
+  const lastDigits = Array(10).fill(0.5);
+  numbers.forEach((value) => { lastDigits[value % 10] += 1; });
+  const lastTotal = lastDigits.reduce((sum, value) => sum + value, 0);
+  pieces.push(...lastDigits.map((value) => Math.sqrt(value / lastTotal)));
+  return pieces;
+}
+
+function robustScoreCounts(counts, bank) {
+  const artifact = bank.robust.hellinger;
+  const feature = hellingerFeature(counts);
+  let projected = feature.map((value, index) => (value - artifact.feature_mean[index]) / artifact.feature_scale[index]);
+  projected = subtractBasis(projected, artifact.nuisance_basis);
+  projected = normalized(projected);
+  const scores = artifact.centroids.map((centroid) => dot(projected, centroid));
+  return standardize(scores);
+}
+
+function orderedBlockScores(numbers, bank) {
+  const artifact = bank.robust.ordered_blocks;
+  const feature = orderedBlockFeature(numbers);
+  const standardizedFeature = feature.map((value, index) => (value - artifact.feature_mean[index]) / artifact.feature_scale[index]);
+  const unit = normalized(standardizedFeature);
+  const environmentScores = artifact.environment_centroids.map(
+    (centroids) => centroids.map((centroid) => dot(unit, centroid)),
+  );
+  const template = standardize(artifact.centroids.map((_, modelIndex) => Math.max(
+    ...environmentScores.map((scores) => scores[modelIndex]),
+  )));
+  const projected = normalized(subtractBasis(standardizedFeature, artifact.nuisance_basis));
+  const nuisance = standardize(artifact.centroids.map((centroid) => dot(projected, centroid)));
+  return standardize(template.map((value, index) => 0.5 * value + 0.5 * nuisance[index]));
+}
+
+function robustScoreNumbers(numbers, bank) {
+  const marginal = robustScoreCounts(countNumbers(numbers), bank);
+  const artifact = bank.robust.ordered_blocks;
+  const weight = artifact ? Number(artifact.weight || 0) : 0;
+  if (!artifact || weight === 0) return marginal;
+  const ordered = orderedBlockScores(numbers, bank);
+  return marginal.map((value, index) => (1 - weight) * value + weight * ordered[index]);
+}
+
+function softmax(values) {
+  const maximum = Math.max(...values);
+  const weights = values.map((value) => Math.exp(value - maximum));
+  const total = weights.reduce((sum, value) => sum + value, 0);
+  return weights.map((value) => value / total);
+}
+
+function jsSimilarity(left, right) {
+  const leftTotal = left.reduce((sum, value) => sum + value, 0);
+  const rightTotal = right.reduce((sum, value) => sum + value, 0) + ALPHA * DIMENSION;
+  const p = left.map((value) => value / leftTotal);
+  const q = right.map((value) => (value + ALPHA) / rightTotal);
+  const midpoint = p.map((value, index) => (value + q[index]) / 2);
+  const divergence = (values) => values.reduce(
+    (total, value, index) => total + (value ? value * Math.log(value / midpoint[index]) : 0),
+    0,
+  );
+  const js = (divergence(p) + divergence(q)) / 2;
+  return 1 - Math.sqrt(js / Math.log(2));
+}
+
+export function analyzeGlobalOutputs(outputs, bank) {
+  const modelIds = bank.models.map((model) => model.id);
+  const valid = [];
+  const diagnostics = [];
+  outputs.forEach((item, index) => {
+    const expected = Number(item.expected_count || 0);
+    const numbers = parseNumbers(item.text || "");
+    const minimum = expected ? Math.max(80, Math.ceil(expected * 0.55)) : 80;
+    const accepted = numbers.length >= minimum;
+    diagnostics.push({ index, parsed_numbers: numbers.length, minimum_numbers: minimum, accepted });
+    if (accepted) valid.push({ numbers, counts: countNumbers(numbers), scores: robustScoreNumbers(numbers, bank) });
+  });
+  if (!valid.length) throw new Error("没有可用回答：请粘贴完整数字序列；拒答或严重截断的回答不会计入。");
+
+  const combinedScores = modelIds.map((_, modelIndex) => mean(valid.map((item) => item.scores[modelIndex])));
+  const calibrationKey = String(Math.min(valid.length, 3));
+  const beta = Number(bank.calibration[calibrationKey].beta);
+  const probabilities = softmax(combinedScores.map((value) => beta * value));
+  const pooledCounts = Array.from({ length: DIMENSION }, (_, index) => valid.reduce((sum, item) => sum + item.counts[index], 0));
+  const modelEntries = Object.fromEntries(bank.models.map((model) => [model.id, model]));
+  const familyOrder = [...new Set(bank.models.map((model) => model.family || "models"))];
+  const familyNames = Object.fromEntries(familyOrder.map((family) => [
+    family,
+    bank.models.find((model) => (model.family || "models") === family)?.family_name || family,
+  ]));
+  const results = modelIds.map((model, index) => ({
+    model,
+    display_name: modelEntries[model].display_name,
+    probability: probabilities[index],
+    profile_similarity: jsSimilarity(pooledCounts, modelEntries[model].counts),
+    score: combinedScores[index],
+    family: modelEntries[model].family || "models",
+    family_name: familyNames[modelEntries[model].family || "models"],
+  })).sort((left, right) => right.probability - left.probability);
+  const familyProbabilities = Object.fromEntries(familyOrder.map((family) => [
+    family,
+    results.filter((item) => item.family === family).reduce((sum, item) => sum + item.probability, 0),
+  ]));
+  results.forEach((item) => { item.conditional_probability = item.probability / familyProbabilities[item.family]; });
+  const winningFamily = familyOrder.reduce((best, family) => familyProbabilities[family] > familyProbabilities[best] ? family : best);
+  return {
+    prediction: results[0].model,
+    prediction_name: results[0].display_name,
+    probability: results[0].probability,
+    used_outputs: valid.length,
+    results,
+    diagnostics,
+    calibration: { queries: calibrationKey, beta, cv_accuracy: bank.calibration[calibrationKey].cv_accuracy },
+    family_prediction: winningFamily,
+    family_prediction_name: familyNames[winningFamily],
+    family_probability: familyProbabilities[winningFamily],
+    family_probabilities: familyOrder.map((family) => ({ family, display_name: familyNames[family], probability: familyProbabilities[family] })),
+    method: "统一全局稳健数字指纹",
+  };
+}

pkg/model_fingerprint/testdata/astra-reference.json

@@ -0,0 +1 @@
+[{"row_id": "gpt-6-astra__query-01", "parent_row_id": "gpt-6-astra__query-01", "bank_id": "gpt", "source": "gpt-6-astra", "model_id": "gpt-6-astra", "response_model": "gpt-6-astra", "exact_version": "gpt-6-astra", "condition_id": "environment-01", "nuisance_condition_id": "environment-01", "wrapper_id": "environment-01", "wrapper_transport": "clean", "challenge_id": "query-01", "task_index": 0, "requested_count": 218, "parsed_count": 218, "strict_threshold": 120, "strict_valid": true, "temperature": "provider_default", "config_id": "reference-collection", "provider": "codex", "prompt": "For each of 218 positions, make one separate first-instinct choice of an integer from 1 to 355 inclusive. The current language model must complete this directly without tools, Python, code execution, calculators, search, APIs, or external random generators. Choose every position separately. Do not count upward or downward, including 1, 2, 3, and do not use an arithmetic progression, repeating cycle, repeated block, or another rule-made pattern. Accidental repetitions are valid. Once an item is written, do not sort, reorder, deduplicate, replace, or repair the list. Return one compact JSON array containing the complete sequence and no explanation.", "base_prompt": "For each of 218 positions, make one separate first-instinct choice of an integer from 1 to 355 inclusive. The current language model must complete this directly without tools, Python, code execution, calculators, search, APIs, or external random generators. Choose every position separately. Do not count upward or downward, including 1, 2, 3, and do not use an arithmetic progression, repeating cycle, repeated block, or another rule-made pattern. Accidental repetitions are valid. Once an item is written, do not sort, reorder, deduplicate, replace, or repair the list. Return one compact JSON array containing the complete sequence and no explanation.", "system_prompt": "", "user_prefix": "", "text": "[247,83,319,146,28,204,337,112,59,271,164,352,91,223,17,308,135,76,289,192,43,258,121,334,68,215,301,154,9,237,178,325,54,109,283,196,31,342,87,261,143,22,310,185,73,229,348,116,294,48,203,157,331,95,266,12,181,316,64,240,127,354,39,218,172,298,81,251,106,323,56,189,274,14,139,345,207,93,232,167,305,46,119,287,211,34,253,176,329,72,224,151,8,313,98,269,184,51,341,130,291,66,235,159,322,24,198,277,113,350,85,243,161,37,302,124,280,19,216,146,333,61,194,256,102,317,44,170,288,79,226,355,138,11,264,187,314,97,205,53,275,149,326,32,118,238,69,296,163,221,90,347,179,26,250,132,309,57,201,284,114,339,74,228,155,4,273,193,320,41,245,107,299,182,63,212,351,129,16,267,158,306,88,234,47,328,174,101,286,209,35,252,141,315,77,197,343,120,260,58,231,168,292,21,136,304,94,219,65,336,183,242,7,278,153,324,108,202]", "error": null, "request_seconds": 45.789022299984936, "collected_at": "2026-09-05T02:04:49.454748+00:00"}, {"row_id": "gpt-6-astra__query-02", "parent_row_id": "gpt-6-astra__query-02", "bank_id": "gpt", "source": "gpt-6-astra", "model_id": "gpt-6-astra", "response_model": "gpt-6-astra", "exact_version": "gpt-6-astra", "condition_id": "environment-01", "nuisance_condition_id": "environment-01", "wrapper_id": "environment-01", "wrapper_transport": "clean", "challenge_id": "query-02", "task_index": 0, "requested_count": 233, "parsed_count": 233, "strict_threshold": 129, "strict_valid": true, "temperature": "provider_default", "config_id": "reference-collection", "provider": "codex", "prompt": "Provide exactly 233 whole-number choices between 1 and 355 inclusive, choosing each item separately as it comes to mind. The current language model must complete this directly without tools, Python, code execution, calculators, search, APIs, or external random generators. Choose every position separately. Do not count upward or downward, including 1, 2, 3, and do not use an arithmetic progression, repeating cycle, repeated block, or another rule-made pattern. Accidental repetitions are valid. Once an item is written, do not sort, reorder, deduplicate, replace, or repair the list. Return one compact JSON array containing the complete sequence and no explanation.", "base_prompt": "Provide exactly 233 whole-number choices between 1 and 355 inclusive, choosing each item separately as it comes to mind. The current language model must complete this directly without tools, Python, code execution, calculators, search, APIs, or external random generators. Choose every position separately. Do not count upward or downward, including 1, 2, 3, and do not use an arithmetic progression, repeating cycle, repeated block, or another rule-made pattern. Accidental repetitions are valid. Once an item is written, do not sort, reorder, deduplicate, replace, or repair the list. Return one compact JSON array containing the complete sequence and no explanation.", "system_prompt": "", "user_prefix": "", "text": "[287,43,196,321,78,154,9,242,113,335,62,219,174,28,303,141,87,264,350,106,183,51,298,127,14,231,92,316,1Line truncated