M4 收口:神识用户面与计量闭环——BYOK/配额三段式/usage 落库/Anthropic+Gemini 适配器/神识阁

- 神识 Go:store 双实现(PG 自动建表+60s 就绪重试 / 内存回退)承载 usage_logs·byok_keys·quota_balances;BYOK 密钥库(AES-GCM 加密、API 脱敏、撤回即失效、主密钥未配置 fail-closed);配额三段式(预扣 max_tokens 钳位 1M→结算实际 token→全败幂等退款,HJ-2004);计量归属(IR user_id→usage_logs,/me/usage 用户维度聚合+配额总览,/admin/usage/sample 对账抽样);Anthropic/Gemini 出站适配器(SSE 解析、system 提升、用量映射);stub 端点补名修复计量空 endpoint
- IR 契约:user_id/byok_key_id 双端同步(Go types.go + Py types.py)
- 灵台:runs.owner_id(迁移 005,server_default 兼容存量)经 kernel 全链透传为 IR user_id;shenshi_client 扩展用户面方法(X-Hunjing-User-Id 代理,Echo 桩带内存实现);/me/byok-keys 登记·列表·撤回与 /me/usage 端点(4 用例)
- 前端神识阁(/models 重建):偏好(生成参数表单)/自带密钥(登记加密保存、脱敏列表、撤回二次确认)/用量(聚合表+配额进度条)三区;me API 库+mock+5 用例;侧栏恢复入口
- 配置与部署:.env.example 增 SHENSHI_DATABASE_URL/SHENSHI_BYOK_MASTER_KEY/SHENSHI_USER_BUDGET_TOKENS;compose 神识容器接自有库(init-shenshi.sql 预建 hunjing_shenshi,与灵台不共库共表)
- 证据:Go 34 用例(BYOK 独占/配额拒绝/结算退款/归属聚合)、后端 532、前端 210、BFF 4 全绿;跨进程 E2E 四场景(灵台 HttpShenshiClient→真 Go 神识:登记脱敏/BYOK 独占不可达整体失败/用量归属聚合/撤回即失效)通过;rewrite-plan M4 标记完成、能力矩阵神识行升已验证
This commit is contained in:
chenxin committed 2026-08-27 18:39:17 +08:00
1 parent 462d570751
commit 144415247e
51 files changed
+3533 -90

No files matched your search

