Files
CLIProxyAPI/internal/runtime/executor/xai_executor_execute.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

487 lines
19 KiB
Go

package executor
import (
"bytes"
"context"
"fmt"
"io"
"net/http"
"strings"
"time"
"github.com/MoeForge/moego/ojson"
"github.com/router-for-me/CLIProxyAPI/v8/internal/runtime/executor/helps"
cliproxyauth "github.com/router-for-me/CLIProxyAPI/v8/sdk/cliproxy/auth"
cliproxyexecutor "github.com/router-for-me/CLIProxyAPI/v8/sdk/cliproxy/executor"
sdktranslator "github.com/router-for-me/CLIProxyAPI/v8/sdk/translator"
log "github.com/sirupsen/logrus"
)
func (e *XAIExecutor) Execute(ctx context.Context, auth *cliproxyauth.Auth, req cliproxyexecutor.Request, opts cliproxyexecutor.Options) (resp cliproxyexecutor.Response, err error) {
ctx = helps.EnsureSessionContext(ctx, opts, req.Payload)
if opts.Alt == "responses/compact" {
return e.executeCompact(ctx, auth, req, opts)
}
if endpointPath := xaiImageEndpointPath(opts); endpointPath != "" {
return e.executeImages(ctx, auth, req, opts, endpointPath)
}
if xaiIsVideoRequest(opts) {
return e.executeVideos(ctx, auth, req, opts)
}
if xaiIsSpeechRequest(opts) {
return e.executeSpeech(ctx, auth, req, opts)
}
token, _ := xaiCreds(auth)
baseURL := xaiChatBaseURL(auth)
logXAIResolvedBaseURL(ctx, baseURL)
prepared, err := e.prepareResponsesRequestDoc(ctx, req, opts, true)
if err != nil {
return resp, err
}
reporter := helps.NewExecutorUsageReporter(ctx, e, prepared.baseModel, auth)
defer reporter.TrackFailure(ctx, &err)
url := strings.TrimSuffix(baseURL, "/") + "/responses"
doc := prepared.ensureDoc()
sanitizeXAIInputEncryptedContentForBaseURLDoc(doc, baseURL)
helps.FinalizePayloadDoc(helps.WithPayloadFinalizer(ctx, prepared.finalizePayload), doc)
prepared.body = doc.Bytes()
reporter.SetTranslatedReasoningEffort(prepared.body, e.Identifier())
httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(prepared.body))
if err != nil {
return resp, err
}
applyXAIChatHeaders(httpReq, auth, token, true, prepared.sessionID, opts.Headers)
e.recordXAIRequest(ctx, auth, url, httpReq.Header.Clone(), prepared.body)
httpClient := helps.NewProxyAwareHTTPClient(ctx, e.cfg, auth, 0)
httpClient = reporter.TrackHTTPClient(httpClient)
httpResp, err := httpClient.Do(httpReq)
if err != nil {
helps.RecordAPIResponseError(ctx, e.cfg, err)
return resp, err
}
defer func() {
if errClose := httpResp.Body.Close(); errClose != nil {
log.Errorf("xai executor: close response body error: %v", errClose)
}
}()
helps.RecordAPIResponseMetadata(ctx, e.cfg, httpResp.StatusCode, httpResp.Header.Clone())
if httpResp.StatusCode < 200 || httpResp.StatusCode >= 300 {
data, errRead := io.ReadAll(httpResp.Body)
if errRead != nil {
helps.RecordAPIResponseError(ctx, e.cfg, errRead)
return resp, errRead
}
helps.AppendAPIResponseChunk(ctx, e.cfg, data)
helps.LogWithRequestID(ctx).Debugf("request error, error status: %d, error message: %s", httpResp.StatusCode, helps.SummarizeErrorBody(httpResp.Header.Get("Content-Type"), data))
return resp, xaiStatusErr(httpResp.StatusCode, data)
}
data, err := io.ReadAll(httpResp.Body)
if err != nil {
helps.RecordAPIResponseError(ctx, e.cfg, err)
return resp, err
}
helps.AppendAPIResponseChunk(ctx, e.cfg, data)
outputItemsByIndex := make(map[int64][]byte)
var outputItemsFallback [][]byte
responseFilter := newXAIInternalXSearchResponseFilter(prepared.filterInternalXSearch, prepared.clientDeclaredTools)
namespaceRestorer := newXAINamespaceRestorer(prepared.namespaceTools)
var upstreamUsage helps.StreamUsageBuffer
for _, line := range bytes.Split(data, []byte("\n")) {
if !bytes.HasPrefix(line, xaiDataTag) {
continue
}
eventData := xaiNormalizeReasoningSummaryData(bytes.TrimSpace(line[len(xaiDataTag):]))
upstreamUsage.ObserveResponsesStream(eventData)
prepared.applyPatch.RememberDispatcherEvent(eventData)
eventData = namespaceRestorer.restore(eventData)
if prepared.webSearchAlias != "" {
eventData = restoreXAIClientWebSearchName(eventData, prepared.webSearchAlias)
}
eventData = responseFilter.apply(eventData)
if len(eventData) == 0 {
continue
}
events, errBridge := prepared.applyPatch.Transform(eventData)
if errBridge != nil {
errBridge = statusErr{code: http.StatusBadGateway, msg: helps.ApplyPatchUpstreamErrorMessage}
upstreamUsage.PublishFailure(ctx, reporter, errBridge)
return resp, errBridge
}
for _, eventData := range events {
reporter.ObserveResponseModel(eventData)
eventType := ojson.GetBytesNoCopy(eventData, "type").String()
switch eventType {
case "response.output_item.done":
xaiCollectOutputItemDone(eventData, outputItemsByIndex, &outputItemsFallback)
case "response.completed", "response.incomplete":
completedData := xaiPatchCompletedOutput(eventData, outputItemsByIndex, outputItemsFallback)
completedData = xaiNormalizeReasoningSummaryData(completedData)
if eventType == "response.completed" {
// A truncated turn carries no replayable terminal state, so only a
// completed response may refresh the reasoning replay cache.
cacheXAIReasoningReplayFromCompleted(ctx, prepared.replayScope, completedData)
}
var param any
out := sdktranslator.TranslateNonStream(ctx, prepared.to, prepared.responseFormat, req.Model, prepared.originalPayload, prepared.body, completedData, &param)
if helps.ApplyPatchTranslationError(param) != nil || len(out) == 0 {
errTranslation := statusErr{code: http.StatusBadGateway, msg: helps.ApplyPatchUpstreamErrorMessage}
upstreamUsage.PublishFailure(ctx, reporter, errTranslation)
return cliproxyexecutor.Response{}, errTranslation
}
if !upstreamUsage.Publish(ctx, reporter) {
if detail, ok := helps.ParseCodexUsageWithOutputItems(completedData, outputItemsByIndex, outputItemsFallback); ok {
reporter.Publish(ctx, detail)
}
}
if prepared.responseFormat == sdktranslator.FormatOpenAIResponse {
out = helps.EnsureResponsesUsageDetails(out)
}
return cliproxyexecutor.Response{Payload: out, Headers: httpResp.Header.Clone()}, nil
}
}
}
if errFinish := prepared.applyPatch.Finish(); errFinish != nil {
errFinish = statusErr{code: http.StatusBadGateway, msg: helps.ApplyPatchUpstreamErrorMessage}
upstreamUsage.PublishFailure(ctx, reporter, errFinish)
return resp, errFinish
}
return resp, statusErr{code: http.StatusRequestTimeout, msg: "xai stream error: stream disconnected before response.completed or response.incomplete"}
}
func (e *XAIExecutor) executeCompact(ctx context.Context, auth *cliproxyauth.Auth, req cliproxyexecutor.Request, opts cliproxyexecutor.Options) (resp cliproxyexecutor.Response, err error) {
prepared, data, headers, reporter, errCompactRequest := e.executeCompactRequest(ctx, auth, req, opts)
if errCompactRequest != nil {
return resp, errCompactRequest
}
defer reporter.TrackFailure(ctx, &err)
upstreamUsage := helps.ParseOpenAIUsage(data)
converted, errBridge := prepared.applyPatch.Bridge.TransformNonStream(data)
if errBridge != nil {
errBridge = statusErr{code: http.StatusBadGateway, msg: helps.ApplyPatchUpstreamErrorMessage}
reporter.PublishFailureWithDetail(ctx, upstreamUsage, errBridge)
return resp, errBridge
}
var param any
out := sdktranslator.TranslateNonStream(ctx, prepared.to, prepared.responseFormat, req.Model, prepared.originalPayload, prepared.body, converted, &param)
if helps.ApplyPatchTranslationError(param) != nil || len(out) == 0 {
errTranslation := statusErr{code: http.StatusBadGateway, msg: helps.ApplyPatchUpstreamErrorMessage}
reporter.PublishFailureWithDetail(ctx, upstreamUsage, errTranslation)
return cliproxyexecutor.Response{}, errTranslation
}
reporter.Publish(ctx, upstreamUsage)
if prepared.responseFormat == sdktranslator.FormatOpenAIResponse {
out = helps.EnsureResponsesUsageDetails(out)
}
return cliproxyexecutor.Response{Payload: out, Headers: headers}, nil
}
func (e *XAIExecutor) executeCompactRequest(ctx context.Context, auth *cliproxyauth.Auth, req cliproxyexecutor.Request, opts cliproxyexecutor.Options) (*xaiPreparedRequest, []byte, http.Header, *helps.UsageReporter, error) {
token, _ := xaiCreds(auth)
// Compact must not use xaiChatBaseURL: CLI chat-proxy returns 404 for
// /responses/compact and a 404 cools down the whole xAI auth pool.
baseURL := xaiCompactBaseURL(auth)
logXAIResolvedBaseURL(ctx, baseURL)
prepared, err := e.prepareResponsesRequestToDoc(ctx, req, opts, false, sdktranslator.FormatOpenAIResponse)
if err != nil {
return nil, nil, nil, nil, err
}
doc := prepared.ensureDoc()
_ = doc.Delete("stream")
_ = doc.Delete("tools")
// Compact deletes tools after prepareResponsesRequestTo, which can now keep
// image_generation and rewrite its forced choice to "required" on grok-4.6+.
// Drop the leftover selection so compact does not send tool_choice without tools.
normalizeXAIToolChoiceForToolsDoc(doc)
for _, field := range []string{"max_output_tokens", "temperature", "top_p", "top_k", "stop"} {
_ = doc.Delete(field)
}
xaiRemoveInputItemsByTypeDoc(doc, "compaction_trigger")
if previousResponseID := strings.TrimSpace(ojson.GetBytesNoCopy(req.Payload, "previous_response_id").String()); previousResponseID != "" {
_ = doc.Set("previous_response_id", previousResponseID)
}
reporter := helps.NewExecutorUsageReporter(ctx, e, prepared.baseModel, auth)
defer reporter.TrackFailure(ctx, &err)
requestURL := strings.TrimSuffix(baseURL, "/") + "/responses/compact"
sanitizeXAIInputEncryptedContentForBaseURLDoc(doc, baseURL)
helps.FinalizePayloadDoc(helps.WithPayloadFinalizer(ctx, prepared.finalizePayload), doc)
prepared.body = doc.Bytes()
reporter.SetTranslatedReasoningEffort(prepared.body, e.Identifier())
httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, requestURL, bytes.NewReader(prepared.body))
if err != nil {
return nil, nil, nil, nil, err
}
// Official API / custom compact endpoints use standard API headers, not CLI
// chat-proxy identity headers (which applyXAIChatHeaders may still attach for OAuth chat).
applyXAIHeaders(httpReq, auth, token, false, prepared.sessionID, opts.Headers)
e.recordXAIRequest(ctx, auth, requestURL, httpReq.Header.Clone(), prepared.body)
httpClient := helps.NewProxyAwareHTTPClient(ctx, e.cfg, auth, 0)
httpClient = reporter.TrackHTTPClient(httpClient)
httpResp, err := httpClient.Do(httpReq)
if err != nil {
helps.RecordAPIResponseError(ctx, e.cfg, err)
return nil, nil, nil, nil, err
}
defer func() {
if errClose := httpResp.Body.Close(); errClose != nil {
log.Errorf("xai executor: close response body error: %v", errClose)
}
}()
helps.RecordAPIResponseMetadata(ctx, e.cfg, httpResp.StatusCode, httpResp.Header.Clone())
data, err := io.ReadAll(httpResp.Body)
if err != nil {
helps.RecordAPIResponseError(ctx, e.cfg, err)
return nil, nil, nil, nil, err
}
helps.AppendAPIResponseChunk(ctx, e.cfg, data)
if httpResp.StatusCode < 200 || httpResp.StatusCode >= 300 {
helps.LogWithRequestID(ctx).Debugf("request error, error status: %d, error message: %s", httpResp.StatusCode, helps.SummarizeErrorBody(httpResp.Header.Get("Content-Type"), data))
err = xaiStatusErr(httpResp.StatusCode, data)
return nil, nil, nil, nil, err
}
reporter.ObserveResponseModel(data)
clearXAIReasoningReplayAfterCompaction(ctx, prepared.replayScope)
return prepared, data, httpResp.Header.Clone(), reporter, nil
}
func (e *XAIExecutor) executeCompactionTriggerStream(ctx context.Context, auth *cliproxyauth.Auth, req cliproxyexecutor.Request, opts cliproxyexecutor.Options) (*cliproxyexecutor.StreamResult, error) {
prepared, data, headers, reporter, errCompactRequest := e.executeCompactRequest(ctx, auth, req, opts)
if errCompactRequest != nil {
return nil, errCompactRequest
}
reporter.Publish(ctx, helps.ParseOpenAIUsage(data))
headers = headers.Clone()
if headers == nil {
headers = make(http.Header)
}
headers.Set("Content-Type", "text/event-stream")
chunks := xaiBuildCompactionTriggerStreamChunks(prepared, data)
out := make(chan cliproxyexecutor.StreamChunk, len(chunks))
for _, chunk := range chunks {
out <- cliproxyexecutor.StreamChunk{Payload: chunk}
}
close(out)
return &cliproxyexecutor.StreamResult{Headers: headers, Chunks: out}, nil
}
func xaiInputHasItemType(body []byte, itemType string) bool {
input := ojson.GetBytesNoCopy(body, "input")
if !input.IsArray() {
return false
}
for _, item := range input.Array() {
if item.Get("type").String() == itemType {
return true
}
}
return false
}
func xaiRemoveInputItemsByType(body []byte, itemType string) []byte {
doc := ojson.NewDoc(body)
if !xaiRemoveInputItemsByTypeDoc(doc, itemType) {
return body
}
return doc.Bytes()
}
func xaiRemoveInputItemsByTypeDoc(doc *ojson.Doc, itemType string) bool {
if doc == nil {
return false
}
input := doc.Get("input")
if !input.IsArray() {
return false
}
var buf bytes.Buffer
buf.WriteByte('[')
kept := 0
for _, item := range input.Array() {
if item.Get("type").String() == itemType {
continue
}
if kept > 0 {
buf.WriteByte(',')
}
buf.WriteString(item.Raw)
kept++
}
buf.WriteByte(']')
return doc.SetRawBytes("input", buf.Bytes()) == nil
}
func xaiBuildCompactionTriggerStreamChunks(prepared *xaiPreparedRequest, compactData []byte) [][]byte {
responseID := xaiCompactionResponseID(compactData)
now := time.Now().Unix()
createdAt := ojson.GetBytesNoCopy(compactData, "created_at").Int()
if createdAt == 0 {
createdAt = now
}
completedAt := ojson.GetBytesNoCopy(compactData, "completed_at").Int()
if completedAt == 0 {
completedAt = now
}
item := xaiCompactionOutputItem(compactData, responseID)
output := make([]byte, 0, len(item)+2)
output = append(output, '[')
output = append(output, item...)
output = append(output, ']')
createdResponse := xaiBuildCompactionBaseResponse(prepared, compactData, responseID, createdAt, "in_progress")
inProgressResponse := xaiBuildCompactionBaseResponse(prepared, compactData, responseID, createdAt, "in_progress")
completedResponse := xaiBuildCompactionBaseResponse(prepared, compactData, responseID, createdAt, "completed")
requestModelName := ""
if prepared != nil {
requestModelName = ojson.GetBytesNoCopy(prepared.originalPayload, "model").String()
if requestModelName == "" {
requestModelName = prepared.baseModel
}
}
if requestModelName == "" {
requestModelName = ojson.GetBytesNoCopy(compactData, "model").String()
}
if requestModelName != "" {
createdResponse, _ = ojson.SetBytes(createdResponse, "model", requestModelName)
inProgressResponse, _ = ojson.SetBytes(inProgressResponse, "model", requestModelName)
}
completedDoc := ojson.NewDoc(completedResponse)
_ = completedDoc.Set("completed_at", completedAt)
_ = completedDoc.SetRawBytes("output", output)
if usage := ojson.GetBytesNoCopy(compactData, "usage"); usage.Exists() {
_ = completedDoc.SetRawBytes("usage", []byte(usage.Raw))
}
completedResponse = completedDoc.Bytes()
createdPayload := []byte(`{"type":"response.created","sequence_number":0}`)
createdPayload, _ = ojson.SetRawBytes(createdPayload, "response", createdResponse)
inProgressPayload := []byte(`{"type":"response.in_progress","sequence_number":1}`)
inProgressPayload, _ = ojson.SetRawBytes(inProgressPayload, "response", inProgressResponse)
addedPayload := []byte(`{"type":"response.output_item.added","sequence_number":2,"output_index":0}`)
addedPayload, _ = ojson.SetRawBytes(addedPayload, "item", item)
keepalivePayload := []byte(`{"type":"keepalive","sequence_number":3}`)
donePayload := []byte(`{"type":"response.output_item.done","sequence_number":4,"output_index":0}`)
donePayload, _ = ojson.SetRawBytes(donePayload, "item", item)
completedPayload := []byte(`{"type":"response.completed","sequence_number":5}`)
completedPayload, _ = ojson.SetRawBytes(completedPayload, "response", completedResponse)
completedPayload = helps.EnsureResponsesUsageDetails(completedPayload)
return [][]byte{
xaiBuildSSEFrame("response.created", createdPayload),
xaiBuildSSEFrame("response.in_progress", inProgressPayload),
xaiBuildSSEFrame("response.output_item.added", addedPayload),
xaiBuildSSEFrame("keepalive", keepalivePayload),
xaiBuildSSEFrame("response.output_item.done", donePayload),
xaiBuildSSEFrame("response.completed", completedPayload),
}
}
func xaiBuildCompactionBaseResponse(prepared *xaiPreparedRequest, compactData []byte, responseID string, createdAt int64, status string) []byte {
respDoc := ojson.NewDoc([]byte(`{"id":"","object":"response","created_at":0,"status":"","background":false,"error":null,"incomplete_details":null,"output":[]}`))
_ = respDoc.Set("id", responseID)
_ = respDoc.Set("created_at", createdAt)
_ = respDoc.Set("status", status)
if model := ojson.GetBytesNoCopy(compactData, "model").String(); model != "" {
_ = respDoc.Set("model", model)
} else if prepared != nil && prepared.baseModel != "" {
_ = respDoc.Set("model", prepared.baseModel)
}
if prepared == nil {
return respDoc.Bytes()
}
for _, field := range []string{
"instructions",
"max_output_tokens",
"max_tool_calls",
"parallel_tool_calls",
"previous_response_id",
"prompt_cache_key",
"reasoning",
"text",
"tool_choice",
"tools",
"top_logprobs",
"top_p",
"truncation",
"user",
"metadata",
} {
if value := ojson.GetBytesNoCopy(prepared.body, field); value.Exists() {
_ = respDoc.SetRawBytes(field, []byte(value.Raw))
}
}
return respDoc.Bytes()
}
func xaiCompactionOutputItem(compactData []byte, responseID string) []byte {
itemResult := ojson.GetBytesNoCopy(compactData, "output.0")
item := []byte(`{"type":"compaction"}`)
if itemResult.Exists() && itemResult.Type == ojson.JSON {
item = []byte(itemResult.Raw)
}
itemDoc := ojson.NewDoc(item)
changed := false
if !itemDoc.Get("type").Exists() {
if itemDoc.Set("type", "compaction") == nil {
changed = true
}
}
if !itemDoc.Get("id").Exists() {
if itemDoc.Set("id", xaiCompactionItemID(responseID)) == nil {
changed = true
}
}
if !changed {
return item
}
return itemDoc.Bytes()
}
func xaiCompactionResponseID(compactData []byte) string {
if responseID := strings.TrimSpace(ojson.GetBytesNoCopy(compactData, "id").String()); responseID != "" {
if strings.HasPrefix(responseID, "resp_") {
return responseID
}
return "resp_" + strings.TrimPrefix(responseID, "cmp_")
}
return fmt.Sprintf("resp_xai_compaction_%d", time.Now().UnixNano())
}
func xaiCompactionItemID(responseID string) string {
if suffix := strings.TrimPrefix(responseID, "resp_"); suffix != "" && suffix != responseID {
return "cmp_" + suffix
}
return "cmp_" + responseID
}
func xaiBuildSSEFrame(eventName string, data []byte) []byte {
out := make([]byte, 0, len(eventName)+len(data)+16)
out = append(out, "event: "...)
out = append(out, eventName...)
out = append(out, '\n')
out = append(out, "data: "...)
out = append(out, data...)
out = append(out, '\n', '\n')
return out
}