package 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 {

Lines 1–500 of 826. Load more