+195
View File
@@ -0,0 +1,195 @@
// BYOK / 配额三段式 / 用量归属的服务级场景测试。
package server
import (
"bufio"
"encoding/hex"
"encoding/json"
"net/http"
"net/http/httptest"
"strings"
"testing"
"time"
"hunjing/shenshi/internal/byok"
"hunjing/shenshi/internal/quota"
"hunjing/shenshi/internal/route"
"hunjing/shenshi/internal/store"
)
func testMasterKey() string {
b := make([]byte, 32)
for i := range b {
b[i] = byte(i + 1)
}
return hex.EncodeToString(b)
}
// fullServer 装配 store/byok/quota 的完整服务;eps 为注册表候选(按优先级升序尝试)。
func fullServer(t *testing.T, budget int64, eps ...route.Endpoint) (*httptest.Server, store.Store, *byok.Vault) {
t.Helper()
st := store.NewMem()
vault, err := byok.NewVault(testMasterKey(), st)
if err != nil {
t.Fatal(err)
}
registry := registryWith(t, time.Second, eps...)
srv := New(Config{Store: st, Vault: vault, Quota: quota.New(st, budget)}, registry)
ts := httptest.NewServer(srv)
t.Cleanup(ts.Close)
return ts, st, vault
}
func postChat(ts *httptest.Server, body, userID string) (*http.Response, string) {
req, _ := http.NewRequest(http.MethodPost, ts.URL+"/v1/chat/completions", strings.NewReader(body))
req.Header.Set("content-type", "application/json")
if userID != "" {
req.Header.Set("X-Hunjing-User-Id", userID)
}
resp, err := ts.Client().Do(req)
if err != nil {
return nil, ""
}
var sb strings.Builder
scanner := bufio.NewScanner(resp.Body)
for scanner.Scan() {
sb.WriteString(scanner.Text())
sb.WriteString("\n")
}
return resp, sb.String()
}
func byokChatBody(run, extra string) string {
return `{"ir_version":1,"slot":"chat","messages":[{"role":"user","content":"hi"}],"run_id":"` + run + `"` + extra + `,"stream":true}`
}
// 场景:BYOK 独占路由——请求携带 byok_key_id 时只走用户端点,不回落平台候选。
func TestByokExclusiveRouting(t *testing.T) {
platform := fakeOpenAI(t, 0, 0, "平台端点")
defer platform.Close()
ts, _, vault := fullServer(t, 0, oaEndpoint("platform", platform.URL, 10))
byokUpstream := fakeOpenAI(t, 0, 0, "用户端点")
defer byokUpstream.Close()
key, err := vault.Register("u1", "自带", "openai_compatible", byokUpstream.URL, "sk-mine", "my-model")
if err != nil {
t.Fatal(err)
}
body := byokChatBody("run_byok", `,"user_id":"u1","byok_key_id":"`+key.ID+`"`)
resp, out := postChat(ts, body, "u1")
if resp == nil || resp.StatusCode != 200 {
t.Fatalf("BYOK 请求失败: %s", out)
}
if !strings.Contains(out, "用户端点") || strings.Contains(out, "平台端点") {
t.Fatalf("应独占 BYOK 端点: %s", out)
}
}
// 场景:BYOK 无效引用 → 整体失败,不回落平台端点。
func TestByokInvalidReferenceRejected(t *testing.T) {
platform := fakeOpenAI(t, 0, 0, "平台端点")
defer platform.Close()
ts, _, _ := fullServer(t, 0, oaEndpoint("platform", platform.URL, 10))
resp, out := postChat(ts, byokChatBody("run_bad", `,"user_id":"u1","byok_key_id":"byok_missing"`), "u1")
if resp == nil || resp.StatusCode != http.StatusServiceUnavailable {
t.Fatalf("应 503: %s", out)
}
if !strings.Contains(out, "HJ-2001") || strings.Contains(out, "平台端点") {
t.Fatalf("应整体失败而非回落: %s", out)
}
}
// 场景:配额不足 → HJ-2004 预拒,且不产生用量记录。
func TestQuotaRejectsWhenExhausted(t *testing.T) {
upstream := fakeOpenAI(t, 0, 0, "内容")
defer upstream.Close()
ts, st, _ := fullServer(t, 10, oaEndpoint("up", upstream.URL, 10))
resp, out := postChat(ts, byokChatBody("run_q", `,"user_id":"u1","max_tokens":100`), "u1")
if resp == nil || resp.StatusCode != http.StatusPaymentRequired {
t.Fatalf("配额不足应 402: %s", out)
}
if !strings.Contains(out, "HJ-2004") {
t.Fatalf("应携带 HJ-2004: %s", out)
}
sample, _ := st.SampleUsage(10)
if len(sample) != 0 {
t.Fatalf("预拒请求不应产生用量记录: %+v", sample)
}
}
// 场景:成功结算释放差值;全败全额退款——余额不残留。
func TestQuotaSettleAndRefundBalance(t *testing.T) {
upstream := fakeOpenAI(t, 0, 0, "内容")
bad := fakeOpenAI(t, 0, http.StatusForbidden, "")
defer upstream.Close()
defer bad.Close()
ts, st, _ := fullServer(t, 1000, oaEndpoint("up", upstream.URL, 10))
// 成功:预扣 max_tokens=200,实际 3+4=7
if resp, out := postChat(ts, byokChatBody("run_ok", `,"user_id":"u1","max_tokens":200`), "u1"); resp == nil || resp.StatusCode != 200 {
t.Fatalf("成功请求失败: %s", out)
}
b, _ := st.Balance("u1")
if b.Used != 7 || b.Reserved != 0 {
t.Fatalf("结算后账目错误: %+v", b)
}
// 已用 7,预算 1000:请求 max_tokens 994 应被拒(7+994 > 1000)
if resp, out := postChat(ts, byokChatBody("run_over", `,"user_id":"u1","max_tokens":994`), "u1"); resp == nil || resp.StatusCode != http.StatusPaymentRequired {
t.Fatalf("超预算应拒: %s", out)
}
// 全候选失败 → 全额退款
tsBad, stBad, _ := fullServer(t, 1000, oaEndpoint("bad", bad.URL, 10))
if resp, out := postChat(tsBad, byokChatBody("run_af", `,"user_id":"u2","max_tokens":500`), "u2"); resp == nil || resp.StatusCode != http.StatusServiceUnavailable {
t.Fatalf("全败应 503: %s", out)
}
b2, _ := stBad.Balance("u2")
if b2.Reserved != 0 || b2.Used != 0 {
t.Fatalf("全败后应全额退款: %+v", b2)
}
}
// 场景:用量归属计量——/me/usage 按用户过滤并附配额总览。
func TestUsageAttributionByUser(t *testing.T) {
upstream := fakeOpenAI(t, 0, 0, "内容")
defer upstream.Close()
ts, _, _ := fullServer(t, 0, oaEndpoint("up", upstream.URL, 10))
for _, b := range []string{
byokChatBody("run_u1", `,"user_id":"u1"`),
byokChatBody("run_u2", `,"user_id":"u2"`),
byokChatBody("run_u1b", `,"user_id":"u1"`),
} {
if resp, out := postChat(ts, b, ""); resp == nil || resp.StatusCode != 200 {
t.Fatalf("请求失败: %s", out)
}
}
req, _ := http.NewRequest(http.MethodGet, ts.URL+"/me/usage", nil)
req.Header.Set("X-Hunjing-User-Id", "u1")
resp, err := ts.Client().Do(req)
if err != nil {
t.Fatal(err)
}
var payload struct {
Rows []struct {
UserID string `json:"user_id"`
Requests int `json:"requests"`
} `json:"rows"`
Quota *struct {
Budget int64 `json:"budget"`
Used int64 `json:"used"`
} `json:"quota"`
}
_ = json.NewDecoder(resp.Body).Decode(&payload)
if len(payload.Rows) != 1 || payload.Rows[0].UserID != "u1" || payload.Rows[0].Requests != 2 {
t.Fatalf("u1 聚合错误: %+v", payload.Rows)
}
if payload.Quota == nil || payload.Quota.Used != 14 {
t.Fatalf("配额总览错误: %+v", payload.Quota)
}
}
+6 -4
View File
@@ -150,12 +150,14 @@ func TestUsageAggregate(t *testing.T) {
if err != nil {
t.Fatal(err)
}
var agg []map[string]any
var payload struct {
Rows []map[string]any `json:"rows"`
}
defer func() { _ = usageResp.Body.Close() }()
if err := json.NewDecoder(usageResp.Body).Decode(&agg); err != nil {
if err := json.NewDecoder(usageResp.Body).Decode(&payload); err != nil {
t.Fatal(err)
}
if len(agg) != 1 || agg[0]["ok"].(float64) != 1 || agg[0]["prompt_tokens"].(float64) != 3 {
t.Fatalf("聚合不符:%v", agg)
if len(payload.Rows) != 1 || payload.Rows[0]["ok"].(float64) != 1 || payload.Rows[0]["prompt_tokens"].(float64) != 3 {
t.Fatalf("聚合不符:%v", payload.Rows)
}
}
+199 -11
View File
@@ -1,25 +1,36 @@
// Package server 神识 HTTP 服务:数据面(IR 入站 → SSE 出站)、健康面与用量面。
// Package server 神识 HTTP 服务:数据面(IR 入站 → SSE 出站)、健康面、用量面与 BYOK 面。
//
// 故障切换红线:首帧到达前不提交 SSE 响应——失败可整体换道并返回 JSON 错误;
// 已写出字节后不再换道,如实以 error 终帧收尾(shenshi-gateway.md §4/§5)。
//
// 配额三段式:预扣(max_tokens 上限,钳位)→ 结算(实际 token)→ 退款(失败幂等)。
// BYOK:请求携带 byok_key_id 时独占候选(不回落平台端点,防止用户预期自带密钥却被平台计费)。
package server
import (
"context"
"encoding/json"
"errors"
"fmt"
"net/http"
"time"
"hunjing/shenshi/internal/byok"
"hunjing/shenshi/internal/ir"
"hunjing/shenshi/internal/metering"
"hunjing/shenshi/internal/quota"
"hunjing/shenshi/internal/relay"
"hunjing/shenshi/internal/route"
"hunjing/shenshi/internal/store"
"hunjing/shenshi/internal/transform"
)
// Config 服务配置。
type Config struct {
ServiceToken string
Store store.Store // nil 时计量退化为进程内环形
Vault *byok.Vault // nil 时 BYOK 面整体 503(fail-closed)
Quota *quota.Limiter
}
// Server 神识 HTTP 服务。
@@ -32,11 +43,19 @@ type Server struct {
// New 构建服务并注册路由。
func New(cfg Config, routes *route.Registry) *Server {
s := &Server{cfg: cfg, routes: routes, usage: metering.New(10_000), mux: http.NewServeMux()}
s := &Server{
cfg: cfg, routes: routes,
usage: metering.New(10_000, cfg.Store),
mux: http.NewServeMux(),
}
s.mux.HandleFunc("GET /healthz", s.handleHealth)
s.mux.HandleFunc("GET /readyz", s.handleHealth)
s.mux.Handle("POST /v1/chat/completions", s.auth(http.HandlerFunc(s.handleChat)))
s.mux.Handle("GET /me/usage", s.auth(http.HandlerFunc(s.handleUsage)))
s.mux.Handle("GET /admin/usage/sample", s.auth(http.HandlerFunc(s.handleUsageSample)))
s.mux.Handle("GET /me/byok-keys", s.auth(http.HandlerFunc(s.handleByokList)))
s.mux.Handle("POST /me/byok-keys", s.auth(http.HandlerFunc(s.handleByokRegister)))
s.mux.Handle("DELETE /me/byok-keys/{id}", s.auth(http.HandlerFunc(s.handleByokRevoke)))
return s
}
@@ -58,7 +77,10 @@ func (s *Server) auth(next http.Handler) http.Handler {
})
}
// handleChat 数据面:IR → 候选迭代(首字超时/冷却标记/粘性)→ SSE。
// defaultReserve 预扣默认上限(max_tokens 未指定时按 4K 输出预扣)。
const defaultReserve = 4096
// handleChat 数据面:配额预扣 → 候选迭代(首字超时/冷却标记/粘性/BYOK 独占)→ SSE → 结算/退款。
func (s *Server) handleChat(w http.ResponseWriter, r *http.Request) {
var req ir.ChatRequest
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
@@ -69,20 +91,37 @@ func (s *Server) handleChat(w http.ResponseWriter, r *http.Request) {
writeError(w, http.StatusBadRequest, "HJ-2002", err.Error())
return
}
candidates, err := s.routes.Candidates(req.Slot, req.RunID)
// 三段式之一:预扣(按输出上限;钳位集中在 quota 包)
reserveTokens := int64(defaultReserve)
if req.MaxTokens != nil {
reserveTokens = int64(*req.MaxTokens)
}
reserved, err := s.quotaReserve(req.UserID, reserveTokens)
if err != nil {
writeError(w, http.StatusPaymentRequired, "HJ-2004", err.Error())
return
}
candidates, err := s.candidates(&req)
if err != nil {
_ = s.quotaRefund(req.UserID, reserved)
writeError(w, http.StatusServiceUnavailable, "HJ-2001", err.Error())
return
}
var lastErr error
for _, endpoint := range candidates {
res := s.tryEndpoint(w, r, endpoint, &req)
for i, endpoint := range candidates {
res := s.tryEndpoint(w, r, endpoint, &req, i)
s.usage.Record(res.Attempt)
if res.Committed {
// 已向客户端写出:无论成败都不能再换道
if res.Status == "ok" {
s.routes.Sticky.Remember(req.RunID, endpoint.Name)
s.quotaSettle(req.UserID, reserved, res.Attempt.PromptTokens+res.Attempt.CompletionTokens)
} else {
// 流中失败:已发生的 token 照实结算,其余退款
s.quotaSettle(req.UserID, reserved, res.Attempt.PromptTokens+res.Attempt.CompletionTokens)
}
return
}
@@ -98,9 +137,55 @@ func (s *Server) handleChat(w http.ResponseWriter, r *http.Request) {
}
lastErr = res.Err
}
// 三段式之三:全部候选失败 → 全额退款
_ = s.quotaRefund(req.UserID, reserved)
writeError(w, http.StatusServiceUnavailable, "HJ-2001", "全部候选端点失败:"+errString(lastErr))
}
// candidates 候选序列:BYOK 独占(不回落平台端点);否则注册表候选。
func (s *Server) candidates(req *ir.ChatRequest) ([]route.Endpoint, error) {
if req.ByokKeyID == "" {
return s.routes.Candidates(req.Slot, req.RunID)
}
if s.cfg.Vault == nil {
return nil, fmt.Errorf("HJ-2003 BYOK 功能未启用(SHENSHI_BYOK_MASTER_KEY 未配置)")
}
key, plain, err := s.cfg.Vault.Resolve(req.UserID, req.ByokKeyID)
if err != nil {
return nil, err
}
spec := route.EndpointSpec{Type: key.Type, Name: "byok:" + key.ID, BaseURL: key.BaseURL, APIKey: plain, Model: key.Model}
adaptor, ok := route.BuildAdaptor(spec)
if !ok {
return nil, fmt.Errorf("HJ-2003 BYOK 密钥类型不受支持: %s", key.Type)
}
return []route.Endpoint{{
Name: spec.Name, Type: key.Type, Adaptor: adaptor,
Priority: -100, CredentialKey: spec.Name, UpstreamModel: key.Model,
}}, nil
}
func (s *Server) quotaReserve(userID string, tokens int64) (int64, error) {
if s.cfg.Quota == nil {
return 0, nil
}
return s.cfg.Quota.Reserve(userID, tokens)
}
func (s *Server) quotaSettle(userID string, reserved int64, actual int) error {
if s.cfg.Quota == nil {
return nil
}
return s.cfg.Quota.Settle(userID, reserved, int64(actual))
}
func (s *Server) quotaRefund(userID string, reserved int64) error {
if s.cfg.Quota == nil {
return nil
}
return s.cfg.Quota.Refund(userID, reserved)
}
type attempt struct {
metering.Attempt
Committed bool // 是否已向客户端写出 SSE
@@ -116,7 +201,7 @@ func errString(err error) string {
}
// tryEndpoint 单端点尝试。
func (s *Server) tryEndpoint(w http.ResponseWriter, r *http.Request, endpoint route.Endpoint, req *ir.ChatRequest) attempt {
func (s *Server) tryEndpoint(w http.ResponseWriter, r *http.Request, endpoint route.Endpoint, req *ir.ChatRequest, seq int) attempt {
start := time.Now()
ctx, cancel := context.WithTimeout(r.Context(), s.routes.FirstByteTimeout)
defer cancel()
@@ -129,7 +214,8 @@ func (s *Server) tryEndpoint(w http.ResponseWriter, r *http.Request, endpoint ro
}()
res := attempt{Attempt: metering.Attempt{
RunID: req.RunID, CharacterID: req.CharacterID,
ID: fmt.Sprintf("%s#%s#%d", req.RunID, endpoint.Name, seq),
RunID: req.RunID, CharacterID: req.CharacterID, UserID: req.UserID,
Model: req.Model, Slot: req.Slot, Endpoint: endpoint.Name,
}}
@@ -195,10 +281,112 @@ func failStatus(err error) string {
return "error"
}
// handleUsage 用量聚合(/me/usage;BYOK 归属维度随 M4b 接入)。
func (s *Server) handleUsage(w http.ResponseWriter, _ *http.Request) {
// meUser 从代理头取用户标识(灵台鉴权后注入,服务令牌即信任边界)。
func meUser(r *http.Request) string { return r.Header.Get("X-Hunjing-User-Id") }
// handleUsage 用户用量聚合(/me/usage;附配额余额)。
func (s *Server) handleUsage(w http.ResponseWriter, r *http.Request) {
userID := meUser(r)
rows, err := s.usage.Aggregate(userID)
if err != nil {
writeError(w, http.StatusInternalServerError, "HJ-2001", err.Error())
return
}
resp := map[string]any{"rows": rows}
if s.cfg.Quota != nil {
budget, used, reserved, err := s.cfg.Quota.Budget(userID)
if err == nil {
resp["quota"] = map[string]int64{"budget": budget, "used": used, "reserved": reserved}
}
}
w.Header().Set("Content-Type", "application/json")
_ = json.NewEncoder(w).Encode(s.usage.Aggregate())
_ = json.NewEncoder(w).Encode(resp)
}
// handleUsageSample 对账抽样(/admin/usage/sample?limit=N;最近 N 条原始记录)。
func (s *Server) handleUsageSample(w http.ResponseWriter, r *http.Request) {
limit := 50
if v := r.URL.Query().Get("limit"); v != "" {
if _, err := fmt.Sscanf(v, "%d", &limit); err != nil || limit <= 0 || limit > 1000 {
writeError(w, http.StatusBadRequest, "HJ-2002", "limit 须为 1..1000")
return
}
}
rows, err := s.usage.Sample(limit)
if err != nil {
writeError(w, http.StatusInternalServerError, "HJ-2001", err.Error())
return
}
w.Header().Set("Content-Type", "application/json")
_ = json.NewEncoder(w).Encode(map[string]any{"rows": rows})
}
func (s *Server) handleByokList(w http.ResponseWriter, r *http.Request) {
if s.cfg.Vault == nil {
writeError(w, http.StatusServiceUnavailable, "HJ-2003", "BYOK 功能未启用(SHENSHI_BYOK_MASTER_KEY 未配置)")
return
}
keys, err := s.cfg.Vault.List(meUser(r))
if err != nil {
writeError(w, http.StatusInternalServerError, "HJ-2001", err.Error())
return
}
w.Header().Set("Content-Type", "application/json")
_ = json.NewEncoder(w).Encode(map[string]any{"keys": keys})
}
type byokRegisterRequest struct {
Name string `json:"name"`
Type string `json:"type"` // openai_compatible / anthropic / gemini
BaseURL string `json:"base_url"`
APIKey string `json:"api_key"`
Model string `json:"model"`
}
func (s *Server) handleByokRegister(w http.ResponseWriter, r *http.Request) {
if s.cfg.Vault == nil {
writeError(w, http.StatusServiceUnavailable, "HJ-2003", "BYOK 功能未启用(SHENSHI_BYOK_MASTER_KEY 未配置)")
return
}
var body byokRegisterRequest
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
writeError(w, http.StatusBadRequest, "HJ-2002", "请求解析失败: "+err.Error())
return
}
switch body.Type {
case "openai_compatible", "anthropic", "gemini":
default:
writeError(w, http.StatusBadRequest, "HJ-2002", "type 须为 openai_compatible / anthropic / gemini")
return
}
if body.APIKey == "" || body.BaseURL == "" || body.Model == "" {
writeError(w, http.StatusBadRequest, "HJ-2002", "api_key / base_url / model 不能为空")
return
}
key, err := s.cfg.Vault.Register(meUser(r), body.Name, body.Type, body.BaseURL, body.APIKey, body.Model)
if err != nil {
writeError(w, http.StatusBadRequest, "HJ-2003", err.Error())
return
}
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusCreated)
_ = json.NewEncoder(w).Encode(key)
}
func (s *Server) handleByokRevoke(w http.ResponseWriter, r *http.Request) {
if s.cfg.Vault == nil {
writeError(w, http.StatusServiceUnavailable, "HJ-2003", "BYOK 功能未启用(SHENSHI_BYOK_MASTER_KEY 未配置)")
return
}
if err := s.cfg.Vault.Revoke(meUser(r), r.PathValue("id")); err != nil {
if errors.Is(err, store.ErrByokNotFound) {
writeError(w, http.StatusNotFound, "HJ-2003", err.Error())
return
}
writeError(w, http.StatusInternalServerError, "HJ-2001", err.Error())
return
}
w.WriteHeader(http.StatusNoContent)
}
// handleHealth 健康面。