mirror of
https://github.com/router-for-me/CLIProxyAPI.git
synced 2026-11-19 16:29:45 +08:00
Move Claude prompt-cache stripping before payload finalization so user-injected values survive, and extract count-tokens betas only after finalization without changing business semantics. Capture Codex instructions and xAI transcript input before payload rules for duplex, replay, and compaction inheritance, and reuse the exact finalized xAI websocket frame on retries. This prevents rules from being applied twice, overwritten, or accumulating across turns.
647 lines
25 KiB
Go
647 lines
25 KiB
Go
package executor
|
|
|
|
import (
|
|
"bufio"
|
|
"bytes"
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"strings"
|
|
|
|
"github.com/MoeForge/moego/ojson"
|
|
"github.com/router-for-me/CLIProxyAPI/v8/internal/clienterror"
|
|
"github.com/router-for-me/CLIProxyAPI/v8/internal/runtime/executor/helps"
|
|
"github.com/router-for-me/CLIProxyAPI/v8/internal/thinking"
|
|
"github.com/router-for-me/CLIProxyAPI/v8/internal/util"
|
|
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"
|
|
)
|
|
|
|
func (e *ClaudeExecutor) ExecuteStream(ctx context.Context, auth *cliproxyauth.Auth, req cliproxyexecutor.Request, opts cliproxyexecutor.Options) (_ *cliproxyexecutor.StreamResult, err error) {
|
|
ctx = helps.EnsureSessionContext(ctx, opts, req.Payload)
|
|
if errExpand := expandClaudeResponsesCompaction(&req, &opts); errExpand != nil {
|
|
return nil, statusErr{code: http.StatusBadRequest, msg: errExpand.Error()}
|
|
}
|
|
if claudeResponsesCompactionRequested(req, opts) {
|
|
return e.executeClaudeCompactionStream(ctx, auth, req, opts)
|
|
}
|
|
baseModel := thinking.ParseSuffix(req.Model).ModelName
|
|
upstreamModel := e.upstreamModel(baseModel)
|
|
|
|
apiKey, baseURL := claudeCreds(auth)
|
|
if baseURL == "" {
|
|
baseURL = "https://api.anthropic.com"
|
|
}
|
|
url := fmt.Sprintf("%s/v1/messages?beta=true", baseURL)
|
|
fp := resolveClaudeFingerprintPolicy(e.cfg, auth, apiKey)
|
|
defer func() {
|
|
if cancelErr := newClaudeOAuthCancellationError(ctx, fp.OAuthCancellation, err); cancelErr != nil {
|
|
err = cancelErr
|
|
}
|
|
}()
|
|
// Same split as Execute: OAuth signs everywhere, an opted-in API key only on
|
|
// upstreams the native gate accepts.
|
|
cchSigning := claudeCCHSigningEnabled(apiKey, claudeCCHUpstreamAnthropic, fp.ProfileClaudeCodeCLI, url)
|
|
|
|
reporter := helps.NewExecutorUsageReporter(ctx, e, baseModel, auth)
|
|
defer reporter.TrackFailure(ctx, &err)
|
|
if upstreamModel != baseModel {
|
|
reporter.SetUpstreamModel(upstreamModel)
|
|
}
|
|
from := opts.SourceFormat
|
|
ctx, req, opts = e.applyNativeToolSearchFallback(ctx, auth, from, upstreamModel, req, opts)
|
|
responseFormat := cliproxyexecutor.ResponseFormatOrSource(opts)
|
|
to := sdktranslator.FromString("claude")
|
|
var replayScope claudeThinkingReplayScope
|
|
if claudeThinkingReplayEnabled(auth, req, opts) {
|
|
req, replayScope = prepareClaudeThinkingReplayRequest(ctx, auth, req, opts)
|
|
}
|
|
defer func() {
|
|
if err != nil && replayScope.replayApplied && shouldClearKimiThinkingReplayAfterError(err) {
|
|
clearClaudeThinkingReplayContent(ctx, replayScope)
|
|
}
|
|
}()
|
|
originalPayloadSource := req.Payload
|
|
if len(opts.OriginalRequest) > 0 {
|
|
originalPayloadSource = opts.OriginalRequest
|
|
}
|
|
originalPayload := originalPayloadSource
|
|
incomingHeaders, claudeCodeDetection := detectIncomingClaudeCodeRequest(ctx, opts.Headers, originalPayload, false, e.cfg)
|
|
wirePolicy, wireSettings := resolveClaudeWirePolicy(e.cfg, auth, apiKey, claudeCodeDetection.Confirmed)
|
|
confirmedClaudeCode := isEffectiveConfirmedClaudeCode(claudeCodeDetection, wirePolicy)
|
|
ctx = e.pinResponsesSystemItemPlacement(ctx, auth, from, upstreamModel, wirePolicy, wireSettings)
|
|
claudeSessionID := ""
|
|
if fp.ProfileClaudeCodeCLI {
|
|
claudeSessionID = helps.ClaudeAgentSessionUUIDForRequest(incomingHeaders, originalPayload, req.Payload, confirmedClaudeCode, opts.Metadata, req.Metadata)
|
|
}
|
|
|
|
continuityCtx := &helps.ClaudeContinuityContext{}
|
|
ctx = helps.WithClaudeContinuityContext(ctx, continuityCtx)
|
|
ctx = helps.WithIncomingHeaders(ctx, incomingHeaders)
|
|
ctx = helps.WithClaudeExecutionMetadata(ctx, helps.ClaudeRequestHasExecutionMetadata(opts.Metadata, req.Metadata))
|
|
if claudeSessionID != "" {
|
|
ctx = helps.WithClaudeSessionID(ctx, claudeSessionID)
|
|
}
|
|
|
|
webSearchSessionKey, webSearchTTL, webSearchLimit := e.claudeWebSearchResultCacheScope(ctx, auth, from, req, opts, originalPayload)
|
|
ctx = helps.WithClaudeWebSearchResultRestore(ctx, webSearchSessionKey, webSearchTTL)
|
|
|
|
isCompat := helps.APIKeyModelIsCompat(req)
|
|
originalTranslated, body, err := helps.TranslateRequestPairReturningError(ctx, opts.Headers, e.cfg, from, to, baseModel, originalPayload, req.Payload, true, isCompat)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
doc := ojson.NewDoc(body)
|
|
helps.SetStringIfDifferentDoc(doc, "model", upstreamModel)
|
|
helps.NormalizeClaudeToolChoiceDoc(e.upstreamRequestLogProvider(), upstreamModel, doc)
|
|
|
|
if err = helps.ApplyRequestThinkingDoc(doc, req, opts, from.String(), to.String(), e.Identifier()); err != nil {
|
|
return nil, err
|
|
}
|
|
helps.RestoreClaudeWebSearchResultsContextDoc(ctx, doc, webSearchSessionKey, webSearchTTL)
|
|
if rebuildMidSystemMessageEnabled(e.cfg, auth) {
|
|
rebuildMidSystemMessagesToTopLevelDoc(doc)
|
|
}
|
|
|
|
// Apply cloaking (system prompt injection, fake user ID, sensitive word obfuscation)
|
|
// based on client type and configuration.
|
|
isProbeOrHelper := isClaudeProbeOrHelperRequestDoc(doc)
|
|
explicitCacheMode := isExplicitPromptCacheModeDoc(doc, originalPayload, req.Payload)
|
|
if explicitCacheMode {
|
|
ctx = withExplicitPromptCacheMode(ctx, true)
|
|
}
|
|
var cloaked bool
|
|
cloaked, _, err = applyCloakingInternalDoc(
|
|
ctx,
|
|
e.cfg,
|
|
auth,
|
|
doc,
|
|
apiKey,
|
|
confirmedClaudeCode,
|
|
cchSigning,
|
|
false,
|
|
explicitCacheMode,
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
// Only the Messages endpoint on Anthropic itself was captured; count_tokens
|
|
// keeps its own shape and other gateways never see this field.
|
|
diagnosticsState := claudeDiagnosticsRequestState{}
|
|
if !isProbeOrHelper {
|
|
isProbeOrHelper = isClaudeProbeOrHelperRequestDoc(doc)
|
|
}
|
|
if continuityCtx.Initialized {
|
|
diagnosticsState = claudeDiagnosticsRequestState{
|
|
key: continuityCtx.Key,
|
|
sequence: continuityCtx.Sequence,
|
|
promptID: continuityCtx.PromptID,
|
|
}
|
|
}
|
|
contextManagementState := claudeCodeContextManagementState{
|
|
eligible: cloaked && isAnthropicUpstreamBase(baseURL),
|
|
callerOwned: doc.Get("context_management").Exists(),
|
|
}
|
|
if contextManagementState.eligible {
|
|
contextManagementState.automaticallyInjected = injectClaudeCodeContextManagementDoc(doc)
|
|
if fp.InjectDiagnostics && !isProbeOrHelper {
|
|
if continuityCtx.Initialized {
|
|
diagnosticsState = injectClaudeDiagnosticsWithStateDoc(doc, continuityCtx.Key, continuityCtx.Sequence, continuityCtx.PreviousMessageID, continuityCtx.PromptID)
|
|
} else {
|
|
diagnosticsState = injectClaudeDiagnosticsDoc(doc, auth, claudeSessionID)
|
|
}
|
|
}
|
|
}
|
|
|
|
ensureModelMaxTokensDoc(doc, baseModel)
|
|
|
|
// Disable thinking if tool_choice forces tool use (Anthropic API constraint)
|
|
disableThinkingIfToolChoiceForcedDoc(doc)
|
|
reconcileClaudeCodeContextManagementDoc(doc, contextManagementState)
|
|
normalizeClaudeSamplingForUpstreamDoc(doc, confirmedClaudeCode)
|
|
|
|
// Default cache_control for translated entrypoints (Responses/Chat/Gemini) and other
|
|
// non-native callers. Confirmed native Claude Code owns its marker placement and must
|
|
// not be rewritten. Cloaked requests always run section-independent ensure so cloaking's
|
|
// first-user marker cannot suppress system/latest-user breakpoints.
|
|
// cloaked and confirmedClaudeCode are mutually exclusive: resolveClaudeWirePolicy
|
|
// forces Cloak off for a confirmed native client.
|
|
cpaOwnsCacheControl := shouldEnsureCacheControlDoc(doc, cloaked, confirmedClaudeCode, originalPayload, req.Payload)
|
|
if cpaOwnsCacheControl {
|
|
ensureCacheControlDoc(doc)
|
|
}
|
|
|
|
// Enforce Anthropic's cache_control block limit (max 4 breakpoints per request).
|
|
// Cloaking and ensureCacheControl may push the total over 4 when the client
|
|
// already sends multiple cache_control blocks.
|
|
enforceCacheControlLimitDoc(doc, 4)
|
|
|
|
// Native selects the 1h cache pool only for OAuth credentials and pairs it with
|
|
// extended-cache-ttl-2025-04-11, which claudeCodeCLIBetas emits on exactly the
|
|
// same credential condition. Upgrading after placement is settled mirrors the
|
|
// native ttl helper.
|
|
//
|
|
// This runs only while CPA owns placement, and it then owns the ttl of every
|
|
// breakpoint it can reach: a marker carrying no ttl is the wire default, not an
|
|
// opt-in to 5m, so a cloaked caller's bare {"type":"ephemeral"} is upgraded too.
|
|
// Only a ttl the caller wrote out explicitly survives, because
|
|
// upgradeClaudeCacheControlTTL skips any block that already has one.
|
|
// claude-code-cli fingerprint profiles emit extended-cache-ttl and must use the same 1h pool.
|
|
// In native Claude Code, subagents default to 5m unless 1h is explicitly configured;
|
|
// probes omit both 1h cache and extended-cache-ttl.
|
|
isSubagent := isClaudeSubagentRequestDoc(incomingHeaders, doc)
|
|
subagent1h := isSubagent && claudeSubagentRequests1hDoc(incomingHeaders, doc)
|
|
if cpaOwnsCacheControl && fp.ProfileClaudeCodeCLI && (!isSubagent || subagent1h) && !isProbeOrHelper {
|
|
upgradeClaudeCacheControlTTLDoc(doc, claudeCacheControlTTL1h)
|
|
} else if (isProbeOrHelper || (isSubagent && !subagent1h)) && !explicitCacheMode {
|
|
stripClaudeCacheControlTTLDoc(doc)
|
|
}
|
|
|
|
// Normalize TTL values to prevent ordering violations under prompt-caching-scope-2026-01-05.
|
|
if !explicitCacheMode {
|
|
normalizeCacheControlTTLDoc(doc)
|
|
}
|
|
|
|
// Extract betas from body and convert to header
|
|
var extraBetas []string
|
|
var oauthToolNamesReverseMap map[string]string
|
|
if fp.MCPAlias && cloaked {
|
|
mcpAliases := resolveClaudeMCPAliasOptions(ctx, opts.Metadata, req.Metadata)
|
|
oauthToolNamesReverseMap, err = e.prepareClaudeOAuthToolNamesForRequestDoc(doc, mcpAliases)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
helps.NormalizeClaudeToolPropertyNamesDoc(doc)
|
|
sanitizeClaudeMessagesForClaudeUpstreamWithDebugDoc(ctx, doc, baseModel, helps.APIKeyModelIsCompat(req))
|
|
if fp.ApplyCLIIdentity {
|
|
err = applyClaudeCLIIdentityDoc(doc, auth, apiKey, url, claudeSessionID, fp.SynthesizeIdentity)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
if cloaked {
|
|
if matcher := wireSettings.buildSensitiveWordMatcher(); matcher != nil {
|
|
helps.ObfuscateSensitiveWordsDoc(doc, matcher)
|
|
}
|
|
}
|
|
cchBilling := ""
|
|
if cchSigning {
|
|
if !claudeCodeDetection.HelperProfile || claudeBodyNeedsBillingFallbackDoc(doc) {
|
|
cchBilling = claudeCCHFallbackBillingHeaderDoc(ctx, e.cfg, doc, claudeCodeDetection.Entrypoint)
|
|
}
|
|
err = ensureClaudeBillingHeaderCCHPlaceholderDoc(doc, cchBilling)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("finalize Claude CCH: %w", err)
|
|
}
|
|
}
|
|
stripDefaultKimiClaudeCodeAttributionDoc(auth, url, fp.ProfileClaudeCodeCLI, doc)
|
|
applyClaudePreservedThinkingBindingDoc(doc)
|
|
// Keep built-in cleanup before the final user payload rules.
|
|
stripPromptCacheOptionsDoc(doc)
|
|
// User rules match the fully prepared business body and are applied only once.
|
|
touchedPayloadPaths := helps.ApplyPayloadConfigWithTrackedPathsDoc(
|
|
e.cfg, baseModel, to.String(), from.String(), "", doc, stripTranslatedDefaultMaxTokens(from, originalPayload, originalTranslated),
|
|
helps.PayloadRequestedModel(opts, req.Model), helps.PayloadRequestPath(opts), opts.Headers,
|
|
"diagnostics", "betas",
|
|
)
|
|
if touchedPayloadPaths["diagnostics"] {
|
|
diagnosticsState = claudeDiagnosticsRequestState{}
|
|
}
|
|
extraBetas, _ = extractAndRemoveBetasDoc(doc)
|
|
bodyForUpstream := doc.Bytes()
|
|
body = bodyForUpstream
|
|
bodyForTranslation := bodyForUpstream
|
|
if cchSigning {
|
|
bodyForUpstream, err = signAnthropicMessagesBody(bodyForUpstream)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("sign Claude CCH: %w", err)
|
|
}
|
|
}
|
|
// Read-only validation must observe the final configured model and messages.
|
|
if errMidSystem := validateClaudeMidSystemMessageModel(bodyForUpstream, confirmedClaudeCode, isAnthropicUpstreamBase(baseURL)); errMidSystem != nil {
|
|
return nil, errMidSystem
|
|
}
|
|
reporter.SetTranslatedReasoningEffort(bodyForUpstream, to.String())
|
|
httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(bodyForUpstream))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if errHeaders := applyClaudeHeadersWithNativeProfile(
|
|
httpReq,
|
|
auth,
|
|
apiKey,
|
|
true,
|
|
extraBetas,
|
|
bodyForUpstream,
|
|
e.cfg,
|
|
incomingHeaders,
|
|
confirmedClaudeCode && !cloaked,
|
|
claudeCodeDetection.HelperProfile,
|
|
claudeSessionID,
|
|
); errHeaders != nil {
|
|
return nil, errHeaders
|
|
}
|
|
threadBetas, errThread := e.prepareClaudeThreadBetas(ctx, httpReq, auth, bodyForUpstream, extraBetas, touchedPayloadPaths["betas"], incomingHeaders, wirePolicy.Uncloak, opts.Metadata, req.Metadata)
|
|
if errThread != nil {
|
|
return nil, errThread
|
|
}
|
|
fastRequest := isAnthropicUpstreamBase(baseURL) && claudeRequestIsFast(httpReq, bodyForUpstream)
|
|
authID, authLabel, authType, authValue := claudeAuthLogIdentity(auth)
|
|
helps.RecordAPIRequest(ctx, e.cfg, helps.UpstreamRequestLog{
|
|
URL: url,
|
|
Method: http.MethodPost,
|
|
Headers: httpReq.Header.Clone(),
|
|
Body: bodyForUpstream,
|
|
Provider: e.upstreamRequestLogProvider(),
|
|
AuthID: authID,
|
|
AuthLabel: authLabel,
|
|
AuthType: authType,
|
|
AuthValue: authValue,
|
|
})
|
|
|
|
httpClient := helps.NewUtlsHTTPClient(ctx, e.cfg, auth, 0)
|
|
httpClient = reporter.TrackHTTPClient(httpClient)
|
|
httpResp, err := doClaudeUpstreamRequest(httpClient, httpReq)
|
|
if err != nil {
|
|
helps.RecordAPIResponseError(ctx, e.cfg, err)
|
|
return nil, wrapClaudeFastRequestError(fastRequest, 0, err)
|
|
}
|
|
helps.RecordAPIResponseMetadata(ctx, e.cfg, httpResp.StatusCode, httpResp.Header.Clone())
|
|
if httpResp.StatusCode < 200 || httpResp.StatusCode >= 300 {
|
|
// Decompress error responses — pass the Content-Encoding value (may be empty)
|
|
// and let decodeResponseBody handle both header-declared and magic-byte-detected
|
|
// compression. This keeps error-path behaviour consistent with the success path.
|
|
errBody, decErr := decodeResponseBody(httpResp.Body, claudeResponseContentEncoding(httpResp.Header))
|
|
if decErr != nil {
|
|
helps.RecordAPIResponseError(ctx, e.cfg, decErr)
|
|
msg := fmt.Sprintf("failed to decode error response body: %v", decErr)
|
|
helps.LogWithRequestID(ctx).Warn(msg)
|
|
errClassified := classifyClaudeUpstreamErrorWithCooling(httpResp.StatusCode, httpResp.Header, []byte(msg), e.modelLevelCooling())
|
|
if fastRequest {
|
|
return nil, wrapClaudeFastRequestError(fastRequest, httpResp.StatusCode, errClassified)
|
|
}
|
|
return nil, errClassified
|
|
}
|
|
b, readErr := io.ReadAll(errBody)
|
|
helps.AppendAPIResponseChunk(ctx, e.cfg, b)
|
|
if readErr != nil {
|
|
helps.RecordAPIResponseError(ctx, e.cfg, readErr)
|
|
msg := fmt.Sprintf("failed to read error response body: %v", readErr)
|
|
helps.LogWithRequestID(ctx).Warn(msg)
|
|
if len(b) == 0 {
|
|
b = []byte(msg)
|
|
}
|
|
}
|
|
helps.LogWithRequestID(ctx).Debugf("request error, error status: %d, error message: %s", httpResp.StatusCode, helps.SummarizeErrorBody(httpResp.Header.Get("Content-Type"), b))
|
|
if errClose := errBody.Close(); errClose != nil {
|
|
log.Errorf("response body close error: %v", errClose)
|
|
}
|
|
if fastRequest {
|
|
return nil, newClaudeFastDirectResponseError(httpResp, b)
|
|
}
|
|
return nil, classifyClaudeUpstreamErrorWithCooling(httpResp.StatusCode, httpResp.Header, b, e.modelLevelCooling())
|
|
}
|
|
decodedBody, err := decodeResponseBody(httpResp.Body, claudeResponseContentEncoding(httpResp.Header))
|
|
if err != nil {
|
|
helps.RecordAPIResponseError(ctx, e.cfg, err)
|
|
if errClose := httpResp.Body.Close(); errClose != nil {
|
|
log.Errorf("response body close error: %v", errClose)
|
|
}
|
|
return nil, wrapClaudeFastRequestError(fastRequest, httpResp.StatusCode, err)
|
|
}
|
|
out := make(chan cliproxyexecutor.StreamChunk, 1)
|
|
go func() {
|
|
defer close(out)
|
|
defer func() {
|
|
if errClose := decodedBody.Close(); errClose != nil {
|
|
log.Errorf("response body close error: %v", errClose)
|
|
}
|
|
}()
|
|
var streamUsage helps.StreamUsageBuffer
|
|
defer streamUsage.Publish(ctx, reporter)
|
|
emitCancellation := func(cause error) bool {
|
|
cancelErr := newClaudeOAuthCancellationError(ctx, fp.OAuthCancellation, cause)
|
|
if cancelErr != nil {
|
|
helps.RecordAPIResponseError(ctx, e.cfg, cancelErr)
|
|
streamUsage.PublishFailure(ctx, reporter, cancelErr)
|
|
select {
|
|
case out <- cliproxyexecutor.StreamChunk{Err: cancelErr}:
|
|
default:
|
|
}
|
|
return true
|
|
}
|
|
c := cause
|
|
if ctx != nil && ctx.Err() != nil {
|
|
c = ctx.Err()
|
|
}
|
|
if errors.Is(c, context.Canceled) {
|
|
helps.RecordAPIResponseError(ctx, e.cfg, c)
|
|
streamUsage.PublishFailure(ctx, reporter, c)
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
emitResponseError := func(errResponse error) {
|
|
errResponse = wrapClaudeFastRequestError(fastRequest, httpResp.StatusCode, errResponse)
|
|
helps.RecordAPIResponseError(ctx, e.cfg, errResponse)
|
|
streamUsage.PublishFailure(ctx, reporter, errResponse)
|
|
select {
|
|
case out <- cliproxyexecutor.StreamChunk{Err: errResponse}:
|
|
case <-ctx.Done():
|
|
}
|
|
}
|
|
|
|
streamBody := threadBetas.StreamReader(decodedBody, func(messageID string) {
|
|
commitClaudeContinuity(diagnosticsState, messageID, helps.HeaderValueCaseInsensitive(httpResp.Header, "request-id"))
|
|
e.rememberClaudeOAuthToolAliases(body, oauthToolNamesReverseMap, messageID)
|
|
})
|
|
// If the response target is Claude, directly forward complete SSE events without translation.
|
|
if responseFormat == to {
|
|
scanner := bufio.NewScanner(streamBody)
|
|
scanner.Buffer(nil, 52_428_800) // 50MB
|
|
var event bytes.Buffer
|
|
var upstreamMessageID string
|
|
var upstreamStreamErr error
|
|
upstreamCompleted := false
|
|
flushEvent := func() bool {
|
|
if event.Len() == 0 {
|
|
return true
|
|
}
|
|
observeClaudeSSEEvent(event.Bytes(), &upstreamMessageID, &upstreamCompleted, &upstreamStreamErr)
|
|
streamUsage.ObserveClaudeSSEEvent(event.Bytes())
|
|
cloned := bytes.Clone(event.Bytes())
|
|
event.Reset()
|
|
select {
|
|
case out <- cliproxyexecutor.StreamChunk{Payload: cloned}:
|
|
return true
|
|
case <-ctx.Done():
|
|
return false
|
|
}
|
|
}
|
|
for scanner.Scan() {
|
|
line := scanner.Bytes()
|
|
helps.AppendAPIResponseChunk(ctx, e.cfg, line)
|
|
reporter.ObserveResponseModel(line)
|
|
streamUsage.ObserveClaudeStream(line)
|
|
restoredLine, errRestore := restoreClaudeOAuthToolNamesFromStreamLine(line, oauthToolNamesReverseMap)
|
|
if errRestore != nil {
|
|
emitResponseError(fmt.Errorf("restore Claude OAuth tool name from streaming response: %w", errRestore))
|
|
return
|
|
}
|
|
line = e.restoreResponseModel(restoredLine, req.Model)
|
|
event.Write(line)
|
|
event.WriteByte('\n')
|
|
if len(bytes.TrimSpace(line)) == 0 {
|
|
if !flushEvent() {
|
|
emitCancellation(ctx.Err())
|
|
return
|
|
}
|
|
if upstreamCompleted || (upstreamStreamErr != nil && !clienterror.IsClaudePolicyRefusalError(upstreamStreamErr)) {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if !flushEvent() {
|
|
emitCancellation(ctx.Err())
|
|
return
|
|
}
|
|
if !upstreamCompleted || upstreamStreamErr != nil {
|
|
if emitCancellation(scanner.Err()) {
|
|
return
|
|
}
|
|
errScan := scanner.Err()
|
|
if errScan == nil {
|
|
errScan = upstreamStreamErr
|
|
}
|
|
if errScan == nil && ctx.Err() == nil {
|
|
errScan = statusErr{code: http.StatusBadGateway, msg: "upstream stream closed before message_stop"}
|
|
}
|
|
if errScan != nil {
|
|
errScan = wrapClaudeFastRequestError(fastRequest, httpResp.StatusCode, errScan)
|
|
helps.RecordAPIResponseError(ctx, e.cfg, errScan)
|
|
streamUsage.PublishFailure(ctx, reporter, errScan)
|
|
select {
|
|
case out <- cliproxyexecutor.StreamChunk{Err: errScan}:
|
|
case <-ctx.Done():
|
|
}
|
|
return
|
|
}
|
|
}
|
|
if upstreamCompleted {
|
|
commitClaudeContinuity(diagnosticsState, upstreamMessageID, helps.HeaderValueCaseInsensitive(httpResp.Header, "request-id"))
|
|
e.rememberClaudeOAuthToolAliases(body, oauthToolNamesReverseMap, upstreamMessageID)
|
|
}
|
|
return
|
|
}
|
|
|
|
// For other formats, use translation
|
|
scanner := bufio.NewScanner(streamBody)
|
|
scanner.Buffer(nil, 52_428_800) // 50MB
|
|
var param any
|
|
helps.InitializeApplyPatchStream(ctx, to, responseFormat, req.Model, helps.ApplyPatchOriginalRequest(req, opts), bodyForTranslation, ¶m)
|
|
var upstreamMessageID string
|
|
var upstreamStreamErr error
|
|
var eventBuf bytes.Buffer
|
|
upstreamCompleted := false
|
|
for scanner.Scan() {
|
|
line := scanner.Bytes()
|
|
eventBuf.Write(line)
|
|
eventBuf.WriteByte('\n')
|
|
if len(bytes.TrimSpace(line)) == 0 {
|
|
observeClaudeSSEEvent(eventBuf.Bytes(), &upstreamMessageID, &upstreamCompleted, &upstreamStreamErr)
|
|
streamUsage.ObserveClaudeSSEEvent(eventBuf.Bytes())
|
|
eventBuf.Reset()
|
|
}
|
|
helps.AppendAPIResponseChunk(ctx, e.cfg, line)
|
|
reporter.ObserveResponseModel(line)
|
|
streamUsage.ObserveClaudeStream(line)
|
|
restoredLine, errRestore := restoreClaudeOAuthToolNamesFromStreamLine(line, oauthToolNamesReverseMap)
|
|
if errRestore != nil {
|
|
emitResponseError(fmt.Errorf("restore Claude OAuth tool name from streaming response: %w", errRestore))
|
|
return
|
|
}
|
|
line = e.restoreResponseModel(restoredLine, req.Model)
|
|
helps.RecordClaudeWebSearchResultsContext(ctx, webSearchSessionKey, line, webSearchTTL, webSearchLimit)
|
|
chunks := sdktranslator.TranslateStream(
|
|
ctx,
|
|
to,
|
|
responseFormat,
|
|
req.Model,
|
|
helps.ApplyPatchOriginalRequest(req, opts),
|
|
bodyForTranslation,
|
|
bytes.Clone(line),
|
|
¶m,
|
|
)
|
|
if responseFormat == sdktranslator.FormatOpenAIResponse && helps.ApplyPatchTranslationError(param) == nil {
|
|
for i, chunk := range chunks {
|
|
chunks[i] = helps.EnsureResponsesUsageDetails(chunk)
|
|
}
|
|
}
|
|
helps.RecordApplyPatchStreamFailure(ctx, param, reporter, statusErr{code: http.StatusBadGateway, msg: helps.ApplyPatchUpstreamErrorMessage})
|
|
for i := range chunks {
|
|
select {
|
|
case out <- cliproxyexecutor.StreamChunk{Payload: chunks[i]}:
|
|
case <-ctx.Done():
|
|
if eventBuf.Len() > 0 {
|
|
observeClaudeSSEEvent(eventBuf.Bytes(), &upstreamMessageID, &upstreamCompleted, &upstreamStreamErr)
|
|
streamUsage.ObserveClaudeSSEEvent(eventBuf.Bytes())
|
|
eventBuf.Reset()
|
|
}
|
|
if !upstreamCompleted {
|
|
emitCancellation(ctx.Err())
|
|
}
|
|
return
|
|
}
|
|
}
|
|
if helps.StopApplyPatchStream(ctx, param, reporter, out, statusErr{code: http.StatusBadGateway, msg: helps.ApplyPatchUpstreamErrorMessage}) {
|
|
return
|
|
}
|
|
if upstreamCompleted || (upstreamStreamErr != nil && !clienterror.IsClaudePolicyRefusalError(upstreamStreamErr)) {
|
|
break
|
|
}
|
|
}
|
|
if eventBuf.Len() > 0 {
|
|
observeClaudeSSEEvent(eventBuf.Bytes(), &upstreamMessageID, &upstreamCompleted, &upstreamStreamErr)
|
|
streamUsage.ObserveClaudeSSEEvent(eventBuf.Bytes())
|
|
eventBuf.Reset()
|
|
}
|
|
if helps.EndApplyPatchStream(ctx, param, reporter, out, statusErr{code: http.StatusBadGateway, msg: helps.ApplyPatchUpstreamErrorMessage}) {
|
|
return
|
|
}
|
|
if !upstreamCompleted || upstreamStreamErr != nil {
|
|
if emitCancellation(scanner.Err()) {
|
|
return
|
|
}
|
|
errScan := scanner.Err()
|
|
if errScan == nil {
|
|
errScan = upstreamStreamErr
|
|
}
|
|
if errScan == nil && ctx.Err() == nil {
|
|
errScan = statusErr{code: http.StatusBadGateway, msg: "upstream stream closed before message_stop"}
|
|
}
|
|
if errScan != nil {
|
|
errScan = wrapClaudeFastRequestError(fastRequest, httpResp.StatusCode, errScan)
|
|
helps.RecordAPIResponseError(ctx, e.cfg, errScan)
|
|
streamUsage.PublishFailure(ctx, reporter, errScan)
|
|
select {
|
|
case out <- cliproxyexecutor.StreamChunk{Err: errScan}:
|
|
case <-ctx.Done():
|
|
}
|
|
return
|
|
}
|
|
}
|
|
if upstreamCompleted {
|
|
commitClaudeContinuity(diagnosticsState, upstreamMessageID, helps.HeaderValueCaseInsensitive(httpResp.Header, "request-id"))
|
|
e.rememberClaudeOAuthToolAliases(body, oauthToolNamesReverseMap, upstreamMessageID)
|
|
}
|
|
}()
|
|
result := &cliproxyexecutor.StreamResult{Headers: httpResp.Header.Clone(), Chunks: out}
|
|
if replayScope.valid() {
|
|
result = wrapClaudeThinkingReplayStream(ctx, result, replayScope)
|
|
}
|
|
return result, nil
|
|
}
|
|
|
|
func validateClaudeStreamingResponse(data []byte) error {
|
|
scanner := bufio.NewScanner(bytes.NewReader(data))
|
|
scanner.Buffer(nil, 52_428_800)
|
|
|
|
hasData := false
|
|
hasMessageStart := false
|
|
hasMessageDelta := false
|
|
|
|
for scanner.Scan() {
|
|
line := bytes.TrimSpace(scanner.Bytes())
|
|
if len(line) == 0 || !bytes.HasPrefix(line, []byte("data:")) {
|
|
continue
|
|
}
|
|
payload := bytes.TrimSpace(line[len("data:"):])
|
|
if len(payload) == 0 || bytes.Equal(payload, []byte("[DONE]")) {
|
|
continue
|
|
}
|
|
hasData = true
|
|
if !ojson.ValidBytes(payload) {
|
|
return statusErr{code: http.StatusBadGateway, msg: "claude executor: upstream returned malformed stream data"}
|
|
}
|
|
|
|
root := util.ParseGJSONBytesNoCopy(payload)
|
|
switch root.Get("type").String() {
|
|
case "error":
|
|
message := strings.TrimSpace(root.Get("error.message").String())
|
|
if message == "" {
|
|
message = strings.TrimSpace(root.Get("error.type").String())
|
|
}
|
|
if message == "" {
|
|
message = "unknown upstream error"
|
|
}
|
|
return statusErr{code: http.StatusBadGateway, msg: "claude executor: upstream returned error event: " + message}
|
|
case "message_start":
|
|
message := root.Get("message")
|
|
if strings.TrimSpace(message.Get("id").String()) == "" || strings.TrimSpace(message.Get("model").String()) == "" {
|
|
return statusErr{code: http.StatusBadGateway, msg: "claude executor: upstream stream message_start is missing id or model"}
|
|
}
|
|
hasMessageStart = true
|
|
case "message_delta":
|
|
hasMessageDelta = true
|
|
}
|
|
}
|
|
if errScan := scanner.Err(); errScan != nil {
|
|
return errScan
|
|
}
|
|
if !hasData {
|
|
return statusErr{code: http.StatusBadGateway, msg: "claude executor: upstream returned empty stream response"}
|
|
}
|
|
if !hasMessageStart {
|
|
return statusErr{code: http.StatusBadGateway, msg: "claude executor: upstream stream response is missing message_start"}
|
|
}
|
|
if !hasMessageDelta {
|
|
return statusErr{code: http.StatusBadGateway, msg: "claude executor: upstream stream response ended before message completion"}
|
|
}
|
|
return nil
|
|
}
|