mirror of
https://github.com/router-for-me/CLIProxyAPI.git
synced 2026-11-16 22:57:53 +08:00
- Capture bounded per-attempt upstream status, masked headers, response chunks, and transport or stream errors when request-log is false. - Bind synchronized deferred capture to the HTTP request context and preserve partial HTTP bodies and WebSocket dial or reconnect failures. - Mask Cookie headers alongside Set-Cookie so forced error logs do not expose session credentials. Closes: #7420 Co-authored-by: Dylan <1990016@gmail.com> Co-authored-by: lzt404 <2596933790@qq.com>
582 lines
22 KiB
Go
582 lines
22 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)
|
|
helps.AppendAPIResponseChunk(ctx, e.cfg, data)
|
|
if errRead != nil {
|
|
helps.RecordAPIResponseError(ctx, e.cfg, errRead)
|
|
return resp, errRead
|
|
}
|
|
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)
|
|
helps.AppendAPIResponseChunk(ctx, e.cfg, data)
|
|
if err != nil {
|
|
helps.RecordAPIResponseError(ctx, e.cfg, err)
|
|
return resp, err
|
|
}
|
|
|
|
outputItemsByIndex := make(map[int64][]byte)
|
|
var outputItemsFallback [][]byte
|
|
responseFilter := newXAIInternalXSearchResponseFilter(prepared.filterInternalXSearch, prepared.clientDeclaredTools)
|
|
namespaceRestorer := newXAINamespaceRestorer(prepared.namespaceTools)
|
|
var upstreamUsage helps.StreamUsageBuffer
|
|
events := helps.NewCodexSSEScanner(ctx, bytes.NewReader(data), len(data)+1)
|
|
sawSSEData := false
|
|
var pendingEventName string
|
|
var pendingData []byte
|
|
hasPendingData := false
|
|
|
|
dispatchSSEEvent := func(eventName string, rawEventData []byte) (cliproxyexecutor.Response, bool, error) {
|
|
rawEventData = bytes.TrimSpace(rawEventData)
|
|
if len(rawEventData) == 0 || bytes.Equal(rawEventData, []byte("[DONE]")) {
|
|
return cliproxyexecutor.Response{}, false, nil
|
|
}
|
|
sawSSEData = true
|
|
if !ojson.ValidBytes(rawEventData) {
|
|
if errTerminal, ok := xaiTerminalFailureErr(eventName, rawEventData); ok {
|
|
upstreamUsage.PublishFailure(ctx, reporter, errTerminal)
|
|
return cliproxyexecutor.Response{}, true, errTerminal
|
|
}
|
|
return cliproxyexecutor.Response{}, false, nil
|
|
}
|
|
eventData := xaiNormalizeReasoningSummaryData(rawEventData)
|
|
upstreamUsage.ObserveResponsesStream(eventData)
|
|
reporter.ObserveResponseModel(eventData)
|
|
if errTerminal, ok := xaiTerminalFailureErr(eventName, eventData); ok {
|
|
upstreamUsage.PublishFailure(ctx, reporter, errTerminal)
|
|
return cliproxyexecutor.Response{}, true, errTerminal
|
|
}
|
|
prepared.applyPatch.RememberDispatcherEvent(eventData)
|
|
eventData = namespaceRestorer.restore(eventData)
|
|
if prepared.webSearchAlias != "" {
|
|
eventData = restoreXAIClientWebSearchName(eventData, prepared.webSearchAlias)
|
|
}
|
|
eventData = responseFilter.apply(eventData)
|
|
if len(eventData) == 0 {
|
|
return cliproxyexecutor.Response{}, false, nil
|
|
}
|
|
transformedEvents, errBridge := prepared.applyPatch.Transform(eventData)
|
|
if errBridge != nil {
|
|
errBridge = statusErr{code: http.StatusBadGateway, msg: helps.ApplyPatchUpstreamErrorMessage}
|
|
upstreamUsage.PublishFailure(ctx, reporter, errBridge)
|
|
return cliproxyexecutor.Response{}, true, errBridge
|
|
}
|
|
for _, eventData := range transformedEvents {
|
|
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, ¶m)
|
|
if helps.ApplyPatchTranslationError(param) != nil || len(out) == 0 {
|
|
errTranslation := statusErr{code: http.StatusBadGateway, msg: helps.ApplyPatchUpstreamErrorMessage}
|
|
upstreamUsage.PublishFailure(ctx, reporter, errTranslation)
|
|
return cliproxyexecutor.Response{}, true, 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,
|
|
Incomplete: eventType == "response.incomplete",
|
|
Headers: httpResp.Header.Clone(),
|
|
}, true, nil
|
|
}
|
|
}
|
|
return cliproxyexecutor.Response{}, false, nil
|
|
}
|
|
|
|
flushPendingEvent := func() (cliproxyexecutor.Response, bool, error) {
|
|
if !hasPendingData {
|
|
pendingEventName = ""
|
|
pendingData = nil
|
|
return cliproxyexecutor.Response{}, false, nil
|
|
}
|
|
eventName := pendingEventName
|
|
eventPayload := pendingData
|
|
pendingEventName = ""
|
|
pendingData = nil
|
|
hasPendingData = false
|
|
return dispatchSSEEvent(eventName, eventPayload)
|
|
}
|
|
|
|
for events.Scan() {
|
|
line := bytes.TrimRight(events.Bytes(), "\r")
|
|
if len(bytes.TrimSpace(line)) == 0 {
|
|
if outResp, done, errDispatch := flushPendingEvent(); done {
|
|
return outResp, errDispatch
|
|
}
|
|
continue
|
|
}
|
|
if bytes.HasPrefix(line, xaiEventTag) {
|
|
nextEventName := strings.TrimSpace(string(line[len(xaiEventTag):]))
|
|
if hasPendingData && pendingEventName != "" {
|
|
if outResp, done, errDispatch := flushPendingEvent(); done {
|
|
return outResp, errDispatch
|
|
}
|
|
}
|
|
pendingEventName = nextEventName
|
|
continue
|
|
}
|
|
if !bytes.HasPrefix(line, xaiDataTag) {
|
|
continue
|
|
}
|
|
rawEventData := bytes.TrimSpace(line[len(xaiDataTag):])
|
|
if hasPendingData {
|
|
if ojson.ValidBytes(pendingData) || bytes.Equal(pendingData, []byte("[DONE]")) {
|
|
if outResp, done, errDispatch := flushPendingEvent(); done {
|
|
return outResp, errDispatch
|
|
}
|
|
} else {
|
|
pendingData = append(append(pendingData, '\n'), rawEventData...)
|
|
continue
|
|
}
|
|
}
|
|
pendingData = bytes.Clone(rawEventData)
|
|
hasPendingData = true
|
|
}
|
|
if outResp, done, errDispatch := flushPendingEvent(); done {
|
|
return outResp, errDispatch
|
|
}
|
|
|
|
if !sawSSEData {
|
|
if trimmed := bytes.TrimSpace(data); len(trimmed) > 0 {
|
|
if errTerminal, ok := xaiTerminalFailureErr("", trimmed); ok {
|
|
upstreamUsage.PublishFailure(ctx, reporter, errTerminal)
|
|
return resp, errTerminal
|
|
}
|
|
}
|
|
}
|
|
if prepared.applyPatch.HasPatchActivity() {
|
|
if errFinish := prepared.applyPatch.Finish(); errFinish != nil {
|
|
errFinish = xaiRequestScopedStreamError{statusErr: statusErr{code: http.StatusBadGateway, msg: helps.ApplyPatchUpstreamErrorMessage}}
|
|
upstreamUsage.PublishFailure(ctx, reporter, errFinish)
|
|
return resp, errFinish
|
|
}
|
|
}
|
|
if !sawSSEData {
|
|
errEmpty := newXAIEmptyStreamError()
|
|
upstreamUsage.PublishFailure(ctx, reporter, errEmpty)
|
|
return resp, errEmpty
|
|
}
|
|
errIncomplete := newXAIIncompleteStreamError()
|
|
upstreamUsage.PublishFailure(ctx, reporter, errIncomplete)
|
|
return resp, errIncomplete
|
|
}
|
|
|
|
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, ¶m)
|
|
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)
|
|
helps.AppendAPIResponseChunk(ctx, e.cfg, data)
|
|
if err != nil {
|
|
helps.RecordAPIResponseError(ctx, e.cfg, err)
|
|
return nil, nil, nil, nil, err
|
|
}
|
|
|
|
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
|
|
}
|