mirror of
https://github.com/router-for-me/CLIProxyAPI.git
synced 2026-11-16 22:57:53 +08:00
- Replace tidwall/gjson and tidwall/sjson with github.com/MoeForge/moego/ojson and encoding/base64 with github.com/MoeForge/moego/base64 across the main module and examples - Introduce cross-method *ojson.Doc request rewriting pipelines across thinking, signature, client/codex, runtime/executor/helps, pluginhost, and all provider executors with FinalizePayloadDoc as the final semantic barrier - Convert all consecutive JSON mutations (>= 2 Set/SetRaw/Delete operations) to batch edits on ojson.Doc - Upgrade read-only byte paths to ojson.GetBytesNoCopy, ojson.GetManyBytesNoCopy, and util.ParseGJSONBytesNoCopy with explicit strings.Clone ownership protection across streaming and persistent state - Use base64.StdEncoding.ValidateString for zero-allocation signature checks and base64.EncodeDataURL for single-allocation data URL construction
358 lines
11 KiB
Go
358 lines
11 KiB
Go
package helps
|
|
|
|
import (
|
|
"net/http"
|
|
"strings"
|
|
|
|
"github.com/MoeForge/moego/ojson"
|
|
"github.com/router-for-me/CLIProxyAPI/v8/internal/util"
|
|
)
|
|
|
|
const (
|
|
codexRateLimitsEventType = "codex.rate_limits"
|
|
codexQuotaAdditionalHeaderKey = "X-Codex-Additional-"
|
|
maxCodexAdditionalRateLimits = 8
|
|
)
|
|
|
|
// ParseCodexQuotaEventHeaders converts one Codex websocket quota event into the
|
|
// same bounded header representation used by HTTP usage observations. Codex
|
|
// sends additional_rate_limits as an object on the websocket path, while the
|
|
// /wham/usage probe exposes the equivalent data as an array; both forms are
|
|
// normalized into namespaced X-Codex headers here.
|
|
//
|
|
// The websocket payload identifies each additional limit only by limit name
|
|
// ("GPT-5.3-Codex-Spark"), while HTTP responses namespace the same limit by a
|
|
// short name (x-codex-bengalfox-*). The two forms therefore cannot produce
|
|
// identical header names; the X-Codex-Additional- prefix marks the websocket
|
|
// origin, and the snapshot-replacement semantics in QuotaState keep the two
|
|
// spellings from accumulating side by side.
|
|
func ParseCodexQuotaEventHeaders(payload []byte) http.Header {
|
|
if len(payload) == 0 {
|
|
return nil
|
|
}
|
|
|
|
eventKind := codexQuotaEventKind(payload)
|
|
if eventKind == codexQuotaEventOther {
|
|
return nil
|
|
}
|
|
root := util.ParseGJSONBytesNoCopy(payload)
|
|
if eventKind == codexQuotaEventError {
|
|
return parseCodexQuotaHeadersObject(root.Get("headers"))
|
|
}
|
|
|
|
headers := make(http.Header)
|
|
hasQuotaData := false
|
|
|
|
baseRateLimits := firstCodexQuotaResult(root, "rate_limits", "rateLimit")
|
|
if addCodexQuotaRateLimitHeaders(headers, "X-Codex-", baseRateLimits) {
|
|
// The main rate-limit object has no user-facing name in the websocket
|
|
// payload, so its fields retain the HTTP response header names.
|
|
hasQuotaData = true
|
|
}
|
|
|
|
additional := firstCodexQuotaResult(root, "additional_rate_limits", "additionalRateLimits")
|
|
additionalCount := 0
|
|
if additional.Exists() && (additional.IsObject() || additional.IsArray()) {
|
|
additional.ForEach(func(key, value ojson.Result) bool {
|
|
if additionalCount >= maxCodexAdditionalRateLimits {
|
|
return false
|
|
}
|
|
limitName := strings.TrimSpace(key.String())
|
|
if additional.IsArray() {
|
|
limitName = firstCodexQuotaResultString(value, "limit_name", "limitName", "name")
|
|
}
|
|
if limitName == "" {
|
|
return true
|
|
}
|
|
identifier := normalizeCodexQuotaHeaderIdentifier(limitName)
|
|
if identifier == "" {
|
|
return true
|
|
}
|
|
rateInfo := firstCodexQuotaResult(value, "rate_limit", "rateLimit")
|
|
if !rateInfo.Exists() {
|
|
rateInfo = value
|
|
}
|
|
prefix := codexQuotaAdditionalHeaderKey + identifier + "-"
|
|
if addCodexQuotaRateLimitHeaders(headers, prefix, rateInfo) {
|
|
// The limit name is upstream-controlled and lands in the
|
|
// plain-text request log, so reject control characters here the
|
|
// same way the plan type is validated below.
|
|
if validCodexQuotaEventText(limitName) {
|
|
headers.Set(prefix+"Limit-Name", strings.Clone(limitName))
|
|
}
|
|
hasQuotaData = true
|
|
additionalCount++
|
|
}
|
|
return true
|
|
})
|
|
}
|
|
|
|
codeReview := firstCodexQuotaResult(root, "code_review_rate_limits", "codeReviewRateLimits")
|
|
if addCodexQuotaRateLimitHeaders(headers, "X-Codex-Code-Review-", codeReview) {
|
|
hasQuotaData = true
|
|
}
|
|
|
|
credits := firstCodexQuotaResult(root, "credits")
|
|
if credits.Exists() && credits.IsObject() {
|
|
hasQuotaData = setCodexQuotaScalarHeader(headers, "X-Codex-Credits-Has-Credits", credits, "has_credits", "hasCredits") || hasQuotaData
|
|
hasQuotaData = setCodexQuotaScalarHeader(headers, "X-Codex-Credits-Unlimited", credits, "unlimited") || hasQuotaData
|
|
hasQuotaData = setCodexQuotaScalarHeader(headers, "X-Codex-Credits-Balance", credits, "balance") || hasQuotaData
|
|
}
|
|
|
|
if !hasQuotaData {
|
|
return nil
|
|
}
|
|
// A malformed active-limit name only invalidates that one header; the
|
|
// window percentages collected above stay valid and must not be discarded.
|
|
activeLimit := firstCodexQuotaResultString(root, "metered_limit_name", "meteredLimitName", "limit_name", "limitName")
|
|
if validCodexQuotaEventIdentifier(activeLimit) {
|
|
headers.Set("X-Codex-Active-Limit", activeLimit)
|
|
}
|
|
if planType := firstCodexQuotaResultString(root, "plan_type", "planType"); validCodexQuotaEventText(planType) {
|
|
headers.Set("X-Codex-Plan-Type", planType)
|
|
}
|
|
return headers
|
|
}
|
|
|
|
const (
|
|
codexQuotaEventOther = iota
|
|
codexQuotaEventError
|
|
codexQuotaEventRateLimits
|
|
)
|
|
|
|
// codexQuotaEventKind performs an allocation-free discriminator check for the
|
|
// common non-quota websocket event path. Codex frames carry the top-level
|
|
// type field within their opening bytes (after sequence_number at most), so
|
|
// only a bounded prefix is scanned instead of the whole frame; full JSON
|
|
// parsing is reserved for quota and error events.
|
|
func codexQuotaEventKind(payload []byte) int {
|
|
const scanLimit = 256
|
|
end := len(payload)
|
|
if end > scanLimit {
|
|
end = scanLimit
|
|
}
|
|
for i := 0; i+6 < end; i++ {
|
|
if payload[i] != '"' || payload[i+1] != 't' || payload[i+2] != 'y' || payload[i+3] != 'p' || payload[i+4] != 'e' || payload[i+5] != '"' {
|
|
continue
|
|
}
|
|
j := i + 6
|
|
for j < end && (payload[j] == ' ' || payload[j] == '\t' || payload[j] == '\r' || payload[j] == '\n') {
|
|
j++
|
|
}
|
|
if j >= end || payload[j] != ':' {
|
|
continue
|
|
}
|
|
j++
|
|
for j < end && (payload[j] == ' ' || payload[j] == '\t' || payload[j] == '\r' || payload[j] == '\n') {
|
|
j++
|
|
}
|
|
if j+7 <= end && payload[j] == '"' && payload[j+1] == 'e' && payload[j+2] == 'r' && payload[j+3] == 'r' && payload[j+4] == 'o' && payload[j+5] == 'r' && payload[j+6] == '"' {
|
|
return codexQuotaEventError
|
|
}
|
|
const rateLimits = `"codex.rate_limits"`
|
|
if j+len(rateLimits) <= end {
|
|
matched := true
|
|
for offset := range rateLimits {
|
|
if payload[j+offset] != rateLimits[offset] {
|
|
matched = false
|
|
break
|
|
}
|
|
}
|
|
if matched {
|
|
return codexQuotaEventRateLimits
|
|
}
|
|
}
|
|
}
|
|
return codexQuotaEventOther
|
|
}
|
|
|
|
func addCodexQuotaRateLimitHeaders(headers http.Header, prefix string, rateInfo ojson.Result) bool {
|
|
if !rateInfo.Exists() || !rateInfo.IsObject() {
|
|
return false
|
|
}
|
|
|
|
changed := false
|
|
if setCodexQuotaScalarHeaderFromResult(headers, prefix+"Allowed", rateInfo, "allowed") {
|
|
changed = true
|
|
}
|
|
if setCodexQuotaScalarHeaderFromResult(headers, prefix+"Limit-Reached", rateInfo, "limit_reached", "limitReached") {
|
|
changed = true
|
|
}
|
|
for _, windowName := range []string{"primary", "secondary"} {
|
|
window := firstCodexQuotaResult(rateInfo, windowName)
|
|
if !window.Exists() || !window.IsObject() {
|
|
continue
|
|
}
|
|
used := firstCodexQuotaResult(window, "used_percent", "usedPercent")
|
|
minutes := firstCodexQuotaResult(window, "window_minutes", "windowMinutes")
|
|
resetAfter := firstCodexQuotaResult(window, "reset_after_seconds", "resetAfterSeconds")
|
|
resetAt := firstCodexQuotaResult(window, "reset_at", "resetAt")
|
|
hasResetAfter := resetAfter.Exists() && resetAfter.Int() >= 0
|
|
hasResetAt := resetAt.Exists() && resetAt.Int() > 0
|
|
if !used.Exists() || !minutes.Exists() ||
|
|
used.Float() < 0 || used.Float() > 100 || minutes.Int() <= 0 ||
|
|
(!hasResetAfter && !hasResetAt) {
|
|
continue
|
|
}
|
|
windowPrefix := prefix + strings.ToUpper(windowName[:1]) + windowName[1:] + "-"
|
|
setCodexQuotaScalarHeaderFromResult(headers, windowPrefix+"Used-Percent", window, "used_percent", "usedPercent")
|
|
setCodexQuotaScalarHeaderFromResult(headers, windowPrefix+"Window-Minutes", window, "window_minutes", "windowMinutes")
|
|
if hasResetAfter {
|
|
setCodexQuotaScalarHeaderFromResult(headers, windowPrefix+"Reset-After-Seconds", window, "reset_after_seconds", "resetAfterSeconds")
|
|
}
|
|
if hasResetAt {
|
|
setCodexQuotaScalarHeaderFromResult(headers, windowPrefix+"Reset-At", window, "reset_at", "resetAt")
|
|
}
|
|
changed = true
|
|
}
|
|
return changed
|
|
}
|
|
|
|
func parseCodexQuotaHeadersObject(headersNode ojson.Result) http.Header {
|
|
if !headersNode.Exists() || !headersNode.IsObject() {
|
|
return nil
|
|
}
|
|
headers := make(http.Header)
|
|
headersNode.ForEach(func(key, value ojson.Result) bool {
|
|
name := http.CanonicalHeaderKey(strings.TrimSpace(key.String()))
|
|
if !isCodexQuotaHeaderName(name) {
|
|
return true
|
|
}
|
|
if raw := codexQuotaScalarValue(value); raw != "" {
|
|
headers.Set(name, raw)
|
|
}
|
|
return true
|
|
})
|
|
if len(headers) == 0 {
|
|
return nil
|
|
}
|
|
return headers
|
|
}
|
|
|
|
func isCodexQuotaHeaderName(name string) bool {
|
|
lower := strings.ToLower(strings.TrimSpace(name))
|
|
if lower == "retry-after" || strings.HasPrefix(lower, "x-ratelimit-") {
|
|
return true
|
|
}
|
|
if lower == "x-codex-active-limit" || lower == "x-codex-plan-type" ||
|
|
strings.HasPrefix(lower, "x-codex-credits-") {
|
|
return true
|
|
}
|
|
if !strings.HasPrefix(lower, "x-codex-") {
|
|
return false
|
|
}
|
|
for _, marker := range []string{
|
|
"-allowed",
|
|
"-limit-reached",
|
|
"-limit-name",
|
|
"-used-percent",
|
|
"-window-minutes",
|
|
"-reset-after-seconds",
|
|
"-reset-at",
|
|
"-over-secondary-limit-percent",
|
|
} {
|
|
if strings.Contains(lower, marker) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func setCodexQuotaScalarHeader(headers http.Header, name string, object ojson.Result, paths ...string) bool {
|
|
return setCodexQuotaScalarHeaderFromResult(headers, name, object, paths...)
|
|
}
|
|
|
|
func setCodexQuotaScalarHeaderFromResult(headers http.Header, name string, object ojson.Result, paths ...string) bool {
|
|
value := firstCodexQuotaResult(object, paths...)
|
|
if !value.Exists() {
|
|
return false
|
|
}
|
|
raw := codexQuotaScalarValue(value)
|
|
if raw == "" {
|
|
return false
|
|
}
|
|
headers.Set(name, raw)
|
|
return true
|
|
}
|
|
|
|
func codexQuotaScalarValue(value ojson.Result) string {
|
|
switch value.Type {
|
|
case ojson.String:
|
|
return strings.Clone(strings.TrimSpace(value.String()))
|
|
case ojson.Number, ojson.True, ojson.False:
|
|
return strings.Clone(strings.TrimSpace(value.Raw))
|
|
default:
|
|
return ""
|
|
}
|
|
}
|
|
|
|
func firstCodexQuotaResult(object ojson.Result, paths ...string) ojson.Result {
|
|
for _, path := range paths {
|
|
value := object.Get(path)
|
|
if value.Exists() && value.Type != ojson.Null {
|
|
return value
|
|
}
|
|
}
|
|
return ojson.Result{}
|
|
}
|
|
|
|
func firstCodexQuotaResultString(object ojson.Result, paths ...string) string {
|
|
for _, path := range paths {
|
|
value := firstCodexQuotaResult(object, path)
|
|
if raw := codexQuotaScalarValue(value); raw != "" {
|
|
return raw
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func normalizeCodexQuotaHeaderIdentifier(value string) string {
|
|
value = strings.TrimSpace(value)
|
|
if value == "" || len(value) > 128 {
|
|
return ""
|
|
}
|
|
var builder strings.Builder
|
|
builder.Grow(len(value))
|
|
lastDash := false
|
|
for _, char := range value {
|
|
switch {
|
|
case (char >= 'a' && char <= 'z') || (char >= 'A' && char <= 'Z') || (char >= '0' && char <= '9') || char == '.' || char == '_':
|
|
builder.WriteRune(char)
|
|
lastDash = false
|
|
case char == '-':
|
|
builder.WriteRune(char)
|
|
lastDash = false
|
|
default:
|
|
if !lastDash {
|
|
builder.WriteByte('-')
|
|
lastDash = true
|
|
}
|
|
}
|
|
}
|
|
identifier := strings.Trim(builder.String(), "-_.")
|
|
if identifier == "" || !validCodexQuotaEventIdentifier(identifier) {
|
|
return ""
|
|
}
|
|
return identifier
|
|
}
|
|
|
|
func validCodexQuotaEventIdentifier(value string) bool {
|
|
value = strings.TrimSpace(value)
|
|
if value == "" || len(value) > 256 {
|
|
return false
|
|
}
|
|
for _, char := range value {
|
|
if (char >= 'a' && char <= 'z') || (char >= 'A' && char <= 'Z') ||
|
|
(char >= '0' && char <= '9') || char == '_' || char == '-' || char == '.' {
|
|
continue
|
|
}
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
func validCodexQuotaEventText(value string) bool {
|
|
value = strings.TrimSpace(value)
|
|
return value != "" && len(value) <= 256 && !strings.ContainsAny(value, "\r\n")
|
|
}
|