mirror of
https://github.com/router-for-me/CLIProxyAPI.git
synced 2026-11-16 22:57:53 +08:00
Handle compaction triggers and capsule replay locally for is-compat models while preserving native Codex behavior. Harden duplex cancellation, event ordering, response ownership, settings inheritance, model aliases, and credential failure classification. Add HTTP, streaming, duplex, handler, usage, and deterministic concurrency regression coverage. Fixes #7406
551 lines
23 KiB
Go
551 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, _ := io.ReadAll(httpResp.Body)
|
|
if errClearReplay := clearCodexReasoningReplayOnInvalidSignature(ctx, replayScope, httpResp.StatusCode, b); errClearReplay != nil {
|
|
return resp, errClearReplay
|
|
}
|
|
helps.AppendAPIResponseChunk(ctx, e.cfg, b)
|
|
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, ¶m)
|
|
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, _ := io.ReadAll(httpResp.Body)
|
|
helps.AppendAPIResponseChunk(ctx, e.cfg, b)
|
|
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)
|
|
if err != nil {
|
|
helps.RecordAPIResponseError(ctx, e.cfg, err)
|
|
return resp, err
|
|
}
|
|
helps.AppendAPIResponseChunk(ctx, e.cfg, data)
|
|
upstreamData := helps.RestoreCodexMultiAgentV2Response(data, optimizeMultiAgentV2)
|
|
var param any
|
|
out := sdktranslator.TranslateNonStream(ctx, to, responseFormat, req.Model, originalPayload, body, upstreamData, ¶m)
|
|
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
|
|
}
|