//go:build ignore // probe169 是 issue #169 的真机测量工具:一条命令给出「安全吗 / 有效吗」两个结论。 // // 2026-10-21 实测结果(官方 5.8.3 客户端通道,CN 域,deepseek-v4.1-flash): // - 安全:带 conversation_id 三发全 200,不被渠道校验拒; // - 有效:**无效**。固定 id 与不带 id 的第二发命中率完全一致(90.9% vs 90.9%), // 说明上游前缀缓存按内容共享,与本字段无关;hy4-preview / glm-5.3 两臂都是 0%, // 是真不返回缓存命中,不是缺这个字段。 // 所以仓库里不再提供「回写 conversation_id」的开关(2026-10-21 已删除), // 本工具保留为测量/复验手段。 // // 背景:上游按 body 的 conversation_id 分前缀缓存槽(上报人的单变量 2×2), // 但官方桌面客户端只发 X-Conversation-* 头、body 里没有该字段(96MB app.asar // 全包检索零命中)。本工具就是对上面这条假设做判决。 // // 阶段 A(安全):带上该字段会不会被渠道校验拒(11-128 / 11140 这类 body 形态拒绝); // 阶段 B(有效):同一段长前缀,固定 conversation_id 重放是否真的整段命中。 // // 用法(仓库根目录,auth 目录两种格式都认): // // go run internal/probe/probe169.go -auths ./auths -realm cn // go run internal/probe/probe169.go -tokfile /path/token.txt -realm cn -uid // // 只打印状态码与 usage 缓存字段,**不打印任何 token**。 package main import ( "context" "encoding/json" "flag" "fmt" "io" "os" "path/filepath" "strings" "time" "github.com/misakano7545/workbuddy2api-panel/internal/auth" "github.com/misakano7545/workbuddy2api-panel/internal/upstream" ) // sample 是单次请求观测到的用量与缓存字段。 type sample struct { status int err string ttfb time.Duration prompt int64 hit int64 miss int64 cached int64 raw string } func (s sample) hitRate() float64 { if s.prompt <= 0 { return 0 } return float64(s.hit) * 100 / float64(s.prompt) } func (s sample) String() string { if s.err != "" { return fmt.Sprintf("status=%d ERR=%s", s.status, truncate(s.err, 120)) } return fmt.Sprintf("status=%d ttfb=%5dms prompt=%d hit=%d miss=%d cached=%d hit%%=%.1f", s.status, s.ttfb.Milliseconds(), s.prompt, s.hit, s.miss, s.cached, s.hitRate()) } func main() { authDir := flag.String("auths", "", "auth 文件目录") realm := flag.String("realm", "cn", "cn / global") model := flag.String("model", "", "模型 id(裸名;空 = 该域默认便宜模型)") tokFile := flag.String("tokfile", "", "token 文件(首行 access token,不回显)") uid := flag.String("uid", "probe169uid", "账号 uid(缓存键隔离段)") base := flag.String("base", "", "覆盖 chat base") phase := flag.String("phase", "all", "all / safe / cache") flag.Parse() a := pickAccount(*tokFile, *authDir, *realm, *uid) if a == nil { fmt.Printf("FAIL: 没有可用的 realm=%s 账号(-auths 或 -tokfile)\n", *realm) os.Exit(1) } uidShow := a.UID if len(uidShow) > 8 { uidShow = uidShow[:8] } fmt.Printf("account: uid=%s realm=%s\n", uidShow, a.Realm()) c := upstream.New() if *base != "" { if a.IsGlobal() { c.ChatBaseGlobal = *base } else { c.ChatBaseCN = *base } } m := *model if m == "" { if a.IsGlobal() { m = "gpt-5.4" } else { m = "deepseek-v4.1-flash" } } fmt.Printf("model=%s base=%s/%s\n\n", m, c.ChatBaseCN, c.ChatBaseGlobal) safeOK := true if *phase == "all" || *phase == "safe" { safeOK = runPhaseA(c, a, m) } if *phase == "all" || *phase == "cache" { runPhaseB(c, a, m) } if !safeOK { os.Exit(1) // 安全没过:退出码非 0,便于脚本判断 } } // pickAccount 从 token 文件或 auth 目录取一个账号(不回显凭证)。 func pickAccount(tokFile, authDir, realm, uid string) *auth.Auth { if tokFile != "" { raw, err := os.ReadFile(tokFile) if err != nil { fmt.Println("read tokfile:", err) return nil } tok := strings.TrimSpace(strings.SplitN(string(raw), "\n", 2)[0]) a := &auth.Auth{AccessToken: tok, UID: uid, ExpiresAt: time.Now().Add(time.Hour).Unix()} _, _ = auth.BackfillRealmFor(a, realm) return a } entries, err := os.ReadDir(authDir) if err != nil { fmt.Println("read auths:", err) return nil } for _, e := range entries { if e.IsDir() || !strings.HasSuffix(e.Name(), ".json") { continue } raw, err := os.ReadFile(filepath.Join(authDir, e.Name())) if err != nil { continue } a := parseLoose(raw) if a == nil { continue } if a.IsGlobal() != (realm == "global") { continue } if a.ExpiresAt > 0 && time.Now().Unix() > a.ExpiresAt { continue } return a } return nil } // parseLoose 兼容两种 auth 文件格式(本仓嵌套/扁平形 + 其它面板导出的 token/user_id 形)。 func parseLoose(raw []byte) *auth.Auth { if a, err := auth.Parse(raw); err == nil && a != nil && a.AccessToken != "" { return a } var m map[string]any if json.Unmarshal(raw, &m) != nil { return nil } str := func(keys ...string) string { for _, k := range keys { if v, ok := m[k].(string); ok && v != "" { return v } } return "" } tok := str("accessToken", "token", "access_token") if tok == "" { return nil } exp := int64(0) for _, k := range []string{"expiresAt", "expires_at"} { if v, ok := m[k].(float64); ok && v > 0 { exp = int64(v) break } } if exp > 1e12 { exp /= 1000 } a := &auth.Auth{AccessToken: tok, UID: str("uid", "user_id", "userId"), ExpiresAt: exp, Nickname: str("nickname")} switch str("realm") { case "intl", "global", "international": _, _ = auth.BackfillRealmFor(a, "global") default: _, _ = auth.BackfillRealmFor(a, "cn") } return a } // runPhaseA 安全组:同一短请求三发(带固定 id / 不带 / 带随机 id),都必须 200。 func runPhaseA(c *upstream.Client, a *auth.Auth, model string) bool { msgs := `[{"role":"system","content":"You are a helpful assistant."},{"role":"user","content":"回复一个字:好"}]` fmt.Println("=== 阶段 A:安全(带 conversation_id 会不会被拒)===") cases := []struct { label string conv string }{ {"A1 带固定 conversation_id", fixedConv()}, {"A2 不带 conversation_id", ""}, {"A3 带随机 conversation_id", "probe169-" + nonce()}, } ok := true for i, cs := range cases { if i > 0 { time.Sleep(1200 * time.Millisecond) } s := send(c, a, model, msgs, cs.conv) fmt.Printf(" %-26s %s\n", cs.label, s) if s.status != 200 || s.err != "" { ok = false if s.raw != "" { fmt.Printf(" %-26s raw=%s\n", "", truncate(s.raw, 240)) } } } if ok { fmt.Println(" → 结论 A:安全。三发全 200,渠道校验不介意 body 的 conversation_id。") } else { fmt.Println(" → 结论 A:不安全(或凭证/模型本身有问题)。") fmt.Println(" 若失败的正是 A1/A3、而 A2 通过 → 上游在拒这个字段,开关必须保持关闭。") } fmt.Println() return ok } // runPhaseB 缓存组:3k token 同前缀 × 2 轮对照(固定 id vs 不带)。 func runPhaseB(c *upstream.Client, a *auth.Auth, model string) { fmt.Println("=== 阶段 B:有效(固定 conversation_id 能否整段命中)===") msgs := longMessages() conv := fixedConv() b1 := send(c, a, model, msgs, conv) fmt.Printf(" %-26s %s\n", "B1-a 固定 id 第 1 次", b1) time.Sleep(1500 * time.Millisecond) b2 := send(c, a, model, msgs, conv) fmt.Printf(" %-26s %s\n", "B1-b 固定 id 第 2 次", b2) time.Sleep(1500 * time.Millisecond) b3 := send(c, a, model, msgs, "") fmt.Printf(" %-26s %s\n", "B2-a 不带 id 第 1 次", b3) time.Sleep(1500 * time.Millisecond) b4 := send(c, a, model, msgs, "") fmt.Printf(" %-26s %s\n", "B2-b 不带 id 第 2 次", b4) withID := b2.hitRate() withoutID := b4.hitRate() fmt.Printf("\n 固定 id 复用命中率 = %.1f%%(B1-b)|不带 id 命中率 = %.1f%%(B2-b)\n", withID, withoutID) switch { case b2.status != 200 || b4.status != 200: fmt.Println(" → 结论 B:无法判定(有请求失败,先看上面的 raw)。") case withoutID >= 50 && withID >= 50: fmt.Println(" → 结论 B:两种形态都命中 → 上游按内容前缀共享缓存,与本字段无关(本仓已不提供该开关)。") case withID-withoutID >= 20: fmt.Println(" → 结论 B:该模型上固定 conversation_id 明显提升命中率 —— 与 2026-10-21 的结论不同,") fmt.Println(" 值得再查(把本次原始输出贴到 issue #169)。") case withID > withoutID: fmt.Println(" → 结论 B:有提升但幅度小(<20pp)。建议换多个模型各跑一遍再看。") default: fmt.Println(" → 结论 B:无效,与 2026-10-21 结论一致(命中率无差别或都为 0)。") } fmt.Println() } // send 发一次真实 chat 请求并解析 usage 缓存字段。 func send(c *upstream.Client, a *auth.Auth, model, messagesJSON, convID string) sample { body := fmt.Sprintf(`{"model":%q,"stream":true,"messages":%s}`, model, messagesJSON) if convID != "" { var obj map[string]any if json.Unmarshal([]byte(body), &obj) == nil { obj["conversation_id"] = convID if nb, err := json.Marshal(obj); err == nil { body = string(nb) } } } meta := upstream.ChatMeta{ConversationRequestID: "probe169-" + nonce()} ctx, cancel := context.WithTimeout(context.Background(), 180*time.Second) defer cancel() start := time.Now() rc, status, respBody, err := c.ChatStreamContext(ctx, a, []byte(body), "", meta, nil) s := sample{status: status, ttfb: time.Since(start)} if err != nil { s.err = err.Error() s.raw = string(respBody) return s } raw, _ := io.ReadAll(rc) rc.Close() parseUsage(string(raw), &s) if status != 200 { s.raw = string(raw) } return s } // parseUsage 从 SSE 里取末帧 usage 的缓存字段。 func parseUsage(text string, s *sample) { for _, line := range strings.Split(text, "\n") { line = strings.TrimSpace(line) if !strings.HasPrefix(line, "data:") { continue } payload := strings.TrimSpace(strings.TrimPrefix(line, "data:")) if payload == "" || payload == "[DONE]" { continue } var obj map[string]any if json.Unmarshal([]byte(payload), &obj) != nil { continue } us, ok := obj["usage"].(map[string]any) if !ok { continue } s.prompt = num(us["prompt_tokens"]) if v, ok := us["prompt_cache_hit_tokens"]; ok { s.hit = num(v) } if v, ok := us["prompt_cache_miss_tokens"]; ok { s.miss = num(v) } if v, ok := us["cached_tokens"]; ok { s.cached = num(v) } if d, ok := us["prompt_tokens_details"].(map[string]any); ok { if v, ok := d["cached_tokens"]; ok { s.cached = num(v) } } } } // longMessages 造 ≈3k token 的稳定长前缀(同会话两次请求逐字节相同)。 func longMessages() string { var b strings.Builder for i := 0; i < 120; i++ { fmt.Fprintf(&b, "%03d cache-slot probe material: replay an identical long prefix so upstream can hit.\n", i) } msgs := []any{ map[string]any{"role": "system", "content": "You are a helpful assistant."}, map[string]any{"role": "user", "content": b.String() + "\n\n只回复一个字:好"}, } out, _ := json.Marshal(msgs) return string(out) } func fixedConv() string { return "probe169-fixed-conversation" } func nonce() string { return fmt.Sprintf("%016x", time.Now().UnixNano()) } func num(v any) int64 { switch t := v.(type) { case float64: return int64(t) case json.Number: n, _ := t.Int64() return n } return 0 } func truncate(s string, n int) string { s = strings.ReplaceAll(strings.ReplaceAll(s, "\n", " "), "\r", "") if len(s) <= n { return s } return s[:n] + "…" }