Files
CLIProxyAPI/internal/runtime/executor/codex_executor_execute.go
Luis Pater ece3f52a41 fix(logging): preserve bounded upstream responses in error logs
- 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>
2026-11-11 03:31:39 +08:00

557 lines
23 KiB
Go

package executor
import (
"bytes"
"context"
"io"
"net/http"
"strings"
"github.com/MoeForge/moego/ojson"
"github.com/router-for-me/CLIProxyAPI/v8/internal/config"
"github.com/router-for-me/CLIProxyAPI/v8/internal/runtime/executor/helps"
"github.com/router-for-me/CLIProxyAPI/v8/internal/thinking"
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"
)
type codexCompactionSummaryContextKey struct{}
type codexCompactionSummaryState struct {
baseModel string
}
func withCodexCompactionSummary(ctx context.Context, baseModel string) context.Context {
if ctx == nil {
ctx = context.Background()
}
return context.WithValue(ctx, codexCompactionSummaryContextKey{}, &codexCompactionSummaryState{baseModel: baseModel})
}
func codexCompactionSummaryStateFromContext(ctx context.Context) *codexCompactionSummaryState {
if ctx == nil {
return nil
}
state, _ := ctx.Value(codexCompactionSummaryContextKey{}).(*codexCompactionSummaryState)
return state
}
func codexCompactionSummaryFromContext(ctx context.Context) bool {
return codexCompactionSummaryStateFromContext(ctx) != nil
}
func rejectSyntheticCompactionPreviousResponseID(ctx context.Context, payload []byte) error {
prevID := strings.TrimSpace(ojson.GetBytesNoCopy(payload, "previous_response_id").String())
if !helps.RecognizedResponsesCompactionResponseID(prevID) {
return nil
}
if cliproxyexecutor.DownstreamWebsocket(ctx) {
return &cliproxyexecutor.UpstreamWebsocketTurnError{
FullContextRequired: true,
EventID: strings.Clone(strings.TrimSpace(ojson.GetBytesNoCopy(payload, "event_id").String())),
}
}
return statusErr{
code: http.StatusBadRequest,
msg: "previous_response_id references a local compaction response; resend full conversation input without previous_response_id",
}
}
func validateCodexLocalCompactionSource(ctx context.Context, payload []byte) error {
prevID := strings.TrimSpace(ojson.GetBytesNoCopy(payload, "previous_response_id").String())
reqType := strings.TrimSpace(ojson.GetBytesNoCopy(payload, "type").String())
if prevID != "" || reqType == "response.append" {
if cliproxyexecutor.DownstreamWebsocket(ctx) {
return &cliproxyexecutor.UpstreamWebsocketTurnError{
FullContextRequired: true,
EventID: strings.Clone(strings.TrimSpace(ojson.GetBytesNoCopy(payload, "event_id").String())),
}
}
return statusErr{
code: http.StatusBadRequest,
msg: "local summary compaction requires full conversation input without previous_response_id",
}
}
if !helps.HasResponsesCompactionConversationInput(payload) {
return statusErr{
code: http.StatusBadRequest,
msg: "local summary compaction requires non-empty conversation input",
}
}
return nil
}
func (e *CodexExecutor) expandCodexResponsesCompaction(auth *cliproxyauth.Auth, req *cliproxyexecutor.Request, opts *cliproxyexecutor.Options, baseModel string) (bool, error) {
if req == nil || opts == nil {
return false, nil
}
isCompat := e.resolveCodexModelIsCompat(auth, *req, baseModel)
if isCompat && opts.SourceFormat == sdktranslator.FormatOpenAIResponse && opts.Alt != "responses/compact" {
return true, helps.ExpandResponsesCompactionCapsules(req, opts, e.Identifier())
}
return isCompat, helps.ExpandRecognizedResponsesCompactionCapsules(req, opts)
}
func (e *CodexExecutor) shouldCompactCompatResponsesTrigger(isCompat bool, req cliproxyexecutor.Request, opts cliproxyexecutor.Options) bool {
return isCompat && opts.SourceFormat == sdktranslator.FormatOpenAIResponse && opts.Alt != "responses/compact" && helps.HasResponsesCompactionTriggerRequest(req, opts)
}
func (e *CodexExecutor) 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)
ctx = helps.WithCodexCommentaryPolicy(ctx, e.cfg)
if opts.Alt == "responses/compact" {
return e.executeCompact(ctx, auth, req, opts)
}
if isCodexOpenAIImageRequest(opts) {
if errExpand := helps.ExpandRecognizedResponsesCompactionCapsules(&req, &opts); errExpand != nil {
return resp, statusErr{code: http.StatusBadRequest, msg: errExpand.Error()}
}
return e.executeOpenAIImage(ctx, auth, req, opts)
}
baseModel := thinking.ParseSuffix(req.Model).ModelName
isCompat, errExpand := e.expandCodexResponsesCompaction(auth, &req, &opts, baseModel)
if errExpand != nil {
return resp, statusErr{code: http.StatusBadRequest, msg: errExpand.Error()}
}
if !codexCompactionSummaryFromContext(ctx) && e.shouldCompactCompatResponsesTrigger(isCompat, req, opts) {
return e.executeCodexResponsesCompaction(ctx, auth, req, opts)
}
if errPrev := rejectSyntheticCompactionPreviousResponseID(ctx, req.Payload); errPrev != nil {
return resp, errPrev
}
apiKey, baseURL := codexCredsForRequest(ctx, auth, opts.Headers)
if errSIWC := ensureCodexSIWCCredentialsForRequest(ctx, auth, apiKey, opts.Headers); errSIWC != nil {
return resp, errSIWC
}
if baseURL == "" {
baseURL = "https://chatgpt.com/backend-api/codex"
}
reporter := helps.NewExecutorUsageReporter(ctx, e, baseModel, auth)
defer reporter.TrackFailure(ctx, &err)
from := opts.SourceFormat
responseFormat := cliproxyexecutor.ResponseFormatOrSource(opts)
to := sdktranslator.FromString("codex")
originalPayloadSource := req.Payload
if len(opts.OriginalRequest) > 0 {
originalPayloadSource = opts.OriginalRequest
}
originalPayload := originalPayloadSource
targetModel := resolveResponsesSignatureTargetModel(baseModel, req, opts)
originalTranslated, body, updatesChanged, err := translateCodexRequestPairWithUpdateIntentContext(ctx, from, to, targetModel, originalPayload, req.Payload, false, isCompat)
if err != nil {
return resp, err
}
originalTranslated = helps.SetStringIfDifferent(originalTranslated, "model", baseModel)
doc := ojson.NewDoc(body)
normalizeCodexOutputBudgetDoc(doc)
helps.SetStringIfDifferentDoc(doc, "model", baseModel)
if err = helps.ApplyRequestThinkingDoc(doc, req, opts, from.String(), to.String(), e.Identifier(), updatesChanged); err != nil {
return resp, err
}
ctx = helps.WithPayloadFinalizer(ctx, helps.NewPayloadFinalizer(e.cfg, e.Identifier(), baseModel, to.String(), "", originalTranslated, req, opts, auth))
helps.SetStringIfDifferentDoc(doc, "model", baseModel)
helps.SetBoolIfDifferentDoc(doc, "stream", true)
_ = doc.Delete("previous_response_id")
_ = doc.Delete("generate")
_ = doc.Delete("prompt_cache_retention")
_ = doc.Delete("safety_identifier")
_ = doc.Delete("stream_options")
useSIWC := codexUseSIWCForRequest(ctx, auth, opts.Headers)
instructionsResult := ojson.GetBytesNoCopy(req.Payload, "instructions")
hasExplicitInstructions := instructionsResult.Exists() && strings.TrimSpace(instructionsResult.String()) != ""
isCompactionSummary := codexCompactionSummaryFromContext(ctx)
if !isCompactionSummary {
ensureWebSearchToolForHistoryDoc(doc, opts.Headers)
}
if !useSIWC {
normalizeCodexInstructionsDoc(doc, helps.IsNativeCodexRequest(req.Payload, opts))
if !isCompactionSummary && (e.cfg == nil || e.cfg.DisableImageGeneration == config.DisableImageGenerationOff) {
checkModel := req.Model
if strings.TrimSpace(checkModel) == "" {
checkModel = baseModel
}
ensureImageGenerationToolDoc(doc, checkModel, auth, opts.Headers)
if !codexAuthUsesAPIKey(auth) {
normalizeCodexImageGenerationToolsDoc(doc)
}
}
} else {
applyCodexSIWCRequestBodyRulesDoc(doc, hasExplicitInstructions, cliproxyexecutor.Options{KeepTopLevelEffort: thinking.HasThinkingSuffix(req.Model)})
}
normalizeCodexParallelToolCallsDoc(doc, opts.Headers)
helps.NormalizeCodexToolSchemasDoc(doc)
optimizeMultiAgentV2 := helps.OptimizeCodexMultiAgentV2RequestForAuthDoc(doc, ctx, opts.Headers, e.cfg, auth, isCompat)
replayScope, _, errReplay := applyCodexReasoningReplayCacheRequiredDoc(ctx, from, req, opts, doc)
if errReplay != nil {
return resp, errReplay
}
sanitizeOpenAIResponsesReasoningEncryptedContentWithCompatModelAndBaseURLDoc(ctx, "codex executor", doc, isCompat, targetModel, baseURL)
url := strings.TrimSuffix(baseURL, "/") + "/responses"
httpReq, upstreamBody, err := e.cacheHelperDoc(ctx, from, url, req, doc, auth, opts.Headers)
if err != nil {
return resp, err
}
body = upstreamBody
upstreamModel := strings.TrimSpace(doc.Get("model").String())
if upstreamModel != "" && upstreamModel != baseModel {
reporter.SetUpstreamModel(upstreamModel)
}
reporter.SetTranslatedReasoningEffort(upstreamBody, to.String())
prepareHeaders := func(request *http.Request) {
applyCodexHeaders(request, auth, apiKey, true, e.cfg, opts.Headers)
applyCodexRoutingHint(ctx, request.Header, auth, upstreamModel, upstreamBody, opts.Headers)
applyModelHeaderOverrides(request.Header, upstreamModel)
alignCodexContentEncoding(request)
}
prepareHeaders(httpReq)
if errValidate := helps.ValidateCodexHostedImageGenerationDoc(doc, httpReq.Header, e.cfg, !useSIWC && !codexAuthUsesAPIKey(auth)); errValidate != nil {
return resp, errValidate
}
var authID, authLabel, authType, authValue string
if auth != nil {
authID = auth.ID
authLabel = auth.Label
authType, authValue = auth.AccountInfo()
}
helps.RecordAPIRequest(ctx, e.cfg, helps.UpstreamRequestLog{
URL: url,
Method: http.MethodPost,
Headers: httpReq.Header.Clone(),
Body: upstreamBody,
Provider: e.Identifier(),
AuthID: authID,
AuthLabel: authLabel,
AuthType: authType,
AuthValue: authValue,
})
httpClient := helps.NewUtlsHTTPClient(ctx, e.cfg, auth, 0)
httpClient = reporter.TrackHTTPClient(httpClient)
httpResp, err := doCodexRequest(httpClient, httpReq, upstreamBody, prepareHeaders, nil)
if err != nil {
helps.RecordAPIResponseError(ctx, e.cfg, err)
return resp, err
}
defer func() {
if errClose := httpResp.Body.Close(); errClose != nil {
log.Errorf("codex executor: close response body error: %v", errClose)
}
}()
helps.RecordAPIResponseMetadata(ctx, e.cfg, httpResp.StatusCode, httpResp.Header.Clone())
if httpResp.StatusCode < 200 || httpResp.StatusCode >= 300 {
b, errRead := io.ReadAll(httpResp.Body)
helps.AppendAPIResponseChunk(ctx, e.cfg, b)
if errRead != nil {
helps.RecordAPIResponseError(ctx, e.cfg, errRead)
}
if errClearReplay := clearCodexReasoningReplayOnInvalidSignature(ctx, replayScope, httpResp.StatusCode, b); errClearReplay != nil {
return resp, errClearReplay
}
helps.LogWithRequestID(ctx).Debugf("request error, error status: %d, error message: %s", httpResp.StatusCode, helps.SummarizeErrorBody(httpResp.Header.Get("Content-Type"), b))
err = newCodexStatusErrWithHeadersAndCooling(httpResp.StatusCode, httpResp.Header, b, e.modelLevelCooling())
return resp, err
}
data, errRead := io.ReadAll(httpResp.Body)
helps.AppendAPIResponseChunk(ctx, e.cfg, data)
events := helps.NewCodexSSEScanner(ctx, bytes.NewReader(data), len(data)+1)
outputItemsByIndex := make(map[int64][]byte)
var outputItemsFallback [][]byte
sawOutputDelta := false
for events.Scan() {
line := events.Bytes()
if !bytes.HasPrefix(line, dataTag) {
continue
}
eventData := bytes.TrimSpace(line[5:])
eventData = helps.RestoreCodexMultiAgentV2Response(eventData, optimizeMultiAgentV2)
reporter.ObserveResponseModel(eventData)
eventType := ojson.GetBytesNoCopy(eventData, "type").String()
if helps.HasMeaningfulCodexOutputDelta(eventData) {
sawOutputDelta = true
}
if streamErr, terminalBody, ok := codexTerminalFailureErrWithCooling(eventData, e.modelLevelCooling()); ok {
if errClearReplay := clearCodexReasoningReplayOnInvalidSignature(ctx, replayScope, streamErr.StatusCode(), terminalBody); errClearReplay != nil {
if detail, hasDetail := helps.ParseCodexUsageWithOutputItems(eventData, outputItemsByIndex, outputItemsFallback); hasDetail {
reporter.PublishFailureWithDetail(ctx, detail, errClearReplay)
}
return resp, errClearReplay
}
err = streamErr
if detail, hasDetail := helps.ParseCodexUsageWithOutputItems(eventData, outputItemsByIndex, outputItemsFallback); hasDetail {
reporter.PublishFailureWithDetail(ctx, detail, err)
}
return resp, err
}
if eventType == "response.output_item.done" {
itemResult := ojson.GetBytesNoCopy(eventData, "item")
if !itemResult.Exists() || itemResult.Type != ojson.JSON {
continue
}
outputIndexResult := ojson.GetBytesNoCopy(eventData, "output_index")
if outputIndexResult.Exists() {
outputItemsByIndex[outputIndexResult.Int()] = []byte(itemResult.Raw)
} else {
outputItemsFallback = append(outputItemsFallback, []byte(itemResult.Raw))
}
continue
}
if eventType != "response.completed" && eventType != "response.incomplete" {
continue
}
if helps.IsCodexTerminalEmptyIncomplete(eventData, len(outputItemsByIndex)+len(outputItemsFallback), sawOutputDelta) {
err = newCodexEmptyIncompleteStreamError()
if detail, hasDetail := helps.ParseCodexUsageWithOutputItems(eventData, outputItemsByIndex, outputItemsFallback); hasDetail {
reporter.PublishFailureWithDetail(ctx, detail, err)
}
return resp, err
}
completedData := patchCodexCompletedOutput(eventData, outputItemsByIndex, outputItemsFallback)
if eventType == "response.completed" {
cacheCodexReasoningReplayFromCompleted(replayScope, completedData)
}
var param any
out := sdktranslator.TranslateNonStream(ctx, to, responseFormat, req.Model, originalPayload, body, completedData, &param)
if helps.ApplyPatchTranslationError(param) != nil || len(out) == 0 {
return cliproxyexecutor.Response{}, statusErr{code: http.StatusBadGateway, msg: helps.ApplyPatchUpstreamErrorMessage}
}
detail, hasDetail := helps.ParseCodexUsageWithOutputItems(completedData, outputItemsByIndex, outputItemsFallback)
if responseFormat == sdktranslator.FormatOpenAIResponse {
out = helps.EnsureResponsesUsageDetails(out)
}
if summaryState := codexCompactionSummaryStateFromContext(ctx); summaryState != nil {
if eventType == "response.incomplete" {
err = statusErr{code: http.StatusBadGateway, msg: "compaction summary response status is \"incomplete\", want \"completed\""}
if hasDetail {
reporter.PublishFailureWithDetail(ctx, detail, err)
} else {
reporter.PublishFailure(ctx, err)
}
return cliproxyexecutor.Response{}, err
}
compactedPayload, errBuild := helps.BuildResponsesCompactionResponseFromSummary(summaryState.baseModel, out)
if errBuild != nil {
err = statusErr{code: http.StatusBadGateway, msg: errBuild.Error()}
if hasDetail {
reporter.PublishFailureWithDetail(ctx, detail, err)
} else {
reporter.PublishFailure(ctx, err)
}
return cliproxyexecutor.Response{}, err
}
if hasDetail {
reporter.Publish(ctx, detail)
} else {
reporter.EnsurePublished(ctx)
}
publishCodexImageToolUsageWithOutputItems(ctx, reporter, body, completedData, outputItemsByIndex, outputItemsFallback)
resp = cliproxyexecutor.Response{Payload: compactedPayload, Headers: httpResp.Header.Clone()}
return resp, nil
}
if hasDetail {
reporter.Publish(ctx, detail)
}
publishCodexImageToolUsageWithOutputItems(ctx, reporter, body, completedData, outputItemsByIndex, outputItemsFallback)
resp = cliproxyexecutor.Response{Payload: out, Incomplete: eventType == "response.incomplete", Headers: httpResp.Header.Clone()}
return resp, nil
}
if errRead != nil {
if errCtx := ctx.Err(); errCtx != nil {
helps.RecordAPIResponseError(ctx, e.cfg, errCtx)
err = errCtx
return resp, err
}
helps.RecordAPIResponseError(ctx, e.cfg, errRead)
}
err = newCodexIncompleteStreamError()
return resp, err
}
func (e *CodexExecutor) executeCodexResponsesCompaction(ctx context.Context, auth *cliproxyauth.Auth, req cliproxyexecutor.Request, opts cliproxyexecutor.Options) (cliproxyexecutor.Response, error) {
var resp cliproxyexecutor.Response
sourcePayload := helps.ResponsesCompactionSourcePayload(req, opts)
if errValidate := validateCodexLocalCompactionSource(ctx, sourcePayload); errValidate != nil {
return resp, errValidate
}
baseModel := thinking.ParseSuffix(req.Model).ModelName
summaryPayload := helps.PrepareAntigravityCompactionSummaryPayload(sourcePayload, baseModel)
summaryReq := req
summaryReq.Payload = summaryPayload
summaryOpts := opts
summaryOpts.Alt = ""
summaryOpts.Stream = false
summaryOpts.OriginalRequest = nil
summaryOpts.SourceFormat = sdktranslator.FormatOpenAIResponse
summaryOpts.ResponseFormat = sdktranslator.FormatOpenAIResponse
return e.Execute(withCodexCompactionSummary(ctx, baseModel), auth, summaryReq, summaryOpts)
}
func (e *CodexExecutor) executeCodexResponsesCompactionStream(ctx context.Context, auth *cliproxyauth.Auth, req cliproxyexecutor.Request, opts cliproxyexecutor.Options) (*cliproxyexecutor.StreamResult, error) {
cliproxyexecutor.MarkLocalWebsocketTurn(ctx)
baseModel := thinking.ParseSuffix(req.Model).ModelName
summaryResp, errSummary := e.executeCodexResponsesCompaction(ctx, auth, req, opts)
if errSummary != nil {
return nil, errSummary
}
chunks, errChunks := helps.BuildResponsesCompactionStreamChunksFromResponse(baseModel, summaryResp.Payload)
if errChunks != nil {
return nil, statusErr{code: http.StatusBadGateway, msg: errChunks.Error()}
}
out := make(chan cliproxyexecutor.StreamChunk, len(chunks))
for _, chunk := range chunks {
out <- cliproxyexecutor.StreamChunk{Payload: chunk}
}
close(out)
headers := summaryResp.Headers.Clone()
if headers == nil {
headers = make(http.Header)
}
headers.Set("Content-Type", "text/event-stream")
return &cliproxyexecutor.StreamResult{Headers: headers, Chunks: out}, nil
}
func (e *CodexExecutor) executeCompact(ctx context.Context, auth *cliproxyauth.Auth, req cliproxyexecutor.Request, opts cliproxyexecutor.Options) (resp cliproxyexecutor.Response, err error) {
if errExpand := helps.ExpandRecognizedResponsesCompactionCapsules(&req, &opts); errExpand != nil {
return resp, statusErr{code: http.StatusBadRequest, msg: errExpand.Error()}
}
baseModel := thinking.ParseSuffix(req.Model).ModelName
apiKey, baseURL := codexCredsForRequest(ctx, auth, opts.Headers)
if errSIWC := ensureCodexSIWCCredentialsForRequest(ctx, auth, apiKey, opts.Headers); errSIWC != nil {
return resp, errSIWC
}
if baseURL == "" {
baseURL = "https://chatgpt.com/backend-api/codex"
}
reporter := helps.NewExecutorUsageReporter(ctx, e, baseModel, auth)
defer reporter.TrackFailure(ctx, &err)
from := opts.SourceFormat
responseFormat := cliproxyexecutor.ResponseFormatOrSource(opts)
to := sdktranslator.FromString("openai-response")
originalPayloadSource := req.Payload
if len(opts.OriginalRequest) > 0 {
originalPayloadSource = opts.OriginalRequest
}
originalPayload := originalPayloadSource
isCompat := e.resolveCodexModelIsCompat(auth, req, baseModel)
targetModel := resolveResponsesSignatureTargetModel(baseModel, req, opts)
originalTranslated, body, updatesChanged, err := translateCodexRequestPairWithUpdateIntentContext(ctx, from, to, targetModel, originalPayload, req.Payload, false, isCompat)
if err != nil {
return resp, err
}
originalTranslated = helps.SetStringIfDifferent(originalTranslated, "model", baseModel)
doc := ojson.NewDoc(body)
if err = helps.ApplyRequestThinkingDoc(doc, req, opts, from.String(), to.String(), e.Identifier(), updatesChanged); err != nil {
return resp, err
}
ctx = helps.WithPayloadFinalizer(ctx, helps.NewPayloadFinalizer(e.cfg, e.Identifier(), baseModel, to.String(), "", originalTranslated, req, opts))
helps.SetStringIfDifferentDoc(doc, "model", baseModel)
_ = doc.Delete("stream")
if !codexUseSIWCForRequest(ctx, auth, opts.Headers) {
normalizeCodexInstructionsDoc(doc, helps.IsNativeCodexRequest(req.Payload, opts))
} else {
instructionsResult := ojson.GetBytesNoCopy(req.Payload, "instructions")
hasExplicitInstructions := instructionsResult.Exists() && strings.TrimSpace(instructionsResult.String()) != ""
applyCodexSIWCCompactBodyRulesDoc(doc, hasExplicitInstructions, cliproxyexecutor.Options{KeepTopLevelEffort: thinking.HasThinkingSuffix(req.Model)})
}
ensureWebSearchToolForHistoryDoc(doc, opts.Headers)
sanitizeOpenAIResponsesReasoningEncryptedContentWithCompatModelAndBaseURLDoc(ctx, "codex executor", doc, isCompat, resolveResponsesSignatureTargetModel(baseModel, req, opts), baseURL)
normalizeCodexParallelToolCallsDoc(doc, opts.Headers)
helps.NormalizeCodexToolSchemasDoc(doc)
optimizeMultiAgentV2 := helps.OptimizeCodexMultiAgentV2RequestForAuthDoc(doc, ctx, opts.Headers, e.cfg, auth, isCompat)
url := strings.TrimSuffix(baseURL, "/") + "/responses/compact"
httpReq, upstreamBody, err := e.cacheHelperDoc(ctx, from, url, req, doc, auth, opts.Headers)
if err != nil {
return resp, err
}
body = upstreamBody
reporter.SetTranslatedReasoningEffort(upstreamBody, to.String())
prepareHeaders := func(request *http.Request) {
applyCodexHeaders(request, auth, apiKey, false, e.cfg, opts.Headers)
applyCodexRoutingHint(ctx, request.Header, auth, baseModel, upstreamBody, opts.Headers)
applyModelHeaderOverrides(request.Header, baseModel)
alignCodexContentEncoding(request)
}
prepareHeaders(httpReq)
var authID, authLabel, authType, authValue string
if auth != nil {
authID = auth.ID
authLabel = auth.Label
authType, authValue = auth.AccountInfo()
}
helps.RecordAPIRequest(ctx, e.cfg, helps.UpstreamRequestLog{
URL: url,
Method: http.MethodPost,
Headers: httpReq.Header.Clone(),
Body: upstreamBody,
Provider: e.Identifier(),
AuthID: authID,
AuthLabel: authLabel,
AuthType: authType,
AuthValue: authValue,
})
httpClient := helps.NewUtlsHTTPClient(ctx, e.cfg, auth, 0)
httpClient = reporter.TrackHTTPClient(httpClient)
httpResp, err := doCodexRequest(httpClient, httpReq, upstreamBody, prepareHeaders, nil)
if err != nil {
helps.RecordAPIResponseError(ctx, e.cfg, err)
return resp, err
}
defer func() {
if errClose := httpResp.Body.Close(); errClose != nil {
log.Errorf("codex executor: close response body error: %v", errClose)
}
}()
helps.RecordAPIResponseMetadata(ctx, e.cfg, httpResp.StatusCode, httpResp.Header.Clone())
if httpResp.StatusCode < 200 || httpResp.StatusCode >= 300 {
b, errRead := io.ReadAll(httpResp.Body)
helps.AppendAPIResponseChunk(ctx, e.cfg, b)
if errRead != nil {
helps.RecordAPIResponseError(ctx, e.cfg, errRead)
}
helps.LogWithRequestID(ctx).Debugf("request error, error status: %d, error message: %s", httpResp.StatusCode, helps.SummarizeErrorBody(httpResp.Header.Get("Content-Type"), b))
err = newCodexStatusErrWithHeadersAndCooling(httpResp.StatusCode, httpResp.Header, b, e.modelLevelCooling())
return resp, err
}
data, err := io.ReadAll(httpResp.Body)
helps.AppendAPIResponseChunk(ctx, e.cfg, data)
if err != nil {
helps.RecordAPIResponseError(ctx, e.cfg, err)
return resp, err
}
upstreamData := helps.RestoreCodexMultiAgentV2Response(data, optimizeMultiAgentV2)
var param any
out := sdktranslator.TranslateNonStream(ctx, to, responseFormat, req.Model, originalPayload, body, upstreamData, &param)
if helps.ApplyPatchTranslationError(param) != nil || len(out) == 0 {
return cliproxyexecutor.Response{}, statusErr{code: http.StatusBadGateway, msg: helps.ApplyPatchUpstreamErrorMessage}
}
reporter.Publish(ctx, helps.ParseOpenAIUsage(upstreamData))
if responseFormat == sdktranslator.FormatOpenAIResponse {
out = helps.EnsureResponsesUsageDetails(out)
}
resp = cliproxyexecutor.Response{Payload: out, Headers: httpResp.Header.Clone()}
return resp, nil
}