Files
CLIProxyAPI/internal/runtime/executor/helps/devin_payload.go
Luis Pater 6e6afab99a refactor: migrate gjson, sjson, and base64 to MoeForge/moego
- 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
2026-11-03 03:05:04 +08:00

230 lines
7.7 KiB
Go

package helps
import (
"bytes"
"encoding/json"
"fmt"
"github.com/MoeForge/moego/base64"
"math"
"github.com/MoeForge/moego/ojson"
"github.com/router-for-me/CLIProxyAPI/v8/internal/util"
"google.golang.org/protobuf/encoding/protowire"
)
// Devin payload rules address the native business fields, never credentials or
// Connect framing. Encoding after the barrier does not inject defaults or sanitize.
type devinPayloadField struct {
name string
kind protowire.Type
repeated bool
binary bool
jsonValue bool
children map[protowire.Number]devinPayloadField
}
var devinPayloadFields = map[protowire.Number]devinPayloadField{
2: {name: "system_prompt", kind: protowire.BytesType},
3: {name: "prompts", kind: protowire.BytesType, repeated: true, children: map[protowire.Number]devinPayloadField{
1: {name: "id", kind: protowire.BytesType},
2: {name: "source", kind: protowire.VarintType},
3: {name: "content", kind: protowire.BytesType},
6: {name: "tool_calls", kind: protowire.BytesType, repeated: true, children: map[protowire.Number]devinPayloadField{
1: {name: "id", kind: protowire.BytesType},
2: {name: "name", kind: protowire.BytesType},
3: {name: "arguments", kind: protowire.BytesType},
}},
7: {name: "tool_call_id", kind: protowire.BytesType},
10: {name: "images", kind: protowire.BytesType, repeated: true, children: map[protowire.Number]devinPayloadField{
1: {name: "data", kind: protowire.BytesType},
2: {name: "mime_type", kind: protowire.BytesType},
}},
11: {name: "thinking", kind: protowire.BytesType},
12: {name: "signature", kind: protowire.BytesType, binary: true},
18: {name: "signature_type", kind: protowire.BytesType},
}},
8: {name: "completion_config", kind: protowire.BytesType, children: map[protowire.Number]devinPayloadField{
1: {name: "enabled", kind: protowire.VarintType},
2: {name: "max_tokens", kind: protowire.VarintType},
3: {name: "parameter_3", kind: protowire.VarintType},
5: {name: "temperature", kind: protowire.Fixed64Type},
7: {name: "top_k", kind: protowire.VarintType},
8: {name: "top_p", kind: protowire.Fixed64Type},
}},
10: {name: "tools", kind: protowire.BytesType, repeated: true, children: map[protowire.Number]devinPayloadField{
1: {name: "name", kind: protowire.BytesType},
2: {name: "description", kind: protowire.BytesType},
3: {name: "parameters", kind: protowire.BytesType, jsonValue: true},
}},
16: {name: "cascade_id", kind: protowire.BytesType},
21: {name: "model", kind: protowire.BytesType},
}
// DevinPayloadDefaultsSource maps caller field presence to the native business
// view so defaults can replace built-in values without replacing caller values.
func DevinPayloadDefaultsSource(native, interactions []byte) []byte {
doc := ojson.NewDocString("{}")
for target, sources := range map[string][]string{
"model": {"model"},
"system_prompt": {"system_instruction", "systemInstruction"},
"prompts": {"input"},
"tools": {"tools"},
"cascade_id": {"session_id", "sessionId", "conversation_id", "previous_interaction_id"},
"completion_config.max_tokens": {"generation_config.max_output_tokens", "generationConfig.max_output_tokens"},
"completion_config.temperature": {"generation_config.temperature", "generationConfig.temperature", "temperature"},
"completion_config.top_k": {"generation_config.top_k", "generationConfig.top_k"},
"completion_config.top_p": {"generation_config.top_p", "generationConfig.top_p"},
} {
var value ojson.Result
for _, source := range sources {
value = ojson.GetBytesNoCopy(interactions, source)
if value.Exists() {
break
}
}
if !value.Exists() {
continue
}
if target == "prompts" || target == "tools" {
value = ojson.GetBytesNoCopy(native, target)
}
if value.Exists() {
_ = doc.SetRaw(target, value.Raw)
}
}
return doc.Bytes()
}
// FinalizeDevinPayload projects the already-normalized protobuf business fields
// to JSON for user rules, then replaces only those fields in the wire message.
func FinalizeDevinPayload(wire []byte, finalize PayloadFinalizer) ([]byte, []byte, error) {
view, errDecode := decodeDevinPayload(wire, devinPayloadFields)
if errDecode != nil {
return nil, nil, errDecode
}
body, errMarshal := json.Marshal(view)
if errMarshal != nil {
return nil, nil, errMarshal
}
doc := ojson.NewDoc(body)
finalize.FinalizeDoc(doc)
configured := doc.Bytes()
if bytes.Equal(configured, body) {
return wire, configured, nil
}
body = configured
out, errEncode := encodeDevinPayload(wire, util.ParseGJSONBytesNoCopy(body), devinPayloadFields)
return out, body, errEncode
}
func decodeDevinPayload(wire []byte, fields map[protowire.Number]devinPayloadField) (map[string]any, error) {
out := make(map[string]any)
for len(wire) > 0 {
num, kind, tagLen := protowire.ConsumeTag(wire)
if tagLen < 0 {
return nil, protowire.ParseError(tagLen)
}
wire = wire[tagLen:]
n := protowire.ConsumeFieldValue(num, kind, wire)
if n < 0 {
return nil, protowire.ParseError(n)
}
field, ok := fields[num]
if ok {
var value any
switch kind {
case protowire.BytesType:
data, _ := protowire.ConsumeBytes(wire)
switch {
case field.children != nil:
decoded, errDecode := decodeDevinPayload(data, field.children)
if errDecode != nil {
return nil, errDecode
}
value = decoded
case field.binary:
value = base64.StdEncoding.EncodeToString(data)
case field.jsonValue && json.Valid(data):
value = json.RawMessage(data)
default:
value = string(data)
}
case protowire.VarintType:
value, _ = protowire.ConsumeVarint(wire)
case protowire.Fixed64Type:
bits, _ := protowire.ConsumeFixed64(wire)
value = math.Float64frombits(bits)
}
if field.repeated {
values, _ := out[field.name].([]any)
out[field.name] = append(values, value)
} else {
out[field.name] = value
}
}
wire = wire[n:]
}
return out, nil
}
func encodeDevinPayload(original []byte, body ojson.Result, fields map[protowire.Number]devinPayloadField) ([]byte, error) {
var out []byte
// Credentials, device metadata, thread ordinals, and protocol flags stay opaque.
for len(original) > 0 {
num, kind, tagLen := protowire.ConsumeTag(original)
if tagLen < 0 {
return nil, protowire.ParseError(tagLen)
}
n := protowire.ConsumeFieldValue(num, kind, original[tagLen:])
if n < 0 {
return nil, protowire.ParseError(n)
}
if _, ok := fields[num]; !ok {
out = append(out, original[:tagLen+n]...)
}
original = original[tagLen+n:]
}
for num := protowire.Number(1); num <= 21; num++ {
field, ok := fields[num]
if !ok {
continue
}
value := body.Get(field.name)
if !value.Exists() || value.Type == ojson.Null {
continue
}
values := []ojson.Result{value}
if field.repeated {
values = value.Array()
}
for _, item := range values {
out = protowire.AppendTag(out, num, field.kind)
switch field.kind {
case protowire.BytesType:
data := []byte(item.String())
if field.children != nil {
var errEncode error
data, errEncode = encodeDevinPayload(nil, item, field.children)
if errEncode != nil {
return nil, errEncode
}
} else if field.binary {
var errDecode error
data, errDecode = base64.StdEncoding.DecodeString(item.String())
if errDecode != nil {
return nil, fmt.Errorf("Devin payload %s: %w", field.name, errDecode)
}
} else if field.jsonValue {
data = []byte(item.Raw)
}
out = protowire.AppendBytes(out, data)
case protowire.VarintType:
out = protowire.AppendVarint(out, item.Uint())
case protowire.Fixed64Type:
out = protowire.AppendFixed64(out, math.Float64bits(item.Float()))
}
}
}
return out, nil
}