package executor import ( "bytes" "context" "fmt" "net/http" "strings" "github.com/MoeForge/moego/ojson" "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" ) type claudeCompactionSummaryContextKey struct{} // expandClaudeResponsesCompaction rewrites sealed compaction items into context // before translation. Unrecognized capsules fail the request instead of being dropped. func expandClaudeResponsesCompaction(req *cliproxyexecutor.Request, opts *cliproxyexecutor.Options) error { return helps.ExpandResponsesCompactionCapsules(req, opts, "claude") } func dropForeignClaudeCompactionItems(payload []byte) []byte { return helps.DropForeignResponsesCompactionItems(payload, "claude") } func claudeResponsesCompactionRequested(req cliproxyexecutor.Request, opts cliproxyexecutor.Options) bool { return opts.Alt == "responses/compact" || helps.HasResponsesCompactionTriggerRequest(req, opts) } func claudeCompactionSourcePayload(req cliproxyexecutor.Request, opts cliproxyexecutor.Options) []byte { return helps.ResponsesCompactionSourcePayload(req, opts) } func (e *ClaudeExecutor) executeClaudeCompaction(ctx context.Context, auth *cliproxyauth.Auth, req cliproxyexecutor.Request, opts cliproxyexecutor.Options) (cliproxyexecutor.Response, error) { var resp cliproxyexecutor.Response baseModel := thinking.ParseSuffix(req.Model).ModelName summaryPayload := prepareClaudeCompactionSummaryPayload(claudeCompactionSourcePayload(req, opts), baseModel) summaryReq := cliproxyexecutor.Request{ Model: req.Model, Payload: summaryPayload, Metadata: req.Metadata, } summaryOpts := opts summaryOpts.Alt = "" summaryOpts.Stream = false summaryOpts.OriginalRequest = nil summaryOpts.SourceFormat = sdktranslator.FormatOpenAIResponse summaryOpts.ResponseFormat = sdktranslator.FormatClaude summaryResp, errSummary := e.Execute(withClaudeCompactionSummary(ctx), auth, summaryReq, summaryOpts) if errSummary != nil { return resp, errSummary } summaryText, errExtract := helps.ExtractAntigravitySummaryText(summaryResp.Payload) if errExtract != nil { return resp, fmt.Errorf("extract summary: %w", errExtract) } capsule, errSeal := helps.SealAntigravityCompaction(summaryText, baseModel) if errSeal != nil { return resp, fmt.Errorf("seal compaction capsule: %w", errSeal) } inputTokens, outputTokens, totalTokens, cachedTokens := claudeCompactionResponsesUsage(summaryResp.Payload) respPayload := helps.BuildAntigravityCompactionResponse(baseModel, capsule, inputTokens, outputTokens, totalTokens) respPayload, _ = ojson.SetBytes(respPayload, "usage.input_tokens_details.cached_tokens", cachedTokens) return cliproxyexecutor.Response{ Payload: respPayload, Headers: summaryResp.Headers, }, nil } func (e *ClaudeExecutor) executeClaudeCompactionStream(ctx context.Context, auth *cliproxyauth.Auth, req cliproxyexecutor.Request, opts cliproxyexecutor.Options) (*cliproxyexecutor.StreamResult, error) { baseModel := thinking.ParseSuffix(req.Model).ModelName summaryResp, errSummary := e.executeClaudeCompaction(ctx, auth, req, opts) if errSummary != nil { return nil, errSummary } // Reuse the capsule and usage already sealed for the non-stream response. item := ojson.GetBytesNoCopy(summaryResp.Payload, "output.0") capsule := item.Get("encrypted_content").String() if item.Get("type").String() != "compaction" || capsule == "" { return nil, fmt.Errorf("extract summary: compaction item missing") } inputTokens := int(ojson.GetBytesNoCopy(summaryResp.Payload, "usage.input_tokens").Int()) outputTokens := int(ojson.GetBytesNoCopy(summaryResp.Payload, "usage.output_tokens").Int()) totalTokens := int(ojson.GetBytesNoCopy(summaryResp.Payload, "usage.total_tokens").Int()) cachedTokens := int(ojson.GetBytesNoCopy(summaryResp.Payload, "usage.input_tokens_details.cached_tokens").Int()) chunks := helps.BuildAntigravityCompactionStreamChunks(baseModel, capsule, inputTokens, outputTokens, totalTokens) for i := range chunks { chunks[i] = patchClaudeCompactionStreamUsage(chunks[i], inputTokens, outputTokens, totalTokens, cachedTokens) } 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 withClaudeCompactionSummary(ctx context.Context) context.Context { if ctx == nil { ctx = context.Background() } return context.WithValue(ctx, claudeCompactionSummaryContextKey{}, true) } func claudeCompactionSummaryFromContext(ctx context.Context) bool { if ctx == nil { return false } flag, ok := ctx.Value(claudeCompactionSummaryContextKey{}).(bool) return ok && flag } // prepareClaudeCompactionSummaryPayload keeps tool definitions that Claude needs // in order to accept tool_use history, while still asking for a text summary. func prepareClaudeCompactionSummaryPayload(payload []byte, modelName string) []byte { tools := ojson.GetBytesNoCopy(payload, "tools") additionalTools := ojson.GetBytesNoCopy(payload, "additional_tools") doc := ojson.NewDoc(payload) helps.PrepareAntigravityCompactionSummaryPayloadDoc(doc, modelName) if tools.Exists() { _ = doc.SetRaw("tools", tools.Raw) } if additionalTools.Exists() { _ = doc.SetRaw("additional_tools", additionalTools.Raw) } return doc.Bytes() } // finalizeClaudeCompactionSummaryBody runs after built-in translation and before // user payload rules. Tool history stays structured when definitions exist, and // tool_choice none stops the summary turn from calling a tool. History without // definitions is flattened so Anthropic does not reject orphan tool blocks. func finalizeClaudeCompactionSummaryBody(body []byte) []byte { doc := ojson.NewDoc(body) if !finalizeClaudeCompactionSummaryBodyDoc(doc) { return body } return doc.Bytes() } func finalizeClaudeCompactionSummaryBodyDoc(doc *ojson.Doc) bool { if doc == nil { return false } if claudeDocHasToolDefinitions(doc) { return doc.SetRawBytes("tool_choice", []byte(`{"type":"none"}`)) == nil } return flattenClaudeToolBlocksForCompactionDoc(doc) } func claudeBodyHasToolDefinitions(body []byte) bool { tools := ojson.GetBytesNoCopy(body, "tools") return tools.IsArray() && len(tools.Array()) > 0 } func claudeDocHasToolDefinitions(doc *ojson.Doc) bool { if doc == nil { return false } tools := doc.Get("tools") return tools.IsArray() && len(tools.Array()) > 0 } func flattenClaudeToolBlocksForCompaction(body []byte) []byte { doc := ojson.NewDoc(body) if !flattenClaudeToolBlocksForCompactionDoc(doc) { return body } return doc.Bytes() } func flattenClaudeToolBlocksForCompactionDoc(doc *ojson.Doc) bool { if doc == nil { return false } messages := doc.Get("messages") if !messages.IsArray() { return false } changed := false rewritten := make([]string, 0, len(messages.Array())) for _, msg := range messages.Array() { content := msg.Get("content") if !content.IsArray() { rewritten = append(rewritten, msg.Raw) continue } parts := make([]string, 0, len(content.Array())) msgChanged := false for _, part := range content.Array() { switch part.Get("type").String() { case "tool_use": text := fmt.Sprintf("Tool call %s (%s): %s", part.Get("name").String(), part.Get("id").String(), part.Get("input").Raw) block, _ := ojson.SetBytes([]byte(`{"type":"text","text":""}`), "text", text) parts = append(parts, string(block)) msgChanged = true case "tool_result": result := part.Get("content") resultText := result.Raw if result.Type == ojson.String { resultText = result.String() } text := fmt.Sprintf("Tool result %s: %s", part.Get("tool_use_id").String(), resultText) block, _ := ojson.SetBytes([]byte(`{"type":"text","text":""}`), "text", text) parts = append(parts, string(block)) msgChanged = true default: parts = append(parts, part.Raw) } } if !msgChanged { rewritten = append(rewritten, msg.Raw) continue } changed = true updated, _ := ojson.SetRawBytes([]byte(msg.Raw), "content", []byte("["+strings.Join(parts, ",")+"]")) rewritten = append(rewritten, string(updated)) } if !changed { return false } return doc.SetRawBytes("messages", []byte("["+strings.Join(rewritten, ",")+"]")) == nil } // claudeCompactionResponsesUsage matches the Responses translator: input includes // cache creation and cache read, cached_tokens is cache read, and total is their sum. func claudeCompactionResponsesUsage(payload []byte) (inputTokens, outputTokens, totalTokens, cachedTokens int) { usage := ojson.GetBytesNoCopy(payload, "usage") if !usage.Exists() { parsed := helps.ParseOpenAIUsage(payload) return int(parsed.InputTokens), int(parsed.OutputTokens), int(parsed.TotalTokens), 0 } rawInput := int(usage.Get("input_tokens").Int()) outputTokens = int(usage.Get("output_tokens").Int()) cacheCreation := int(usage.Get("cache_creation_input_tokens").Int()) cachedTokens = int(usage.Get("cache_read_input_tokens").Int()) inputTokens = rawInput + cacheCreation + cachedTokens totalTokens = inputTokens + outputTokens return inputTokens, outputTokens, totalTokens, cachedTokens } func patchClaudeCompactionStreamUsage(chunk []byte, inputTokens, outputTokens, totalTokens, cachedTokens int) []byte { const dataPrefix = "data: " idx := bytes.Index(chunk, []byte(dataPrefix)) if idx < 0 { return chunk } data := bytes.TrimSpace(chunk[idx+len(dataPrefix):]) doc := ojson.NewDoc(data) path := "" switch { case doc.Get("response.usage").Exists(): path = "response.usage" case doc.Get("usage").Exists(): path = "usage" default: return chunk } _ = doc.Set(path+".input_tokens", inputTokens) _ = doc.Set(path+".output_tokens", outputTokens) _ = doc.Set(path+".total_tokens", totalTokens) _ = doc.Set(path+".input_tokens_details.cached_tokens", cachedTokens) var buf bytes.Buffer buf.Write(chunk[:idx]) buf.WriteString(dataPrefix) buf.Write(doc.Bytes()) buf.WriteString("\n\n") return buf.Bytes() }