gcli2api / internal /jsonscan /jsonscan.go
a3216's picture
feat: 同步上游 320f5d4;扩展模型(多免费渠道/自定义映射/访问密钥/模型白名单)
e48a2d8
Raw History Blame Contribute Delete
11 kB
// Package jsonscan 从**原始 JSON 字节**里读取少数几个字段,不做整棵树的解析。
//
// 为什么需要它:网关每处理一个 chat 请求,会对同一个 body 做 4~6 次
// json.Unmarshal(会话键、首条 role、kimi 工具、body 归一化、会话字段注入),
// 而线上代理负载的 body 常在 100~500KB。整棵树解析要给每个字符串解转义、
// 建 map、分配几十万对象;其中大部分字段根本没人看。
//
// 本包遍历一次、只解出被问到的少数几个字符串,其余值按 JSON 语法跳过(零分配)。
// 语义与 encoding/json 一致:解出来的值走 json.Unmarshal 解转义;跳过只看语法。
// 任何解析不了的情况都返回 Ok=false,调用方**必须**回落到整树解析。
//
// 性能要点(都是实测踩出来的):
// - 不要为「查一个键」扫整个 body 多次——一次遍历收集所有想要的键;
// - 不要对跳过的字符串调用 json.Unmarshal(第一版的致命错误:600KB 历史消息里
// 几千个字符串各解一次,比整树解析还慢 4 倍);
// - 字符串边界用 bytes.IndexByte,只在疑似反斜杠时才回退逐字节。
package jsonscan
import (
"bytes"
"encoding/json"
"fmt"
"unicode/utf8"
)
// Query 描述要读的字段。
type Query struct {
// Top 顶层键(只取值是字符串的那些)。
Top []string
// Nested 顶层子对象键(例如 "metadata");与 NestedKeys 都非空时才生效。
Nested string
NestedKeys []string
}
// Result 读取结果。Ok=false 表示 body 不是本包能完整走完的 JSON 对象,
// 调用方应回落整树解析(此时其它字段的值不可信)。
type Result struct {
Top map[string]string
Nested map[string]string
Ok bool
}
// Get 取顶层键的值(未命中 / 非字符串 → "")。
func (r Result) Get(key string) string { return r.Top[key] }
// GetNested 取顶层子对象里的键值(未命中 / 非字符串 → "")。
func (r Result) GetNested(key string) string { return r.Nested[key] }
// Lookup 单遍遍历顶层对象,收集 Query 要求的字符串值。
//
// 大数据量的字段(messages/tools)在这里只是被跳过,不做任何解码。
func Lookup(body []byte, q Query) Result {
res := Result{Top: map[string]string{}, Nested: map[string]string{}}
i := skipSpace(body, 0)
if i >= len(body) || body[i] != '{' {
return res
}
i++
for {
i = skipSpace(body, i)
if i >= len(body) {
return res
}
if body[i] == '}' {
res.Ok = true
return res
}
key, next, ok := readKey(body, i)
if !ok {
return res
}
i = skipSpace(body, next)
if i >= len(body) || body[i] != ':' {
return res
}
i = skipSpace(body, i+1)
if q.Nested != "" && len(q.NestedKeys) > 0 && string(key) == q.Nested {
res.Nested = collect(body, i, q.NestedKeys)
j, ok := skipValue(body, i)
if !ok {
return res
}
i = skipSpace(body, j)
} else if matchAny(key, q.Top) {
if v, after, ok := readStrValue(body, i); ok {
res.Top[string(key)] = v
i = skipSpace(body, after)
} else {
j, ok := skipValue(body, i)
if !ok {
return res
}
i = skipSpace(body, j)
}
} else {
j, ok := skipValue(body, i)
if !ok {
return res
}
i = skipSpace(body, j)
}
if i >= len(body) {
return res
}
switch body[i] {
case ',':
i++
case '}':
res.Ok = true
return res
default:
return res
}
}
}
// collect 在 body[i] 处的对象里收集 keys 的字符串值(未命中留空)。
func collect(body []byte, i int, keys []string) map[string]string {
out := map[string]string{}
i = skipSpace(body, i)
if i >= len(body) || body[i] != '{' {
return out
}
i++
for {
i = skipSpace(body, i)
if i >= len(body) || body[i] == '}' {
return out
}
key, next, ok := readKey(body, i)
if !ok {
return out
}
i = skipSpace(body, next)
if i >= len(body) || body[i] != ':' {
return out
}
i = skipSpace(body, i+1)
if matchAny(key, keys) {
if v, after, ok := readStrValue(body, i); ok {
out[string(key)] = v
i = skipSpace(body, after)
} else {
j, ok := skipValue(body, i)
if !ok {
return out
}
i = skipSpace(body, j)
}
} else {
j, ok := skipValue(body, i)
if !ok {
return out
}
i = skipSpace(body, j)
}
if i >= len(body) {
return out
}
switch body[i] {
case ',':
i++
case '}':
return out
default:
return out
}
}
}
// TopLevelString 取顶层对象里某个键的字符串值(便捷入口;查多个键时直接用 Lookup)。
func TopLevelString(body []byte, key string) (string, bool) {
res := Lookup(body, Query{Top: []string{key}})
if !res.Ok {
return "", false
}
v, ok := res.Top[key]
return v, ok
}
// NestedString 取顶层对象.objKey 这个子对象里 key 的字符串值。
func NestedString(body []byte, objKey, key string) (string, bool) {
res := Lookup(body, Query{Nested: objKey, NestedKeys: []string{key}})
if !res.Ok {
return "", false
}
v, ok := res.Nested[key]
return v, ok
}
// FirstMessageRole 取 messages[0].role。语义与整树解析一致:
// messages 不是非空数组 / 首元素不是对象 / role 缺失或不是字符串 → ok=false。
func FirstMessageRole(body []byte) (string, bool) {
i := skipSpace(body, 0)
if i >= len(body) || body[i] != '{' {
return "", false
}
i++
for {
i = skipSpace(body, i)
if i >= len(body) || body[i] == '}' {
return "", false
}
key, next, ok := readKey(body, i)
if !ok {
return "", false
}
i = skipSpace(body, next)
if i >= len(body) || body[i] != ':' {
return "", false
}
i = skipSpace(body, i+1)
if string(key) == "messages" {
i = skipSpace(body, i)
if i >= len(body) || body[i] != '[' {
return "", false
}
i = skipSpace(body, i+1)
if i < len(body) && body[i] == ']' {
return "", false
}
first := collect(body, i, []string{"role"})
role, ok := first["role"]
return role, ok
}
j, ok := skipValue(body, i)
if !ok {
return "", false
}
i = skipSpace(body, j)
if i >= len(body) {
return "", false
}
switch body[i] {
case ',':
i++
case '}':
return "", false
default:
return "", false
}
}
}
// IsObject 报告扫描器能否完整走完这个 body 的顶层对象。
//
// 用途:调用方用它决定「扫描结果可信」还是「回落整树解析」。走不通说明 body
// 不是合法对象或形态超出本包假设——此时不要相信「没找到键」的结论。
func IsObject(body []byte) bool {
i := skipSpace(body, 0)
if i >= len(body) || body[i] != '{' {
return false
}
i++
for {
i = skipSpace(body, i)
if i >= len(body) {
return false
}
if body[i] == '}' {
return true
}
_, next, ok := readKey(body, i)
if !ok {
return false
}
i = skipSpace(body, next)
if i >= len(body) || body[i] != ':' {
return false
}
j, ok := skipValue(body, i+1)
if !ok {
return false
}
i = skipSpace(body, j)
if i >= len(body) {
return false
}
switch body[i] {
case ',':
i++
case '}':
return true
default:
return false
}
}
}
// matchAny 报告 key 是否在 want 里。
func matchAny(key []byte, want []string) bool {
for _, w := range want {
if string(key) == w {
return true
}
}
return false
}
// skipSpace 跳过 JSON 空白。
func skipSpace(b []byte, i int) int {
for i < len(b) {
switch b[i] {
case ' ', '\t', '\n', '\r':
i++
default:
return i
}
}
return i
}
// readKey 读一个对象键(b[i] 必须是 '"'),返回**未解转义**的原始字节与结束偏移。
// 键几乎总是纯 ASCII,原始字节可直接与候选键比较;含转义的键由调用方按原文比较
// (对候选键无转义这一前提成立)。这里不做解码,避免为每个键付一次 Unmarshal。
func readKey(b []byte, i int) ([]byte, int, bool) {
if i >= len(b) || b[i] != '"' {
return nil, i, false
}
j := i + 1
for {
n := bytes.IndexByte(b[j:], '"')
if n < 0 {
return nil, i, false
}
j += n
if !escaped(b, i, j) {
return b[i+1 : j], j + 1, true
}
j++
}
}
// escaped 报告 b[pos] 处的引号是否被反斜杠转义(数前面连续反斜杠的奇偶)。
func escaped(b []byte, start, pos int) bool {
bs := 0
for k := pos - 1; k > start && b[k] == '\\'; k-- {
bs++
}
return bs%2 == 1
}
// readStrValue 读一个字符串值并解转义。b[i] 必须是 '"'。
func readStrValue(b []byte, i int) (string, int, bool) {
raw, end, ok := readKey(b, i)
if !ok {
return "", i, false
}
// 快路径只处理「无转义 + 合法 UTF-8」的字符串(绝大多数情况)。
// 其余一律交给 encoding/json:它会把非法 UTF-8 字节替换成 U+FFFD、把 \uXXXX
// 解成对应字符——直接 string(raw) 会漏掉前者(fuzz 抓到的真实差异)。
if bytes.IndexByte(raw, '\\') < 0 && utf8.Valid(raw) {
return string(raw), end, true
}
var s string
if err := json.Unmarshal(b[i:end], &s); err != nil {
return "", i, false
}
return s, end, true
}
// skipString 跳过一个字符串(不解转义、不分配),返回结束偏移。
func skipString(b []byte, i int) (int, bool) {
if i >= len(b) || b[i] != '"' {
return i, false
}
j := i + 1
for {
n := bytes.IndexByte(b[j:], '"')
if n < 0 {
return i, false
}
j += n
if !escaped(b, i, j) {
return j + 1, true
}
j++
}
}
// skipValue 从 b[i] 起跳过一个完整 JSON 值,返回其后的偏移。零分配、不解转义。
func skipValue(b []byte, i int) (int, bool) {
i = skipSpace(b, i)
if i >= len(b) {
return i, false
}
switch b[i] {
case '"':
return skipString(b, i)
case '{', '[':
depth := 0
for i < len(b) {
switch b[i] {
case '"':
next, ok := skipString(b, i)
if !ok {
return i, false
}
i = next
continue
case '{', '[':
depth++
case '}', ']':
depth--
if depth == 0 {
return i + 1, true
}
}
i++
}
return i, false
default:
// 数字 / true / false / null:扫到分隔符为止。
start := i
for i < len(b) {
switch b[i] {
case ',', '}', ']', ' ', '\t', '\n', '\r':
if i == start {
return i, false
}
return i, true
}
i++
}
return i, i > start
}
}
// Validate 只在测试里用:确认扫描器与整树解析对同一 body 的判定一致。
func Validate(body []byte) error {
var obj map[string]any
if err := json.Unmarshal(body, &obj); err != nil {
return nil // 坏 body 不是本函数的关注点
}
keys := []string{"model", "conversation_id", "conversationId", "user_id", "prompt_cache_key"}
res := Lookup(body, Query{Top: keys})
if !res.Ok {
return fmt.Errorf("scanner could not walk object: %s", body)
}
for _, k := range keys {
want, _ := obj[k].(string)
if want != res.Top[k] {
return fmt.Errorf("key %q: got %q want %q", k, res.Top[k], want)
}
}
return nil
}