Something went wrong. Try again.
sloproxy
Something went wrong. Try again.
27 kB · 826 lines
Go
at commit 42eef103
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827package executor
import ( "context" "crypto/sha256" "encoding/hex" "hash" "io" "net/http" "strings"
"github.com/gin-gonic/gin" "github.com/google/uuid" internalcache "github.com/router-for-me/CLIProxyAPI/v7/internal/cache" "github.com/router-for-me/CLIProxyAPI/v7/internal/runtime/executor/helps" "github.com/router-for-me/CLIProxyAPI/v7/internal/signature" "github.com/router-for-me/CLIProxyAPI/v7/internal/thinking" "github.com/router-for-me/CLIProxyAPI/v7/internal/util" cliproxyexecutor "github.com/router-for-me/CLIProxyAPI/v7/sdk/cliproxy/executor" sdktranslator "github.com/router-for-me/CLIProxyAPI/v7/sdk/translator" "github.com/tidwall/gjson" "github.com/tidwall/sjson")
type codexReasoningReplayScope struct { modelName string sessionKey string requestFingerprint string}
func (s codexReasoningReplayScope) valid() bool { return strings.TrimSpace(s.modelName) != "" && strings.TrimSpace(s.sessionKey) != ""}
func applyCodexReasoningReplayCache(ctx context.Context, from sdktranslator.Format, req cliproxyexecutor.Request, opts cliproxyexecutor.Options, body []byte) ([]byte, codexReasoningReplayScope) { updated, scope, _ := applyCodexReasoningReplayCacheRequired(ctx, from, req, opts, body) return updated, scope}
func applyCodexReasoningReplayCacheRequired(ctx context.Context, from sdktranslator.Format, req cliproxyexecutor.Request, opts cliproxyexecutor.Options, body []byte) ([]byte, codexReasoningReplayScope, error) { scope := codexReasoningReplayScopeFromRequest(ctx, from, req, opts, body) if !scope.valid() { return body, scope, nil } items, ok, errReplay := internalcache.GetCodexReasoningReplayItemsRequired(ctx, scope.modelName, scope.sessionKey) if errReplay != nil || !ok { return body, scope, errReplay } updated, ok := insertCodexReasoningReplayTurns(body, items) if !ok { return body, scope, nil } return updated, scope, nil}
func codexReasoningReplayScopeFromRequest(ctx context.Context, from sdktranslator.Format, req cliproxyexecutor.Request, opts cliproxyexecutor.Options, body []byte) codexReasoningReplayScope { if !codexReasoningReplayEnabledForSource(from) { return codexReasoningReplayScope{} } modelName := strings.TrimSpace(gjson.GetBytes(body, "model").String()) if modelName == "" { modelName = thinking.ParseSuffix(req.Model).ModelName } inputItems := gjson.GetBytes(body, "input").Array() return codexReasoningReplayScope{ modelName: modelName, sessionKey: codexReasoningReplaySessionKey(ctx, from, req, opts, body), requestFingerprint: codexReplayInputPrefixFingerprint(inputItems, len(inputItems)), }}
func codexReasoningReplayEnabledForSource(from sdktranslator.Format) bool { return sourceFormatEqual(from, sdktranslator.FormatClaude)}
func sourceFormatEqual(from, want sdktranslator.Format) bool { return strings.EqualFold(strings.TrimSpace(from.String()), want.String())}
func codexClaudeCodeReplaySessionKey(ctx context.Context, payload []byte, headers http.Header) string { sessionKey, _ := helps.ClaudeCodeExecutionScope(ctx, payload, headers) return sessionKey}
func codexReasoningReplaySessionKey(ctx context.Context, from sdktranslator.Format, req cliproxyexecutor.Request, opts cliproxyexecutor.Options, body []byte) string { if ctx == nil { ctx = context.Background() } if sourceFormatEqual(from, sdktranslator.FormatClaude) { if sessionKey := codexClaudeCodeReplaySessionKey(ctx, req.Payload, opts.Headers); sessionKey != "" { return sessionKey } } if value := metadataString(opts.Metadata, cliproxyexecutor.ExecutionSessionMetadataKey); value != "" { return "execution:" + value } if value := metadataString(req.Metadata, cliproxyexecutor.ExecutionSessionMetadataKey); value != "" { return "execution:" + value } if value := codexReasoningReplaySessionKeyFromPayload(body); value != "" { return value } if value := codexReasoningReplaySessionKeyFromPayload(req.Payload); value != "" { return value } if value := codexReasoningReplaySessionKeyFromHeaders(opts.Headers); value != "" { return value } if ginCtx, ok := ctx.Value("gin").(*gin.Context); ok && ginCtx != nil && ginCtx.Request != nil { if value := codexReasoningReplaySessionKeyFromHeaders(ginCtx.Request.Header); value != "" { return value } } if sourceFormatEqual(from, sdktranslator.FormatOpenAI) { if apiKey := strings.TrimSpace(helps.APIKeyFromContext(ctx)); apiKey != "" { return "prompt-cache:" + uuid.NewSHA1(uuid.NameSpaceOID, []byte("cli-proxy-api:codex:prompt-cache:"+apiKey)).String() } } return ""}
func metadataString(metadata map[string]any, key string) string { if len(metadata) == 0 { return "" } raw, ok := metadata[key] if !ok || raw == nil { return "" } switch v := raw.(type) { case string: return strings.TrimSpace(v) case []byte: return strings.TrimSpace(string(v)) default: return "" }}
func codexReasoningReplaySessionKeyFromPayload(payload []byte) string { if len(payload) == 0 { return "" } if promptCacheKey := strings.TrimSpace(gjson.GetBytes(payload, "prompt_cache_key").String()); promptCacheKey != "" { return "prompt-cache:" + promptCacheKey } if windowID := strings.TrimSpace(gjson.GetBytes(payload, "client_metadata.x-codex-window-id").String()); windowID != "" { return "window:" + windowID } if turnMetadata := strings.TrimSpace(gjson.GetBytes(payload, "client_metadata.x-codex-turn-metadata").String()); turnMetadata != "" { return codexReasoningReplaySessionKeyFromTurnMetadata(turnMetadata) } return ""}
func codexReasoningReplaySessionKeyFromHeaders(headers http.Header) string { if headers == nil { return "" } if turnMetadata := strings.TrimSpace(headers.Get("X-Codex-Turn-Metadata")); turnMetadata != "" { if key := codexReasoningReplaySessionKeyFromTurnMetadata(turnMetadata); key != "" { return key } } if windowID := strings.TrimSpace(headerValueCaseInsensitive(headers, "X-Codex-Window-Id")); windowID != "" { return "window:" + windowID } for _, headerName := range []string{"Session_id", "session_id", "Session-Id"} { if value := strings.TrimSpace(headerValueCaseInsensitive(headers, headerName)); value != "" { return "session-id:" + value } } if conversationID := strings.TrimSpace(headerValueCaseInsensitive(headers, "Conversation_id")); conversationID != "" { return "conversation_id:" + conversationID } return ""}
func codexReasoningReplaySessionKeyFromTurnMetadata(turnMetadata string) string { if promptCacheKey := strings.TrimSpace(gjson.Get(turnMetadata, "prompt_cache_key").String()); promptCacheKey != "" { return "prompt-cache:" + promptCacheKey } if windowID := strings.TrimSpace(gjson.Get(turnMetadata, "window_id").String()); windowID != "" { return "window:" + windowID } return ""}
func codexInputHasValidReasoningEncryptedContent(body []byte) bool { input := gjson.GetBytes(body, "input") if !input.IsArray() { return false } for _, item := range input.Array() { if strings.TrimSpace(item.Get("type").String()) != "reasoning" { continue } encryptedContent := item.Get("encrypted_content") if encryptedContent.Type != gjson.String { continue } if _, err := signature.InspectGPTReasoningSignature(encryptedContent.String()); err == nil { return true } } return false}
type codexReasoningReplayTurn struct { marked bool assistantFingerprint string requestFingerprint string callIDs []string items [][]byte}
func insertCodexReasoningReplayTurns(body []byte, replayItems [][]byte) ([]byte, bool) { input := gjson.GetBytes(body, "input") if !input.IsArray() || len(replayItems) == 0 { return body, false } inputItems := input.Array() turns := splitCodexReasoningReplayTurns(replayItems) insertions := make(map[int][][]byte) usedAnchorIndexes := make(map[int]bool) prefixFingerprints := newCodexReplayPrefixFingerprints(inputItems) fallbackAnchorEnd := len(inputItems) - 1 inserted := false for turnIndex := len(turns) - 1; turnIndex >= 0; turnIndex-- { turn := turns[turnIndex] if len(turn.items) == 0 { continue } if !turn.marked { items := filterCodexReasoningReplayItemsForInput(body, turn.items) if len(items) == 0 { continue } index := codexReasoningReplayInsertIndex(inputItems, items) items = codexAlignReasoningReplayToolCallIDs(inputItems, items) insertions[index] = append(items, insertions[index]...) inserted = true continue }
anchorIndex, matched := codexReasoningReplayTurnAnchorIndex(inputItems, turn, fallbackAnchorEnd, usedAnchorIndexes, prefixFingerprints) if !matched { continue } usedAnchorIndexes[anchorIndex] = true if turn.requestFingerprint == "" { fallbackAnchorEnd = anchorIndex - 1 } items := filterCodexReasoningReplayTurnItems(inputItems, turn.items) if len(items) == 0 { continue } items = codexAlignReasoningReplayToolCallIDs(inputItems, items) insertions[anchorIndex] = append(items, insertions[anchorIndex]...) inserted = true } if !inserted { return body, false }
items := make([]string, 0, len(inputItems)+len(replayItems)) for index, inputItem := range inputItems { for _, replayItem := range insertions[index] { items = append(items, string(replayItem)) } items = append(items, inputItem.Raw) } for _, replayItem := range insertions[len(inputItems)] { items = append(items, string(replayItem)) } updated, err := sjson.SetRawBytes(body, "input", []byte("["+strings.Join(items, ",")+"]")) if err != nil { return body, false } return updated, true}
func splitCodexReasoningReplayTurns(items [][]byte) []codexReasoningReplayTurn { turns := make([]codexReasoningReplayTurn, 0) current := codexReasoningReplayTurn{} appendCurrent := func() { if len(current.items) > 0 { turns = append(turns, current) } } for _, item := range items { itemResult := gjson.ParseBytes(item) if strings.TrimSpace(itemResult.Get("type").String()) == internalcache.CodexReasoningReplayTurnType { appendCurrent() current = codexReasoningReplayTurn{ marked: true, assistantFingerprint: strings.TrimSpace(itemResult.Get("assistant_fingerprint").String()), requestFingerprint: strings.TrimSpace(itemResult.Get("request_fingerprint").String()), } if callIDs := itemResult.Get("call_ids"); callIDs.IsArray() { for _, callIDResult := range callIDs.Array() { if callID := strings.TrimSpace(callIDResult.String()); callID != "" { current.callIDs = append(current.callIDs, callID) } } } continue } current.items = append(current.items, item) } appendCurrent() return turns}
func codexReasoningReplayTurnAnchorIndex(inputItems []gjson.Result, turn codexReasoningReplayTurn, fallbackEnd int, used map[int]bool, prefixFingerprints *codexReplayPrefixFingerprints) (int, bool) { searchEnd := fallbackEnd if turn.requestFingerprint != "" { searchEnd = len(inputItems) - 1 } if searchEnd >= len(inputItems) { searchEnd = len(inputItems) - 1 } matchesRequestPrefix := func(index int) bool { return turn.requestFingerprint == "" || prefixFingerprints.at(index) == turn.requestFingerprint } if len(turn.callIDs) > 0 { callIDs := make(map[string]bool) for _, callID := range turn.callIDs { for _, candidate := range codexReplayComparableCallIDs(callID) { callIDs[candidate] = true } } for index := searchEnd; index >= 0; index-- { if used[index] || !matchesRequestPrefix(index) { continue } itemType := strings.TrimSpace(inputItems[index].Get("type").String()) if itemType != "function_call" && itemType != "custom_tool_call" && itemType != "function_call_output" && itemType != "custom_tool_call_output" { continue } for _, candidate := range codexReplayComparableCallIDs(inputItems[index].Get("call_id").String()) { if callIDs[candidate] { return index, true } } } } if turn.assistantFingerprint != "" { for index := searchEnd; index >= 0; index-- { if used[index] || !matchesRequestPrefix(index) { continue } if codexReplayAssistantMessageFingerprint(inputItems[index]) == turn.assistantFingerprint { return index, true } } } if len(turn.callIDs) == 0 && turn.assistantFingerprint == "" { return codexReasoningReplayInsertIndex(inputItems, turn.items), true } return 0, false}
func filterCodexReasoningReplayTurnItems(inputItems []gjson.Result, items [][]byte) [][]byte { existingReasoning := make(map[string]bool) existingCalls := make(map[string]bool) existingOutputs := make(map[string]bool) for _, inputItem := range inputItems { itemType := strings.TrimSpace(inputItem.Get("type").String()) switch itemType { case "reasoning": if encryptedContent := strings.TrimSpace(inputItem.Get("encrypted_content").String()); encryptedContent != "" { existingReasoning[encryptedContent] = true } case "function_call_output", "custom_tool_call_output": for _, candidate := range codexReplayComparableCallIDs(inputItem.Get("call_id").String()) { existingOutputs[candidate] = true } } for _, key := range codexReplayToolCallKeys(inputItem) { existingCalls[key] = true } }
filtered := make([][]byte, 0, len(items)) for _, item := range items { itemResult := gjson.ParseBytes(item) switch strings.TrimSpace(itemResult.Get("type").String()) { case "reasoning": if existingReasoning[strings.TrimSpace(itemResult.Get("encrypted_content").String())] { continue } case "function_call", "custom_tool_call": keys := codexReplayToolCallKeys(itemResult) if len(keys) == 0 || codexReplayAnyToolCallKeyExists(existingCalls, keys) { continue } hasMatchingOutput := false for _, candidate := range codexReplayComparableCallIDs(itemResult.Get("call_id").String()) { if existingOutputs[candidate] { hasMatchingOutput = true break } } if !hasMatchingOutput { continue } for _, key := range keys { existingCalls[key] = true } default: continue } filtered = append(filtered, item) } return filtered}
func codexReplayAssistantMessageFingerprint(item gjson.Result) string { itemType := strings.TrimSpace(item.Get("type").String()) if itemType != "" && itemType != "message" { return "" } if !strings.EqualFold(strings.TrimSpace(item.Get("role").String()), "assistant") { return "" } content := item.Get("content") var builder strings.Builder if content.Type == gjson.String { builder.WriteString(content.String()) } else if content.IsArray() { for _, part := range content.Array() { switch strings.TrimSpace(part.Get("type").String()) { case "input_text", "output_text": builder.WriteString(part.Get("text").String()) case "refusal": builder.WriteString("\x00refusal\x00") builder.WriteString(part.Get("refusal").String()) default: return "" } } } else { return "" } if builder.Len() == 0 { return "" } sum := sha256.Sum256([]byte(builder.String())) return hex.EncodeToString(sum[:])}
func codexReplayInputPrefixFingerprint(inputItems []gjson.Result, end int) string { if end < 0 || end > len(inputItems) { return "" } hasher := sha256.New() for index := 0; index < end; index++ { _, _ = hasher.Write([]byte("\x00item\x00")) _, _ = hasher.Write([]byte(inputItems[index].Raw)) } return hex.EncodeToString(hasher.Sum(nil))}
// codexReplayPrefixFingerprints answers codexReplayInputPrefixFingerprint queries// from one incremental hashing pass. The anchor search probes many prefixes per// turn; recomputing each prefix from scratch is O(n^2) hashing and stalled large// long-context requests for minutes before anything was sent upstream.type codexReplayPrefixFingerprints struct { items []gjson.Result hasher hash.Hash // sums[end] is the fingerprint of items[0:end]; extended lazily. sums []string}
func newCodexReplayPrefixFingerprints(items []gjson.Result) *codexReplayPrefixFingerprints { hasher := sha256.New() return &codexReplayPrefixFingerprints{ items: items, hasher: hasher, sums: []string{hex.EncodeToString(hasher.Sum(nil))}, }}
func (f *codexReplayPrefixFingerprints) at(end int) string { if end < 0 || end > len(f.items) { return "" } // Sum copies the running digest state, so absorbing one item and // snapshotting per step reproduces every prefix fingerprint exactly. for len(f.sums) <= end { next := len(f.sums) - 1 _, _ = f.hasher.Write([]byte("\x00item\x00")) _, _ = io.WriteString(f.hasher, f.items[next].Raw) f.sums = append(f.sums, hex.EncodeToString(f.hasher.Sum(nil))) } return f.sums[end]}
func filterCodexReasoningReplayItemsForInput(body []byte, items [][]byte) [][]byte { input := gjson.GetBytes(body, "input") if !input.IsArray() { return nil }
hasInputReasoning := codexInputHasValidReasoningEncryptedContent(body) existingCalls := make(map[string]bool) existingOutputs := make(map[string]bool) for _, inputItem := range input.Array() { itemType := strings.TrimSpace(inputItem.Get("type").String()) if itemType == "function_call_output" || itemType == "custom_tool_call_output" { callID := strings.TrimSpace(inputItem.Get("call_id").String()) if callID != "" { for _, candidate := range codexReplayComparableCallIDs(callID) { existingOutputs[candidate] = true } } } for _, key := range codexReplayToolCallKeys(inputItem) { existingCalls[key] = true } }
filtered := make([][]byte, 0, len(items)) for _, item := range items { itemResult := gjson.ParseBytes(item) switch strings.TrimSpace(itemResult.Get("type").String()) { case "reasoning": if hasInputReasoning { continue } case "function_call", "custom_tool_call": keys := codexReplayToolCallKeys(itemResult) if len(keys) == 0 || codexReplayAnyToolCallKeyExists(existingCalls, keys) { continue } // Only inject if there is a matching output in the request hasMatchingOutput := false callID := strings.TrimSpace(itemResult.Get("call_id").String()) if callID != "" { for _, candidate := range codexReplayComparableCallIDs(callID) { if existingOutputs[candidate] { hasMatchingOutput = true break } } } if !hasMatchingOutput { continue } for _, key := range keys { existingCalls[key] = true } default: continue } filtered = append(filtered, item) } return filtered}
func insertCodexReasoningReplayItems(body []byte, replayItems [][]byte) ([]byte, bool) { input := gjson.GetBytes(body, "input") if !input.IsArray() || len(replayItems) == 0 { return body, false } inputItems := input.Array() insertIndex := codexReasoningReplayInsertIndex(inputItems, replayItems) replayItems = codexAlignReasoningReplayToolCallIDs(inputItems, replayItems) items := make([]string, 0, len(inputItems)+len(replayItems)) for i, inputItem := range inputItems { if i == insertIndex { for _, replayItem := range replayItems { items = append(items, string(replayItem)) } } items = append(items, inputItem.Raw) } if insertIndex == len(inputItems) { for _, replayItem := range replayItems { items = append(items, string(replayItem)) } } updated, err := sjson.SetRawBytes(body, "input", []byte("["+strings.Join(items, ",")+"]")) if err != nil { return body, false } return updated, true}
func codexReasoningReplayInsertIndex(inputItems []gjson.Result, replayItems [][]byte) int { replayCallIDs := make(map[string]bool) for _, replayItem := range replayItems { itemResult := gjson.ParseBytes(replayItem) itemType := strings.TrimSpace(itemResult.Get("type").String()) if itemType != "function_call" && itemType != "custom_tool_call" { continue } for _, callID := range codexReplayComparableCallIDs(itemResult.Get("call_id").String()) { replayCallIDs[callID] = true } } if len(replayCallIDs) > 0 { for index, inputItem := range inputItems { itemType := strings.TrimSpace(inputItem.Get("type").String()) if itemType != "function_call_output" && itemType != "custom_tool_call_output" { continue } callID := strings.TrimSpace(inputItem.Get("call_id").String()) if callID == "" || replayCallIDs[callID] { return index } } } for index := len(inputItems) - 1; index >= 0; index-- { inputItem := inputItems[index] if role, ok := codexReplayMessageRole(inputItem); ok && role == "assistant" { return index } } for index, inputItem := range inputItems { if shouldInsertCodexReasoningReplayBefore(inputItem) { return index } } return len(inputItems)}
func codexAlignReasoningReplayToolCallIDs(inputItems []gjson.Result, replayItems [][]byte) [][]byte { outputCallIDs := codexReplayOutputCallIDs(inputItems) if len(outputCallIDs) == 0 { return replayItems }
aligned := make([][]byte, 0, len(replayItems)) for _, replayItem := range replayItems { itemResult := gjson.ParseBytes(replayItem) itemType := strings.TrimSpace(itemResult.Get("type").String()) if itemType != "function_call" && itemType != "custom_tool_call" { aligned = append(aligned, replayItem) continue }
callID := strings.TrimSpace(itemResult.Get("call_id").String()) outputCallID := "" for _, candidate := range codexReplayComparableCallIDs(callID) { if value := outputCallIDs[candidate]; value != "" { outputCallID = value break } } if outputCallID == "" || outputCallID == callID { aligned = append(aligned, replayItem) continue }
updated, err := sjson.SetBytes(replayItem, "call_id", outputCallID) if err != nil { aligned = append(aligned, replayItem) continue } aligned = append(aligned, updated) } return aligned}
func codexReplayOutputCallIDs(inputItems []gjson.Result) map[string]string { outputCallIDs := make(map[string]string) for _, inputItem := range inputItems { itemType := strings.TrimSpace(inputItem.Get("type").String()) if itemType != "function_call_output" && itemType != "custom_tool_call_output" { continue } callID := strings.TrimSpace(inputItem.Get("call_id").String()) if callID == "" { continue } for _, candidate := range codexReplayComparableCallIDs(callID) { outputCallIDs[candidate] = callID } } return outputCallIDs}
func shouldInsertCodexReasoningReplayBefore(item gjson.Result) bool { role, ok := codexReplayMessageRole(item) if !ok { return true } switch role { case "developer", "system": return false default: return true }}
func codexReplayMessageRole(item gjson.Result) (string, bool) { itemType := strings.TrimSpace(item.Get("type").String()) role := strings.ToLower(strings.TrimSpace(item.Get("role").String())) if role == "" || (itemType != "" && itemType != "message") { return "", false } return role, true}
func codexReplayToolCallKeys(item gjson.Result) []string { itemType := strings.TrimSpace(item.Get("type").String()) if itemType != "function_call" && itemType != "custom_tool_call" { return nil } callIDs := codexReplayComparableCallIDs(item.Get("call_id").String()) if len(callIDs) == 0 { return nil } keys := make([]string, 0, len(callIDs)) for _, callID := range callIDs { keys = append(keys, itemType+":"+callID) } return keys}
func codexReplayAnyToolCallKeyExists(existing map[string]bool, keys []string) bool { for _, key := range keys { if existing[key] { return true } } return false}
func codexReplayComparableCallIDs(callID string) []string { callID = strings.TrimSpace(callID) if callID == "" { return nil }
claudeVisibleCallID := shortenCodexReplayCallIDIfNeeded(util.SanitizeClaudeToolID(callID)) if claudeVisibleCallID == "" || claudeVisibleCallID == callID { return []string{callID} } return []string{callID, claudeVisibleCallID}}
func shortenCodexReplayCallIDIfNeeded(id string) string { const limit = 64 if len(id) <= limit { return id }
sum := sha256.Sum256([]byte(id)) suffix := "_" + hex.EncodeToString(sum[:8]) prefixLen := limit - len(suffix) if prefixLen <= 0 { return suffix[len(suffix)-limit:] } return id[:prefixLen] + suffix}
func cacheCodexReasoningReplayFromCompleted(scope codexReasoningReplayScope, completedData []byte) { if !scope.valid() { return } output := gjson.GetBytes(completedData, "response.output") if !output.IsArray() { return } replayItems := make([][]byte, 0, len(output.Array())) callIDs := make([]string, 0) assistantFingerprint := "" for _, item := range output.Array() { switch strings.TrimSpace(item.Get("type").String()) { case "reasoning": replayItems = append(replayItems, []byte(item.Raw)) case "function_call", "custom_tool_call": replayItems = append(replayItems, []byte(item.Raw)) if callID := strings.TrimSpace(item.Get("call_id").String()); callID != "" { callIDs = append(callIDs, callID) } case "message": if fingerprint := codexReplayAssistantMessageFingerprint(item); fingerprint != "" { assistantFingerprint = fingerprint } } } if len(replayItems) == 0 { return }
hasher := sha256.New() _, _ = hasher.Write([]byte(scope.requestFingerprint)) _, _ = hasher.Write([]byte("\x00assistant\x00" + assistantFingerprint)) for _, callID := range callIDs { _, _ = hasher.Write([]byte("\x00call\x00" + callID)) } for _, item := range replayItems { _, _ = hasher.Write([]byte("\x00item\x00")) _, _ = hasher.Write(item) } marker := []byte(`{"type":"` + internalcache.CodexReasoningReplayTurnType + `"}`) marker, _ = sjson.SetBytes(marker, "id", hex.EncodeToString(hasher.Sum(nil))) if assistantFingerprint != "" { marker, _ = sjson.SetBytes(marker, "assistant_fingerprint", assistantFingerprint) } if scope.requestFingerprint != "" { marker, _ = sjson.SetBytes(marker, "request_fingerprint", scope.requestFingerprint) } for _, callID := range callIDs { marker, _ = sjson.SetBytes(marker, "call_ids.-1", callID) } items := make([][]byte, 0, len(replayItems)+1) items = append(items, marker) items = append(items, replayItems...) internalcache.AppendCodexReasoningReplayItemsBestEffort(context.Background(), scope.modelName, scope.sessionKey, items)}
func clearCodexReasoningReplayOnInvalidSignature(ctx context.Context, scope codexReasoningReplayScope, statusCode int, body []byte) error { if !scope.valid() { return nil } code, _, ok := codexStatusErrorClassification(statusCode, body) if ok && code == "thinking_signature_invalid" { return internalcache.DeleteCodexReasoningReplayItemRequired(ctx, scope.modelName, scope.sessionKey) } return nil}