diff --git a/internal/auth/antigravity/auth.go b/internal/auth/antigravity/auth.go new file mode 100644 index 00000000..449f413f --- /dev/null +++ b/internal/auth/antigravity/auth.go @@ -0,0 +1,344 @@ +// Package antigravity provides OAuth2 authentication functionality for the Antigravity provider. +package antigravity + +import ( + "context" + "encoding/json" + "fmt" + "io" + "net/http" + "net/url" + "strings" + "time" + + "github.com/router-for-me/CLIProxyAPI/v6/internal/config" + "github.com/router-for-me/CLIProxyAPI/v6/internal/util" + log "github.com/sirupsen/logrus" +) + +// TokenResponse represents OAuth token response from Google +type TokenResponse struct { + AccessToken string `json:"access_token"` + RefreshToken string `json:"refresh_token"` + ExpiresIn int64 `json:"expires_in"` + TokenType string `json:"token_type"` +} + +// userInfo represents Google user profile +type userInfo struct { + Email string `json:"email"` +} + +// AntigravityAuth handles Antigravity OAuth authentication +type AntigravityAuth struct { + httpClient *http.Client +} + +// NewAntigravityAuth creates a new Antigravity auth service. +func NewAntigravityAuth(cfg *config.Config, httpClient *http.Client) *AntigravityAuth { + if httpClient != nil { + return &AntigravityAuth{httpClient: httpClient} + } + if cfg == nil { + cfg = &config.Config{} + } + return &AntigravityAuth{ + httpClient: util.SetProxy(&cfg.SDKConfig, &http.Client{}), + } +} + +// BuildAuthURL generates the OAuth authorization URL. +func (o *AntigravityAuth) BuildAuthURL(state, redirectURI string) string { + if strings.TrimSpace(redirectURI) == "" { + redirectURI = fmt.Sprintf("http://localhost:%d/oauth-callback", CallbackPort) + } + params := url.Values{} + params.Set("access_type", "offline") + params.Set("client_id", ClientID) + params.Set("prompt", "consent") + params.Set("redirect_uri", redirectURI) + params.Set("response_type", "code") + params.Set("scope", strings.Join(Scopes, " ")) + params.Set("state", state) + return AuthEndpoint + "?" + params.Encode() +} + +// ExchangeCodeForTokens exchanges authorization code for access and refresh tokens +func (o *AntigravityAuth) ExchangeCodeForTokens(ctx context.Context, code, redirectURI string) (*TokenResponse, error) { + data := url.Values{} + data.Set("code", code) + data.Set("client_id", ClientID) + data.Set("client_secret", ClientSecret) + data.Set("redirect_uri", redirectURI) + data.Set("grant_type", "authorization_code") + + req, err := http.NewRequestWithContext(ctx, http.MethodPost, TokenEndpoint, strings.NewReader(data.Encode())) + if err != nil { + return nil, fmt.Errorf("antigravity token exchange: create request: %w", err) + } + req.Header.Set("Content-Type", "application/x-www-form-urlencoded") + + resp, errDo := o.httpClient.Do(req) + if errDo != nil { + return nil, fmt.Errorf("antigravity token exchange: execute request: %w", errDo) + } + defer func() { + if errClose := resp.Body.Close(); errClose != nil { + log.Errorf("antigravity token exchange: close body error: %v", errClose) + } + }() + + if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices { + bodyBytes, errRead := io.ReadAll(io.LimitReader(resp.Body, 8<<10)) + if errRead != nil { + return nil, fmt.Errorf("antigravity token exchange: read response: %w", errRead) + } + body := strings.TrimSpace(string(bodyBytes)) + if body == "" { + return nil, fmt.Errorf("antigravity token exchange: request failed: status %d", resp.StatusCode) + } + return nil, fmt.Errorf("antigravity token exchange: request failed: status %d: %s", resp.StatusCode, body) + } + + var token TokenResponse + if errDecode := json.NewDecoder(resp.Body).Decode(&token); errDecode != nil { + return nil, fmt.Errorf("antigravity token exchange: decode response: %w", errDecode) + } + return &token, nil +} + +// FetchUserInfo retrieves user email from Google +func (o *AntigravityAuth) FetchUserInfo(ctx context.Context, accessToken string) (string, error) { + accessToken = strings.TrimSpace(accessToken) + if accessToken == "" { + return "", fmt.Errorf("antigravity userinfo: missing access token") + } + req, err := http.NewRequestWithContext(ctx, http.MethodGet, UserInfoEndpoint, nil) + if err != nil { + return "", fmt.Errorf("antigravity userinfo: create request: %w", err) + } + req.Header.Set("Authorization", "Bearer "+accessToken) + + resp, errDo := o.httpClient.Do(req) + if errDo != nil { + return "", fmt.Errorf("antigravity userinfo: execute request: %w", errDo) + } + defer func() { + if errClose := resp.Body.Close(); errClose != nil { + log.Errorf("antigravity userinfo: close body error: %v", errClose) + } + }() + + if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices { + bodyBytes, errRead := io.ReadAll(io.LimitReader(resp.Body, 8<<10)) + if errRead != nil { + return "", fmt.Errorf("antigravity userinfo: read response: %w", errRead) + } + body := strings.TrimSpace(string(bodyBytes)) + if body == "" { + return "", fmt.Errorf("antigravity userinfo: request failed: status %d", resp.StatusCode) + } + return "", fmt.Errorf("antigravity userinfo: request failed: status %d: %s", resp.StatusCode, body) + } + var info userInfo + if errDecode := json.NewDecoder(resp.Body).Decode(&info); errDecode != nil { + return "", fmt.Errorf("antigravity userinfo: decode response: %w", errDecode) + } + email := strings.TrimSpace(info.Email) + if email == "" { + return "", fmt.Errorf("antigravity userinfo: response missing email") + } + return email, nil +} + +// FetchProjectID retrieves the project ID for the authenticated user via loadCodeAssist +func (o *AntigravityAuth) FetchProjectID(ctx context.Context, accessToken string) (string, error) { + loadReqBody := map[string]any{ + "metadata": map[string]string{ + "ideType": "ANTIGRAVITY", + "platform": "PLATFORM_UNSPECIFIED", + "pluginType": "GEMINI", + }, + } + + rawBody, errMarshal := json.Marshal(loadReqBody) + if errMarshal != nil { + return "", fmt.Errorf("marshal request body: %w", errMarshal) + } + + endpointURL := fmt.Sprintf("%s/%s:loadCodeAssist", APIEndpoint, APIVersion) + req, err := http.NewRequestWithContext(ctx, http.MethodPost, endpointURL, strings.NewReader(string(rawBody))) + if err != nil { + return "", fmt.Errorf("create request: %w", err) + } + req.Header.Set("Authorization", "Bearer "+accessToken) + req.Header.Set("Content-Type", "application/json") + req.Header.Set("User-Agent", APIUserAgent) + req.Header.Set("X-Goog-Api-Client", APIClient) + req.Header.Set("Client-Metadata", ClientMetadata) + + resp, errDo := o.httpClient.Do(req) + if errDo != nil { + return "", fmt.Errorf("execute request: %w", errDo) + } + defer func() { + if errClose := resp.Body.Close(); errClose != nil { + log.Errorf("antigravity loadCodeAssist: close body error: %v", errClose) + } + }() + + bodyBytes, errRead := io.ReadAll(resp.Body) + if errRead != nil { + return "", fmt.Errorf("read response: %w", errRead) + } + + if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices { + return "", fmt.Errorf("request failed with status %d: %s", resp.StatusCode, strings.TrimSpace(string(bodyBytes))) + } + + var loadResp map[string]any + if errDecode := json.Unmarshal(bodyBytes, &loadResp); errDecode != nil { + return "", fmt.Errorf("decode response: %w", errDecode) + } + + // Extract projectID from response + projectID := "" + if id, ok := loadResp["cloudaicompanionProject"].(string); ok { + projectID = strings.TrimSpace(id) + } + if projectID == "" { + if projectMap, ok := loadResp["cloudaicompanionProject"].(map[string]any); ok { + if id, okID := projectMap["id"].(string); okID { + projectID = strings.TrimSpace(id) + } + } + } + + if projectID == "" { + tierID := "legacy-tier" + if tiers, okTiers := loadResp["allowedTiers"].([]any); okTiers { + for _, rawTier := range tiers { + tier, okTier := rawTier.(map[string]any) + if !okTier { + continue + } + if isDefault, okDefault := tier["isDefault"].(bool); okDefault && isDefault { + if id, okID := tier["id"].(string); okID && strings.TrimSpace(id) != "" { + tierID = strings.TrimSpace(id) + break + } + } + } + } + + projectID, err = o.OnboardUser(ctx, accessToken, tierID) + if err != nil { + return "", err + } + return projectID, nil + } + + return projectID, nil +} + +// OnboardUser attempts to fetch the project ID via onboardUser by polling for completion +func (o *AntigravityAuth) OnboardUser(ctx context.Context, accessToken, tierID string) (string, error) { + log.Infof("Antigravity: onboarding user with tier: %s", tierID) + requestBody := map[string]any{ + "tierId": tierID, + "metadata": map[string]string{ + "ideType": "ANTIGRAVITY", + "platform": "PLATFORM_UNSPECIFIED", + "pluginType": "GEMINI", + }, + } + + rawBody, errMarshal := json.Marshal(requestBody) + if errMarshal != nil { + return "", fmt.Errorf("marshal request body: %w", errMarshal) + } + + maxAttempts := 5 + for attempt := 1; attempt <= maxAttempts; attempt++ { + log.Debugf("Polling attempt %d/%d", attempt, maxAttempts) + + reqCtx := ctx + var cancel context.CancelFunc + if reqCtx == nil { + reqCtx = context.Background() + } + reqCtx, cancel = context.WithTimeout(reqCtx, 30*time.Second) + + endpointURL := fmt.Sprintf("%s/%s:onboardUser", APIEndpoint, APIVersion) + req, errRequest := http.NewRequestWithContext(reqCtx, http.MethodPost, endpointURL, strings.NewReader(string(rawBody))) + if errRequest != nil { + cancel() + return "", fmt.Errorf("create request: %w", errRequest) + } + req.Header.Set("Authorization", "Bearer "+accessToken) + req.Header.Set("Content-Type", "application/json") + req.Header.Set("User-Agent", APIUserAgent) + req.Header.Set("X-Goog-Api-Client", APIClient) + req.Header.Set("Client-Metadata", ClientMetadata) + + resp, errDo := o.httpClient.Do(req) + if errDo != nil { + cancel() + return "", fmt.Errorf("execute request: %w", errDo) + } + + bodyBytes, errRead := io.ReadAll(resp.Body) + if errClose := resp.Body.Close(); errClose != nil { + log.Errorf("close body error: %v", errClose) + } + cancel() + + if errRead != nil { + return "", fmt.Errorf("read response: %w", errRead) + } + + if resp.StatusCode == http.StatusOK { + var data map[string]any + if errDecode := json.Unmarshal(bodyBytes, &data); errDecode != nil { + return "", fmt.Errorf("decode response: %w", errDecode) + } + + if done, okDone := data["done"].(bool); okDone && done { + projectID := "" + if responseData, okResp := data["response"].(map[string]any); okResp { + switch projectValue := responseData["cloudaicompanionProject"].(type) { + case map[string]any: + if id, okID := projectValue["id"].(string); okID { + projectID = strings.TrimSpace(id) + } + case string: + projectID = strings.TrimSpace(projectValue) + } + } + + if projectID != "" { + log.Infof("Successfully fetched project_id: %s", projectID) + return projectID, nil + } + + return "", fmt.Errorf("no project_id in response") + } + + time.Sleep(2 * time.Second) + continue + } + + responsePreview := strings.TrimSpace(string(bodyBytes)) + if len(responsePreview) > 500 { + responsePreview = responsePreview[:500] + } + + responseErr := responsePreview + if len(responseErr) > 200 { + responseErr = responseErr[:200] + } + return "", fmt.Errorf("http %d: %s", resp.StatusCode, responseErr) + } + + return "", nil +} diff --git a/internal/auth/antigravity/constants.go b/internal/auth/antigravity/constants.go new file mode 100644 index 00000000..680c8e3c --- /dev/null +++ b/internal/auth/antigravity/constants.go @@ -0,0 +1,34 @@ +// Package antigravity provides OAuth2 authentication functionality for the Antigravity provider. +package antigravity + +// OAuth client credentials and configuration +const ( + ClientID = "1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com" + ClientSecret = "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" + CallbackPort = 51121 +) + +// Scopes defines the OAuth scopes required for Antigravity authentication +var Scopes = []string{ + "https://www.googleapis.com/auth/cloud-platform", + "https://www.googleapis.com/auth/userinfo.email", + "https://www.googleapis.com/auth/userinfo.profile", + "https://www.googleapis.com/auth/cclog", + "https://www.googleapis.com/auth/experimentsandconfigs", +} + +// OAuth2 endpoints for Google authentication +const ( + TokenEndpoint = "https://oauth2.googleapis.com/token" + AuthEndpoint = "https://accounts.google.com/o/oauth2/v2/auth" + UserInfoEndpoint = "https://www.googleapis.com/oauth2/v1/userinfo?alt=json" +) + +// Antigravity API configuration +const ( + APIEndpoint = "https://cloudcode-pa.googleapis.com" + APIVersion = "v1internal" + APIUserAgent = "google-api-nodejs-client/9.15.1" + APIClient = "google-cloud-sdk vscode_cloudshelleditor/0.1" + ClientMetadata = `{"ideType":"IDE_UNSPECIFIED","platform":"PLATFORM_UNSPECIFIED","pluginType":"GEMINI"}` +) diff --git a/internal/auth/antigravity/filename.go b/internal/auth/antigravity/filename.go new file mode 100644 index 00000000..03ad3e2f --- /dev/null +++ b/internal/auth/antigravity/filename.go @@ -0,0 +1,16 @@ +package antigravity + +import ( + "fmt" + "strings" +) + +// CredentialFileName returns the filename used to persist Antigravity credentials. +// It uses the email as a suffix to disambiguate accounts. +func CredentialFileName(email string) string { + email = strings.TrimSpace(email) + if email == "" { + return "antigravity.json" + } + return fmt.Sprintf("antigravity-%s.json", email) +} diff --git a/internal/auth/claude/anthropic_auth.go b/internal/auth/claude/anthropic_auth.go index 07bd5b42..54edce3b 100644 --- a/internal/auth/claude/anthropic_auth.go +++ b/internal/auth/claude/anthropic_auth.go @@ -18,11 +18,12 @@ import ( log "github.com/sirupsen/logrus" ) +// OAuth configuration constants for Claude/Anthropic const ( - anthropicAuthURL = "https://claude.ai/oauth/authorize" - anthropicTokenURL = "https://console.anthropic.com/v1/oauth/token" - anthropicClientID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e" - redirectURI = "http://localhost:54545/callback" + AuthURL = "https://claude.ai/oauth/authorize" + TokenURL = "https://console.anthropic.com/v1/oauth/token" + ClientID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e" + RedirectURI = "http://localhost:54545/callback" ) // tokenResponse represents the response structure from Anthropic's OAuth token endpoint. @@ -82,16 +83,16 @@ func (o *ClaudeAuth) GenerateAuthURL(state string, pkceCodes *PKCECodes) (string params := url.Values{ "code": {"true"}, - "client_id": {anthropicClientID}, + "client_id": {ClientID}, "response_type": {"code"}, - "redirect_uri": {redirectURI}, + "redirect_uri": {RedirectURI}, "scope": {"org:create_api_key user:profile user:inference"}, "code_challenge": {pkceCodes.CodeChallenge}, "code_challenge_method": {"S256"}, "state": {state}, } - authURL := fmt.Sprintf("%s?%s", anthropicAuthURL, params.Encode()) + authURL := fmt.Sprintf("%s?%s", AuthURL, params.Encode()) return authURL, state, nil } @@ -137,8 +138,8 @@ func (o *ClaudeAuth) ExchangeCodeForTokens(ctx context.Context, code, state stri "code": newCode, "state": state, "grant_type": "authorization_code", - "client_id": anthropicClientID, - "redirect_uri": redirectURI, + "client_id": ClientID, + "redirect_uri": RedirectURI, "code_verifier": pkceCodes.CodeVerifier, } @@ -154,7 +155,7 @@ func (o *ClaudeAuth) ExchangeCodeForTokens(ctx context.Context, code, state stri // log.Debugf("Token exchange request: %s", string(jsonBody)) - req, err := http.NewRequestWithContext(ctx, "POST", anthropicTokenURL, strings.NewReader(string(jsonBody))) + req, err := http.NewRequestWithContext(ctx, "POST", TokenURL, strings.NewReader(string(jsonBody))) if err != nil { return nil, fmt.Errorf("failed to create token request: %w", err) } @@ -221,7 +222,7 @@ func (o *ClaudeAuth) RefreshTokens(ctx context.Context, refreshToken string) (*C } reqBody := map[string]interface{}{ - "client_id": anthropicClientID, + "client_id": ClientID, "grant_type": "refresh_token", "refresh_token": refreshToken, } @@ -231,7 +232,7 @@ func (o *ClaudeAuth) RefreshTokens(ctx context.Context, refreshToken string) (*C return nil, fmt.Errorf("failed to marshal request body: %w", err) } - req, err := http.NewRequestWithContext(ctx, "POST", anthropicTokenURL, strings.NewReader(string(jsonBody))) + req, err := http.NewRequestWithContext(ctx, "POST", TokenURL, strings.NewReader(string(jsonBody))) if err != nil { return nil, fmt.Errorf("failed to create refresh request: %w", err) } diff --git a/internal/auth/codex/openai_auth.go b/internal/auth/codex/openai_auth.go index c0299c3d..89deeadb 100644 --- a/internal/auth/codex/openai_auth.go +++ b/internal/auth/codex/openai_auth.go @@ -19,11 +19,12 @@ import ( log "github.com/sirupsen/logrus" ) +// OAuth configuration constants for OpenAI Codex const ( - openaiAuthURL = "https://auth.openai.com/oauth/authorize" - openaiTokenURL = "https://auth.openai.com/oauth/token" - openaiClientID = "app_EMoamEEZ73f0CkXaXp7hrann" - redirectURI = "http://localhost:1455/auth/callback" + AuthURL = "https://auth.openai.com/oauth/authorize" + TokenURL = "https://auth.openai.com/oauth/token" + ClientID = "app_EMoamEEZ73f0CkXaXp7hrann" + RedirectURI = "http://localhost:1455/auth/callback" ) // CodexAuth handles the OpenAI OAuth2 authentication flow. @@ -50,9 +51,9 @@ func (o *CodexAuth) GenerateAuthURL(state string, pkceCodes *PKCECodes) (string, } params := url.Values{ - "client_id": {openaiClientID}, + "client_id": {ClientID}, "response_type": {"code"}, - "redirect_uri": {redirectURI}, + "redirect_uri": {RedirectURI}, "scope": {"openid email profile offline_access"}, "state": {state}, "code_challenge": {pkceCodes.CodeChallenge}, @@ -62,7 +63,7 @@ func (o *CodexAuth) GenerateAuthURL(state string, pkceCodes *PKCECodes) (string, "codex_cli_simplified_flow": {"true"}, } - authURL := fmt.Sprintf("%s?%s", openaiAuthURL, params.Encode()) + authURL := fmt.Sprintf("%s?%s", AuthURL, params.Encode()) return authURL, nil } @@ -77,13 +78,13 @@ func (o *CodexAuth) ExchangeCodeForTokens(ctx context.Context, code string, pkce // Prepare token exchange request data := url.Values{ "grant_type": {"authorization_code"}, - "client_id": {openaiClientID}, + "client_id": {ClientID}, "code": {code}, - "redirect_uri": {redirectURI}, + "redirect_uri": {RedirectURI}, "code_verifier": {pkceCodes.CodeVerifier}, } - req, err := http.NewRequestWithContext(ctx, "POST", openaiTokenURL, strings.NewReader(data.Encode())) + req, err := http.NewRequestWithContext(ctx, "POST", TokenURL, strings.NewReader(data.Encode())) if err != nil { return nil, fmt.Errorf("failed to create token request: %w", err) } @@ -163,13 +164,13 @@ func (o *CodexAuth) RefreshTokens(ctx context.Context, refreshToken string) (*Co } data := url.Values{ - "client_id": {openaiClientID}, + "client_id": {ClientID}, "grant_type": {"refresh_token"}, "refresh_token": {refreshToken}, "scope": {"openid profile email"}, } - req, err := http.NewRequestWithContext(ctx, "POST", openaiTokenURL, strings.NewReader(data.Encode())) + req, err := http.NewRequestWithContext(ctx, "POST", TokenURL, strings.NewReader(data.Encode())) if err != nil { return nil, fmt.Errorf("failed to create refresh request: %w", err) } diff --git a/internal/auth/gemini/gemini_auth.go b/internal/auth/gemini/gemini_auth.go index 7b18e738..6406a0e1 100644 --- a/internal/auth/gemini/gemini_auth.go +++ b/internal/auth/gemini/gemini_auth.go @@ -28,18 +28,19 @@ import ( "golang.org/x/oauth2/google" ) +// OAuth configuration constants for Gemini const ( - geminiOauthClientID = "681255809395-oo8ft2oprdrnp9e3aqf6av3hmdib135j.apps.googleusercontent.com" - geminiOauthClientSecret = "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" + ClientID = "681255809395-oo8ft2oprdrnp9e3aqf6av3hmdib135j.apps.googleusercontent.com" + ClientSecret = "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" + DefaultCallbackPort = 8085 ) -var ( - geminiOauthScopes = []string{ - "https://www.googleapis.com/auth/cloud-platform", - "https://www.googleapis.com/auth/userinfo.email", - "https://www.googleapis.com/auth/userinfo.profile", - } -) +// OAuth scopes for Gemini authentication +var Scopes = []string{ + "https://www.googleapis.com/auth/cloud-platform", + "https://www.googleapis.com/auth/userinfo.email", + "https://www.googleapis.com/auth/userinfo.profile", +} // GeminiAuth provides methods for handling the Gemini OAuth2 authentication flow. // It encapsulates the logic for obtaining, storing, and refreshing authentication tokens @@ -49,8 +50,9 @@ type GeminiAuth struct { // WebLoginOptions customizes the interactive OAuth flow. type WebLoginOptions struct { - NoBrowser bool - Prompt func(string) (string, error) + NoBrowser bool + CallbackPort int + Prompt func(string) (string, error) } // NewGeminiAuth creates a new instance of GeminiAuth. @@ -72,6 +74,12 @@ func NewGeminiAuth() *GeminiAuth { // - *http.Client: An HTTP client configured with authentication // - error: An error if the client configuration fails, nil otherwise func (g *GeminiAuth) GetAuthenticatedClient(ctx context.Context, ts *GeminiTokenStorage, cfg *config.Config, opts *WebLoginOptions) (*http.Client, error) { + callbackPort := DefaultCallbackPort + if opts != nil && opts.CallbackPort > 0 { + callbackPort = opts.CallbackPort + } + callbackURL := fmt.Sprintf("http://localhost:%d/oauth2callback", callbackPort) + // Configure proxy settings for the HTTP client if a proxy URL is provided. proxyURL, err := url.Parse(cfg.ProxyURL) if err == nil { @@ -104,10 +112,10 @@ func (g *GeminiAuth) GetAuthenticatedClient(ctx context.Context, ts *GeminiToken // Configure the OAuth2 client. conf := &oauth2.Config{ - ClientID: geminiOauthClientID, - ClientSecret: geminiOauthClientSecret, - RedirectURL: "http://localhost:8085/oauth2callback", // This will be used by the local server. - Scopes: geminiOauthScopes, + ClientID: ClientID, + ClientSecret: ClientSecret, + RedirectURL: callbackURL, // This will be used by the local server. + Scopes: Scopes, Endpoint: google.Endpoint, } @@ -190,9 +198,9 @@ func (g *GeminiAuth) createTokenStorage(ctx context.Context, config *oauth2.Conf } ifToken["token_uri"] = "https://oauth2.googleapis.com/token" - ifToken["client_id"] = geminiOauthClientID - ifToken["client_secret"] = geminiOauthClientSecret - ifToken["scopes"] = geminiOauthScopes + ifToken["client_id"] = ClientID + ifToken["client_secret"] = ClientSecret + ifToken["scopes"] = Scopes ifToken["universe_domain"] = "googleapis.com" ts := GeminiTokenStorage{ @@ -218,14 +226,20 @@ func (g *GeminiAuth) createTokenStorage(ctx context.Context, config *oauth2.Conf // - *oauth2.Token: The OAuth2 token obtained from the authorization flow // - error: An error if the token acquisition fails, nil otherwise func (g *GeminiAuth) getTokenFromWeb(ctx context.Context, config *oauth2.Config, opts *WebLoginOptions) (*oauth2.Token, error) { + callbackPort := DefaultCallbackPort + if opts != nil && opts.CallbackPort > 0 { + callbackPort = opts.CallbackPort + } + callbackURL := fmt.Sprintf("http://localhost:%d/oauth2callback", callbackPort) + // Use a channel to pass the authorization code from the HTTP handler to the main function. codeChan := make(chan string, 1) errChan := make(chan error, 1) // Create a new HTTP server with its own multiplexer. mux := http.NewServeMux() - server := &http.Server{Addr: ":8085", Handler: mux} - config.RedirectURL = "http://localhost:8085/oauth2callback" + server := &http.Server{Addr: fmt.Sprintf(":%d", callbackPort), Handler: mux} + config.RedirectURL = callbackURL mux.HandleFunc("/oauth2callback", func(w http.ResponseWriter, r *http.Request) { if err := r.URL.Query().Get("error"); err != "" { @@ -277,13 +291,13 @@ func (g *GeminiAuth) getTokenFromWeb(ctx context.Context, config *oauth2.Config, // Check if browser is available if !browser.IsAvailable() { log.Warn("No browser available on this system") - util.PrintSSHTunnelInstructions(8085) + util.PrintSSHTunnelInstructions(callbackPort) fmt.Printf("Please manually open this URL in your browser:\n\n%s\n", authURL) } else { if err := browser.OpenURL(authURL); err != nil { authErr := codex.NewAuthenticationError(codex.ErrBrowserOpenFailed, err) log.Warn(codex.GetUserFriendlyMessage(authErr)) - util.PrintSSHTunnelInstructions(8085) + util.PrintSSHTunnelInstructions(callbackPort) fmt.Printf("Please manually open this URL in your browser:\n\n%s\n", authURL) // Log platform info for debugging @@ -294,7 +308,7 @@ func (g *GeminiAuth) getTokenFromWeb(ctx context.Context, config *oauth2.Config, } } } else { - util.PrintSSHTunnelInstructions(8085) + util.PrintSSHTunnelInstructions(callbackPort) fmt.Printf("Please open this URL in your browser:\n\n%s\n", authURL) } diff --git a/internal/runtime/executor/antigravity_executor.go b/internal/runtime/executor/antigravity_executor.go index 2193b1b1..19fbb7b6 100644 --- a/internal/runtime/executor/antigravity_executor.go +++ b/internal/runtime/executor/antigravity_executor.go @@ -148,87 +148,108 @@ func (e *AntigravityExecutor) Execute(ctx context.Context, auth *cliproxyauth.Au baseURLs := antigravityBaseURLFallbackOrder(auth) httpClient := newProxyAwareHTTPClient(ctx, e.cfg, auth, 0) - var lastStatus int - var lastBody []byte - var lastErr error + attempts := antigravityRetryAttempts(e.cfg) - for idx, baseURL := range baseURLs { - httpReq, errReq := e.buildRequest(ctx, auth, token, baseModel, translated, false, opts.Alt, baseURL) - if errReq != nil { - err = errReq - return resp, err - } +attemptLoop: + for attempt := 0; attempt < attempts; attempt++ { + var lastStatus int + var lastBody []byte + var lastErr error - httpResp, errDo := httpClient.Do(httpReq) - if errDo != nil { - recordAPIResponseError(ctx, e.cfg, errDo) - if errors.Is(errDo, context.Canceled) || errors.Is(errDo, context.DeadlineExceeded) { - return resp, errDo + for idx, baseURL := range baseURLs { + httpReq, errReq := e.buildRequest(ctx, auth, token, baseModel, translated, false, opts.Alt, baseURL) + if errReq != nil { + err = errReq + return resp, err } - lastStatus = 0 - lastBody = nil - lastErr = errDo - if idx+1 < len(baseURLs) { - log.Debugf("antigravity executor: request error on base url %s, retrying with fallback base url: %s", baseURL, baseURLs[idx+1]) - continue + + httpResp, errDo := httpClient.Do(httpReq) + if errDo != nil { + recordAPIResponseError(ctx, e.cfg, errDo) + if errors.Is(errDo, context.Canceled) || errors.Is(errDo, context.DeadlineExceeded) { + return resp, errDo + } + lastStatus = 0 + lastBody = nil + lastErr = errDo + if idx+1 < len(baseURLs) { + log.Debugf("antigravity executor: request error on base url %s, retrying with fallback base url: %s", baseURL, baseURLs[idx+1]) + continue + } + err = errDo + return resp, err } - err = errDo - return resp, err + + recordAPIResponseMetadata(ctx, e.cfg, httpResp.StatusCode, httpResp.Header.Clone()) + bodyBytes, errRead := io.ReadAll(httpResp.Body) + if errClose := httpResp.Body.Close(); errClose != nil { + log.Errorf("antigravity executor: close response body error: %v", errClose) + } + if errRead != nil { + recordAPIResponseError(ctx, e.cfg, errRead) + err = errRead + return resp, err + } + appendAPIResponseChunk(ctx, e.cfg, bodyBytes) + + if httpResp.StatusCode < http.StatusOK || httpResp.StatusCode >= http.StatusMultipleChoices { + log.Debugf("antigravity executor: upstream error status: %d, body: %s", httpResp.StatusCode, summarizeErrorBody(httpResp.Header.Get("Content-Type"), bodyBytes)) + lastStatus = httpResp.StatusCode + lastBody = append([]byte(nil), bodyBytes...) + lastErr = nil + if httpResp.StatusCode == http.StatusTooManyRequests && idx+1 < len(baseURLs) { + log.Debugf("antigravity executor: rate limited on base url %s, retrying with fallback base url: %s", baseURL, baseURLs[idx+1]) + continue + } + if antigravityShouldRetryNoCapacity(httpResp.StatusCode, bodyBytes) { + if idx+1 < len(baseURLs) { + log.Debugf("antigravity executor: no capacity on base url %s, retrying with fallback base url: %s", baseURL, baseURLs[idx+1]) + continue + } + if attempt+1 < attempts { + delay := antigravityNoCapacityRetryDelay(attempt) + log.Debugf("antigravity executor: no capacity for model %s, retrying in %s (attempt %d/%d)", baseModel, delay, attempt+1, attempts) + if errWait := antigravityWait(ctx, delay); errWait != nil { + return resp, errWait + } + continue attemptLoop + } + } + sErr := statusErr{code: httpResp.StatusCode, msg: string(bodyBytes)} + if httpResp.StatusCode == http.StatusTooManyRequests { + if retryAfter, parseErr := parseRetryDelay(bodyBytes); parseErr == nil && retryAfter != nil { + sErr.retryAfter = retryAfter + } + } + err = sErr + return resp, err + } + + reporter.publish(ctx, parseAntigravityUsage(bodyBytes)) + var param any + converted := sdktranslator.TranslateNonStream(ctx, to, from, req.Model, bytes.Clone(opts.OriginalRequest), translated, bodyBytes, ¶m) + resp = cliproxyexecutor.Response{Payload: []byte(converted)} + reporter.ensurePublished(ctx) + return resp, nil } - recordAPIResponseMetadata(ctx, e.cfg, httpResp.StatusCode, httpResp.Header.Clone()) - bodyBytes, errRead := io.ReadAll(httpResp.Body) - if errClose := httpResp.Body.Close(); errClose != nil { - log.Errorf("antigravity executor: close response body error: %v", errClose) - } - if errRead != nil { - recordAPIResponseError(ctx, e.cfg, errRead) - err = errRead - return resp, err - } - appendAPIResponseChunk(ctx, e.cfg, bodyBytes) - - if httpResp.StatusCode < http.StatusOK || httpResp.StatusCode >= http.StatusMultipleChoices { - log.Debugf("antigravity executor: upstream error status: %d, body: %s", httpResp.StatusCode, summarizeErrorBody(httpResp.Header.Get("Content-Type"), bodyBytes)) - lastStatus = httpResp.StatusCode - lastBody = append([]byte(nil), bodyBytes...) - lastErr = nil - if httpResp.StatusCode == http.StatusTooManyRequests && idx+1 < len(baseURLs) { - log.Debugf("antigravity executor: rate limited on base url %s, retrying with fallback base url: %s", baseURL, baseURLs[idx+1]) - continue - } - sErr := statusErr{code: httpResp.StatusCode, msg: string(bodyBytes)} - if httpResp.StatusCode == http.StatusTooManyRequests { - if retryAfter, parseErr := parseRetryDelay(bodyBytes); parseErr == nil && retryAfter != nil { + switch { + case lastStatus != 0: + sErr := statusErr{code: lastStatus, msg: string(lastBody)} + if lastStatus == http.StatusTooManyRequests { + if retryAfter, parseErr := parseRetryDelay(lastBody); parseErr == nil && retryAfter != nil { sErr.retryAfter = retryAfter } } err = sErr - return resp, err + case lastErr != nil: + err = lastErr + default: + err = statusErr{code: http.StatusServiceUnavailable, msg: "antigravity executor: no base url available"} } - - reporter.publish(ctx, parseAntigravityUsage(bodyBytes)) - var param any - converted := sdktranslator.TranslateNonStream(ctx, to, from, req.Model, bytes.Clone(opts.OriginalRequest), translated, bodyBytes, ¶m) - resp = cliproxyexecutor.Response{Payload: []byte(converted)} - reporter.ensurePublished(ctx) - return resp, nil + return resp, err } - switch { - case lastStatus != 0: - sErr := statusErr{code: lastStatus, msg: string(lastBody)} - if lastStatus == http.StatusTooManyRequests { - if retryAfter, parseErr := parseRetryDelay(lastBody); parseErr == nil && retryAfter != nil { - sErr.retryAfter = retryAfter - } - } - err = sErr - case lastErr != nil: - err = lastErr - default: - err = statusErr{code: http.StatusServiceUnavailable, msg: "antigravity executor: no base url available"} - } return resp, err } @@ -268,150 +289,171 @@ func (e *AntigravityExecutor) executeClaudeNonStream(ctx context.Context, auth * baseURLs := antigravityBaseURLFallbackOrder(auth) httpClient := newProxyAwareHTTPClient(ctx, e.cfg, auth, 0) - var lastStatus int - var lastBody []byte - var lastErr error + attempts := antigravityRetryAttempts(e.cfg) - for idx, baseURL := range baseURLs { - httpReq, errReq := e.buildRequest(ctx, auth, token, baseModel, translated, true, opts.Alt, baseURL) - if errReq != nil { - err = errReq - return resp, err - } +attemptLoop: + for attempt := 0; attempt < attempts; attempt++ { + var lastStatus int + var lastBody []byte + var lastErr error - httpResp, errDo := httpClient.Do(httpReq) - if errDo != nil { - recordAPIResponseError(ctx, e.cfg, errDo) - if errors.Is(errDo, context.Canceled) || errors.Is(errDo, context.DeadlineExceeded) { - return resp, errDo + for idx, baseURL := range baseURLs { + httpReq, errReq := e.buildRequest(ctx, auth, token, baseModel, translated, true, opts.Alt, baseURL) + if errReq != nil { + err = errReq + return resp, err } - lastStatus = 0 - lastBody = nil - lastErr = errDo - if idx+1 < len(baseURLs) { - log.Debugf("antigravity executor: request error on base url %s, retrying with fallback base url: %s", baseURL, baseURLs[idx+1]) - continue - } - err = errDo - return resp, err - } - recordAPIResponseMetadata(ctx, e.cfg, httpResp.StatusCode, httpResp.Header.Clone()) - if httpResp.StatusCode < http.StatusOK || httpResp.StatusCode >= http.StatusMultipleChoices { - bodyBytes, errRead := io.ReadAll(httpResp.Body) - if errClose := httpResp.Body.Close(); errClose != nil { - log.Errorf("antigravity executor: close response body error: %v", errClose) - } - if errRead != nil { - recordAPIResponseError(ctx, e.cfg, errRead) - if errors.Is(errRead, context.Canceled) || errors.Is(errRead, context.DeadlineExceeded) { - err = errRead - return resp, err - } - if errCtx := ctx.Err(); errCtx != nil { - err = errCtx - return resp, err + + httpResp, errDo := httpClient.Do(httpReq) + if errDo != nil { + recordAPIResponseError(ctx, e.cfg, errDo) + if errors.Is(errDo, context.Canceled) || errors.Is(errDo, context.DeadlineExceeded) { + return resp, errDo } lastStatus = 0 lastBody = nil - lastErr = errRead + lastErr = errDo if idx+1 < len(baseURLs) { - log.Debugf("antigravity executor: read error on base url %s, retrying with fallback base url: %s", baseURL, baseURLs[idx+1]) + log.Debugf("antigravity executor: request error on base url %s, retrying with fallback base url: %s", baseURL, baseURLs[idx+1]) continue } - err = errRead + err = errDo return resp, err } - appendAPIResponseChunk(ctx, e.cfg, bodyBytes) - lastStatus = httpResp.StatusCode - lastBody = append([]byte(nil), bodyBytes...) - lastErr = nil - if httpResp.StatusCode == http.StatusTooManyRequests && idx+1 < len(baseURLs) { - log.Debugf("antigravity executor: rate limited on base url %s, retrying with fallback base url: %s", baseURL, baseURLs[idx+1]) - continue + recordAPIResponseMetadata(ctx, e.cfg, httpResp.StatusCode, httpResp.Header.Clone()) + if httpResp.StatusCode < http.StatusOK || httpResp.StatusCode >= http.StatusMultipleChoices { + bodyBytes, errRead := io.ReadAll(httpResp.Body) + if errClose := httpResp.Body.Close(); errClose != nil { + log.Errorf("antigravity executor: close response body error: %v", errClose) + } + if errRead != nil { + recordAPIResponseError(ctx, e.cfg, errRead) + if errors.Is(errRead, context.Canceled) || errors.Is(errRead, context.DeadlineExceeded) { + err = errRead + return resp, err + } + if errCtx := ctx.Err(); errCtx != nil { + err = errCtx + return resp, err + } + lastStatus = 0 + lastBody = nil + lastErr = errRead + if idx+1 < len(baseURLs) { + log.Debugf("antigravity executor: read error on base url %s, retrying with fallback base url: %s", baseURL, baseURLs[idx+1]) + continue + } + err = errRead + return resp, err + } + appendAPIResponseChunk(ctx, e.cfg, bodyBytes) + lastStatus = httpResp.StatusCode + lastBody = append([]byte(nil), bodyBytes...) + lastErr = nil + if httpResp.StatusCode == http.StatusTooManyRequests && idx+1 < len(baseURLs) { + log.Debugf("antigravity executor: rate limited on base url %s, retrying with fallback base url: %s", baseURL, baseURLs[idx+1]) + continue + } + if antigravityShouldRetryNoCapacity(httpResp.StatusCode, bodyBytes) { + if idx+1 < len(baseURLs) { + log.Debugf("antigravity executor: no capacity on base url %s, retrying with fallback base url: %s", baseURL, baseURLs[idx+1]) + continue + } + if attempt+1 < attempts { + delay := antigravityNoCapacityRetryDelay(attempt) + log.Debugf("antigravity executor: no capacity for model %s, retrying in %s (attempt %d/%d)", baseModel, delay, attempt+1, attempts) + if errWait := antigravityWait(ctx, delay); errWait != nil { + return resp, errWait + } + continue attemptLoop + } + } + sErr := statusErr{code: httpResp.StatusCode, msg: string(bodyBytes)} + if httpResp.StatusCode == http.StatusTooManyRequests { + if retryAfter, parseErr := parseRetryDelay(bodyBytes); parseErr == nil && retryAfter != nil { + sErr.retryAfter = retryAfter + } + } + err = sErr + return resp, err } - sErr := statusErr{code: httpResp.StatusCode, msg: string(bodyBytes)} - if httpResp.StatusCode == http.StatusTooManyRequests { - if retryAfter, parseErr := parseRetryDelay(bodyBytes); parseErr == nil && retryAfter != nil { + + out := make(chan cliproxyexecutor.StreamChunk) + go func(resp *http.Response) { + defer close(out) + defer func() { + if errClose := resp.Body.Close(); errClose != nil { + log.Errorf("antigravity executor: close response body error: %v", errClose) + } + }() + scanner := bufio.NewScanner(resp.Body) + scanner.Buffer(nil, streamScannerBuffer) + for scanner.Scan() { + line := scanner.Bytes() + appendAPIResponseChunk(ctx, e.cfg, line) + + // Filter usage metadata for all models + // Only retain usage statistics in the terminal chunk + line = FilterSSEUsageMetadata(line) + + payload := jsonPayload(line) + if payload == nil { + continue + } + + if detail, ok := parseAntigravityStreamUsage(payload); ok { + reporter.publish(ctx, detail) + } + + out <- cliproxyexecutor.StreamChunk{Payload: payload} + } + if errScan := scanner.Err(); errScan != nil { + recordAPIResponseError(ctx, e.cfg, errScan) + reporter.publishFailure(ctx) + out <- cliproxyexecutor.StreamChunk{Err: errScan} + } else { + reporter.ensurePublished(ctx) + } + }(httpResp) + + var buffer bytes.Buffer + for chunk := range out { + if chunk.Err != nil { + return resp, chunk.Err + } + if len(chunk.Payload) > 0 { + _, _ = buffer.Write(chunk.Payload) + _, _ = buffer.Write([]byte("\n")) + } + } + resp = cliproxyexecutor.Response{Payload: e.convertStreamToNonStream(buffer.Bytes())} + + reporter.publish(ctx, parseAntigravityUsage(resp.Payload)) + var param any + converted := sdktranslator.TranslateNonStream(ctx, to, from, req.Model, bytes.Clone(opts.OriginalRequest), translated, resp.Payload, ¶m) + resp = cliproxyexecutor.Response{Payload: []byte(converted)} + reporter.ensurePublished(ctx) + + return resp, nil + } + + switch { + case lastStatus != 0: + sErr := statusErr{code: lastStatus, msg: string(lastBody)} + if lastStatus == http.StatusTooManyRequests { + if retryAfter, parseErr := parseRetryDelay(lastBody); parseErr == nil && retryAfter != nil { sErr.retryAfter = retryAfter } } err = sErr - return resp, err + case lastErr != nil: + err = lastErr + default: + err = statusErr{code: http.StatusServiceUnavailable, msg: "antigravity executor: no base url available"} } - - out := make(chan cliproxyexecutor.StreamChunk) - go func(resp *http.Response) { - defer close(out) - defer func() { - if errClose := resp.Body.Close(); errClose != nil { - log.Errorf("antigravity executor: close response body error: %v", errClose) - } - }() - scanner := bufio.NewScanner(resp.Body) - scanner.Buffer(nil, streamScannerBuffer) - for scanner.Scan() { - line := scanner.Bytes() - appendAPIResponseChunk(ctx, e.cfg, line) - - // Filter usage metadata for all models - // Only retain usage statistics in the terminal chunk - line = FilterSSEUsageMetadata(line) - - payload := jsonPayload(line) - if payload == nil { - continue - } - - if detail, ok := parseAntigravityStreamUsage(payload); ok { - reporter.publish(ctx, detail) - } - - out <- cliproxyexecutor.StreamChunk{Payload: payload} - } - if errScan := scanner.Err(); errScan != nil { - recordAPIResponseError(ctx, e.cfg, errScan) - reporter.publishFailure(ctx) - out <- cliproxyexecutor.StreamChunk{Err: errScan} - } else { - reporter.ensurePublished(ctx) - } - }(httpResp) - - var buffer bytes.Buffer - for chunk := range out { - if chunk.Err != nil { - return resp, chunk.Err - } - if len(chunk.Payload) > 0 { - _, _ = buffer.Write(chunk.Payload) - _, _ = buffer.Write([]byte("\n")) - } - } - resp = cliproxyexecutor.Response{Payload: e.convertStreamToNonStream(buffer.Bytes())} - - reporter.publish(ctx, parseAntigravityUsage(resp.Payload)) - var param any - converted := sdktranslator.TranslateNonStream(ctx, to, from, req.Model, bytes.Clone(opts.OriginalRequest), translated, resp.Payload, ¶m) - resp = cliproxyexecutor.Response{Payload: []byte(converted)} - reporter.ensurePublished(ctx) - - return resp, nil + return resp, err } - switch { - case lastStatus != 0: - sErr := statusErr{code: lastStatus, msg: string(lastBody)} - if lastStatus == http.StatusTooManyRequests { - if retryAfter, parseErr := parseRetryDelay(lastBody); parseErr == nil && retryAfter != nil { - sErr.retryAfter = retryAfter - } - } - err = sErr - case lastErr != nil: - err = lastErr - default: - err = statusErr{code: http.StatusServiceUnavailable, msg: "antigravity executor: no base url available"} - } return resp, err } @@ -635,139 +677,160 @@ func (e *AntigravityExecutor) ExecuteStream(ctx context.Context, auth *cliproxya baseURLs := antigravityBaseURLFallbackOrder(auth) httpClient := newProxyAwareHTTPClient(ctx, e.cfg, auth, 0) - var lastStatus int - var lastBody []byte - var lastErr error + attempts := antigravityRetryAttempts(e.cfg) - for idx, baseURL := range baseURLs { - httpReq, errReq := e.buildRequest(ctx, auth, token, baseModel, translated, true, opts.Alt, baseURL) - if errReq != nil { - err = errReq - return nil, err - } - httpResp, errDo := httpClient.Do(httpReq) - if errDo != nil { - recordAPIResponseError(ctx, e.cfg, errDo) - if errors.Is(errDo, context.Canceled) || errors.Is(errDo, context.DeadlineExceeded) { - return nil, errDo +attemptLoop: + for attempt := 0; attempt < attempts; attempt++ { + var lastStatus int + var lastBody []byte + var lastErr error + + for idx, baseURL := range baseURLs { + httpReq, errReq := e.buildRequest(ctx, auth, token, baseModel, translated, true, opts.Alt, baseURL) + if errReq != nil { + err = errReq + return nil, err } - lastStatus = 0 - lastBody = nil - lastErr = errDo - if idx+1 < len(baseURLs) { - log.Debugf("antigravity executor: request error on base url %s, retrying with fallback base url: %s", baseURL, baseURLs[idx+1]) - continue - } - err = errDo - return nil, err - } - recordAPIResponseMetadata(ctx, e.cfg, httpResp.StatusCode, httpResp.Header.Clone()) - if httpResp.StatusCode < http.StatusOK || httpResp.StatusCode >= http.StatusMultipleChoices { - bodyBytes, errRead := io.ReadAll(httpResp.Body) - if errClose := httpResp.Body.Close(); errClose != nil { - log.Errorf("antigravity executor: close response body error: %v", errClose) - } - if errRead != nil { - recordAPIResponseError(ctx, e.cfg, errRead) - if errors.Is(errRead, context.Canceled) || errors.Is(errRead, context.DeadlineExceeded) { - err = errRead - return nil, err - } - if errCtx := ctx.Err(); errCtx != nil { - err = errCtx - return nil, err + httpResp, errDo := httpClient.Do(httpReq) + if errDo != nil { + recordAPIResponseError(ctx, e.cfg, errDo) + if errors.Is(errDo, context.Canceled) || errors.Is(errDo, context.DeadlineExceeded) { + return nil, errDo } lastStatus = 0 lastBody = nil - lastErr = errRead + lastErr = errDo if idx+1 < len(baseURLs) { - log.Debugf("antigravity executor: read error on base url %s, retrying with fallback base url: %s", baseURL, baseURLs[idx+1]) + log.Debugf("antigravity executor: request error on base url %s, retrying with fallback base url: %s", baseURL, baseURLs[idx+1]) continue } - err = errRead + err = errDo return nil, err } - appendAPIResponseChunk(ctx, e.cfg, bodyBytes) - lastStatus = httpResp.StatusCode - lastBody = append([]byte(nil), bodyBytes...) - lastErr = nil - if httpResp.StatusCode == http.StatusTooManyRequests && idx+1 < len(baseURLs) { - log.Debugf("antigravity executor: rate limited on base url %s, retrying with fallback base url: %s", baseURL, baseURLs[idx+1]) - continue + recordAPIResponseMetadata(ctx, e.cfg, httpResp.StatusCode, httpResp.Header.Clone()) + if httpResp.StatusCode < http.StatusOK || httpResp.StatusCode >= http.StatusMultipleChoices { + bodyBytes, errRead := io.ReadAll(httpResp.Body) + if errClose := httpResp.Body.Close(); errClose != nil { + log.Errorf("antigravity executor: close response body error: %v", errClose) + } + if errRead != nil { + recordAPIResponseError(ctx, e.cfg, errRead) + if errors.Is(errRead, context.Canceled) || errors.Is(errRead, context.DeadlineExceeded) { + err = errRead + return nil, err + } + if errCtx := ctx.Err(); errCtx != nil { + err = errCtx + return nil, err + } + lastStatus = 0 + lastBody = nil + lastErr = errRead + if idx+1 < len(baseURLs) { + log.Debugf("antigravity executor: read error on base url %s, retrying with fallback base url: %s", baseURL, baseURLs[idx+1]) + continue + } + err = errRead + return nil, err + } + appendAPIResponseChunk(ctx, e.cfg, bodyBytes) + lastStatus = httpResp.StatusCode + lastBody = append([]byte(nil), bodyBytes...) + lastErr = nil + if httpResp.StatusCode == http.StatusTooManyRequests && idx+1 < len(baseURLs) { + log.Debugf("antigravity executor: rate limited on base url %s, retrying with fallback base url: %s", baseURL, baseURLs[idx+1]) + continue + } + if antigravityShouldRetryNoCapacity(httpResp.StatusCode, bodyBytes) { + if idx+1 < len(baseURLs) { + log.Debugf("antigravity executor: no capacity on base url %s, retrying with fallback base url: %s", baseURL, baseURLs[idx+1]) + continue + } + if attempt+1 < attempts { + delay := antigravityNoCapacityRetryDelay(attempt) + log.Debugf("antigravity executor: no capacity for model %s, retrying in %s (attempt %d/%d)", baseModel, delay, attempt+1, attempts) + if errWait := antigravityWait(ctx, delay); errWait != nil { + return nil, errWait + } + continue attemptLoop + } + } + sErr := statusErr{code: httpResp.StatusCode, msg: string(bodyBytes)} + if httpResp.StatusCode == http.StatusTooManyRequests { + if retryAfter, parseErr := parseRetryDelay(bodyBytes); parseErr == nil && retryAfter != nil { + sErr.retryAfter = retryAfter + } + } + err = sErr + return nil, err } - sErr := statusErr{code: httpResp.StatusCode, msg: string(bodyBytes)} - if httpResp.StatusCode == http.StatusTooManyRequests { - if retryAfter, parseErr := parseRetryDelay(bodyBytes); parseErr == nil && retryAfter != nil { + + out := make(chan cliproxyexecutor.StreamChunk) + stream = out + go func(resp *http.Response) { + defer close(out) + defer func() { + if errClose := resp.Body.Close(); errClose != nil { + log.Errorf("antigravity executor: close response body error: %v", errClose) + } + }() + scanner := bufio.NewScanner(resp.Body) + scanner.Buffer(nil, streamScannerBuffer) + var param any + for scanner.Scan() { + line := scanner.Bytes() + appendAPIResponseChunk(ctx, e.cfg, line) + + // Filter usage metadata for all models + // Only retain usage statistics in the terminal chunk + line = FilterSSEUsageMetadata(line) + + payload := jsonPayload(line) + if payload == nil { + continue + } + + if detail, ok := parseAntigravityStreamUsage(payload); ok { + reporter.publish(ctx, detail) + } + + chunks := sdktranslator.TranslateStream(ctx, to, from, req.Model, bytes.Clone(opts.OriginalRequest), translated, bytes.Clone(payload), ¶m) + for i := range chunks { + out <- cliproxyexecutor.StreamChunk{Payload: []byte(chunks[i])} + } + } + tail := sdktranslator.TranslateStream(ctx, to, from, req.Model, bytes.Clone(opts.OriginalRequest), translated, []byte("[DONE]"), ¶m) + for i := range tail { + out <- cliproxyexecutor.StreamChunk{Payload: []byte(tail[i])} + } + if errScan := scanner.Err(); errScan != nil { + recordAPIResponseError(ctx, e.cfg, errScan) + reporter.publishFailure(ctx) + out <- cliproxyexecutor.StreamChunk{Err: errScan} + } else { + reporter.ensurePublished(ctx) + } + }(httpResp) + return stream, nil + } + + switch { + case lastStatus != 0: + sErr := statusErr{code: lastStatus, msg: string(lastBody)} + if lastStatus == http.StatusTooManyRequests { + if retryAfter, parseErr := parseRetryDelay(lastBody); parseErr == nil && retryAfter != nil { sErr.retryAfter = retryAfter } } err = sErr - return nil, err + case lastErr != nil: + err = lastErr + default: + err = statusErr{code: http.StatusServiceUnavailable, msg: "antigravity executor: no base url available"} } - - out := make(chan cliproxyexecutor.StreamChunk) - stream = out - go func(resp *http.Response) { - defer close(out) - defer func() { - if errClose := resp.Body.Close(); errClose != nil { - log.Errorf("antigravity executor: close response body error: %v", errClose) - } - }() - scanner := bufio.NewScanner(resp.Body) - scanner.Buffer(nil, streamScannerBuffer) - var param any - for scanner.Scan() { - line := scanner.Bytes() - appendAPIResponseChunk(ctx, e.cfg, line) - - // Filter usage metadata for all models - // Only retain usage statistics in the terminal chunk - line = FilterSSEUsageMetadata(line) - - payload := jsonPayload(line) - if payload == nil { - continue - } - - if detail, ok := parseAntigravityStreamUsage(payload); ok { - reporter.publish(ctx, detail) - } - - chunks := sdktranslator.TranslateStream(ctx, to, from, req.Model, bytes.Clone(opts.OriginalRequest), translated, bytes.Clone(payload), ¶m) - for i := range chunks { - out <- cliproxyexecutor.StreamChunk{Payload: []byte(chunks[i])} - } - } - tail := sdktranslator.TranslateStream(ctx, to, from, req.Model, bytes.Clone(opts.OriginalRequest), translated, []byte("[DONE]"), ¶m) - for i := range tail { - out <- cliproxyexecutor.StreamChunk{Payload: []byte(tail[i])} - } - if errScan := scanner.Err(); errScan != nil { - recordAPIResponseError(ctx, e.cfg, errScan) - reporter.publishFailure(ctx) - out <- cliproxyexecutor.StreamChunk{Err: errScan} - } else { - reporter.ensurePublished(ctx) - } - }(httpResp) - return stream, nil + return nil, err } - switch { - case lastStatus != 0: - sErr := statusErr{code: lastStatus, msg: string(lastBody)} - if lastStatus == http.StatusTooManyRequests { - if retryAfter, parseErr := parseRetryDelay(lastBody); parseErr == nil && retryAfter != nil { - sErr.retryAfter = retryAfter - } - } - err = sErr - case lastErr != nil: - err = lastErr - default: - err = statusErr{code: http.StatusServiceUnavailable, msg: "antigravity executor: no base url available"} - } return nil, err } @@ -997,7 +1060,7 @@ func FetchAntigravityModels(ctx context.Context, auth *cliproxyauth.Auth, cfg *c now := time.Now().Unix() modelConfig := registry.GetAntigravityModelConfig() models := make([]*registry.ModelInfo, 0, len(result.Map())) - for originalName := range result.Map() { + for originalName, modelData := range result.Map() { modelID := strings.TrimSpace(originalName) if modelID == "" { continue @@ -1007,12 +1070,18 @@ func FetchAntigravityModels(ctx context.Context, auth *cliproxyauth.Auth, cfg *c continue } modelCfg := modelConfig[modelID] - modelName := modelID + + // Extract displayName from upstream response, fallback to modelID + displayName := modelData.Get("displayName").String() + if displayName == "" { + displayName = modelID + } + modelInfo := ®istry.ModelInfo{ ID: modelID, - Name: modelName, - Description: modelID, - DisplayName: modelID, + Name: modelID, + Description: displayName, + DisplayName: displayName, Version: modelID, Object: "model", Created: now, @@ -1378,14 +1447,65 @@ func resolveUserAgent(auth *cliproxyauth.Auth) string { return defaultAntigravityAgent } +func antigravityRetryAttempts(cfg *config.Config) int { + if cfg == nil { + return 1 + } + retry := cfg.RequestRetry + if retry < 0 { + retry = 0 + } + attempts := retry + 1 + if attempts < 1 { + return 1 + } + return attempts +} + +func antigravityShouldRetryNoCapacity(statusCode int, body []byte) bool { + if statusCode != http.StatusServiceUnavailable { + return false + } + if len(body) == 0 { + return false + } + msg := strings.ToLower(string(body)) + return strings.Contains(msg, "no capacity available") +} + +func antigravityNoCapacityRetryDelay(attempt int) time.Duration { + if attempt < 0 { + attempt = 0 + } + delay := time.Duration(attempt+1) * 250 * time.Millisecond + if delay > 2*time.Second { + delay = 2 * time.Second + } + return delay +} + +func antigravityWait(ctx context.Context, wait time.Duration) error { + if wait <= 0 { + return nil + } + timer := time.NewTimer(wait) + defer timer.Stop() + select { + case <-ctx.Done(): + return ctx.Err() + case <-timer.C: + return nil + } +} + func antigravityBaseURLFallbackOrder(auth *cliproxyauth.Auth) []string { if base := resolveCustomAntigravityBaseURL(auth); base != "" { return []string{base} } return []string{ - antigravitySandboxBaseURLDaily, antigravityBaseURLDaily, - antigravityBaseURLProd, + antigravitySandboxBaseURLDaily, + // antigravityBaseURLProd, } } @@ -1470,7 +1590,7 @@ func generateProjectID() string { return adj + "-" + noun + "-" + randomPart } -// Embed is not supported by the Antigravity executor. +// Embed is not supported by the antigravity executor. func (e *AntigravityExecutor) Embed(context.Context, *cliproxyauth.Auth, cliproxyexecutor.Request, cliproxyexecutor.Options) (cliproxyexecutor.Response, error) { return cliproxyexecutor.Response{}, fmt.Errorf("antigravity executor does not support embeddings") } diff --git a/internal/runtime/executor/claude_executor.go b/internal/runtime/executor/claude_executor.go index 38108888..c237275a 100644 --- a/internal/runtime/executor/claude_executor.go +++ b/internal/runtime/executor/claude_executor.go @@ -163,7 +163,7 @@ func (e *ClaudeExecutor) Execute(ctx context.Context, auth *cliproxyauth.Auth, r if httpResp.StatusCode < 200 || httpResp.StatusCode >= 300 { b, _ := io.ReadAll(httpResp.Body) appendAPIResponseChunk(ctx, e.cfg, b) - log.Debugf("request error, error status: %d, error body: %s", httpResp.StatusCode, summarizeErrorBody(httpResp.Header.Get("Content-Type"), b)) + logWithRequestID(ctx).Debugf("request error, error status: %d, error message: %s", httpResp.StatusCode, summarizeErrorBody(httpResp.Header.Get("Content-Type"), b)) err = statusErr{code: httpResp.StatusCode, msg: string(b)} if errClose := httpResp.Body.Close(); errClose != nil { log.Errorf("response body close error: %v", errClose) @@ -295,7 +295,7 @@ func (e *ClaudeExecutor) ExecuteStream(ctx context.Context, auth *cliproxyauth.A if httpResp.StatusCode < 200 || httpResp.StatusCode >= 300 { b, _ := io.ReadAll(httpResp.Body) appendAPIResponseChunk(ctx, e.cfg, b) - log.Debugf("request error, error status: %d, error body: %s", httpResp.StatusCode, summarizeErrorBody(httpResp.Header.Get("Content-Type"), b)) + logWithRequestID(ctx).Debugf("request error, error status: %d, error message: %s", httpResp.StatusCode, summarizeErrorBody(httpResp.Header.Get("Content-Type"), b)) if errClose := httpResp.Body.Close(); errClose != nil { log.Errorf("response body close error: %v", errClose) } @@ -733,6 +733,11 @@ func applyClaudeToolPrefix(body []byte, prefix string) []byte { if tools := gjson.GetBytes(body, "tools"); tools.Exists() && tools.IsArray() { tools.ForEach(func(index, tool gjson.Result) bool { + // Skip built-in tools (web_search, code_execution, etc.) which have + // a "type" field and require their name to remain unchanged. + if tool.Get("type").Exists() && tool.Get("type").String() != "" { + return true + } name := tool.Get("name").String() if name == "" || strings.HasPrefix(name, prefix) { return true @@ -986,7 +991,7 @@ func applyCloaking(ctx context.Context, cfg *config.Config, auth *cliproxyauth.A return payload } -// Embed is not supported by the Claude executor. +// Embed is not supported by the claude executor. func (e *ClaudeExecutor) Embed(context.Context, *cliproxyauth.Auth, cliproxyexecutor.Request, cliproxyexecutor.Options) (cliproxyexecutor.Response, error) { return cliproxyexecutor.Response{}, fmt.Errorf("claude executor does not support embeddings") } diff --git a/internal/runtime/executor/claude_executor_test.go b/internal/runtime/executor/claude_executor_test.go index 05f5b60c..36fb7ad4 100644 --- a/internal/runtime/executor/claude_executor_test.go +++ b/internal/runtime/executor/claude_executor_test.go @@ -25,6 +25,18 @@ func TestApplyClaudeToolPrefix(t *testing.T) { } } +func TestApplyClaudeToolPrefix_SkipsBuiltinTools(t *testing.T) { + input := []byte(`{"tools":[{"type":"web_search_20250305","name":"web_search"},{"name":"my_custom_tool","input_schema":{"type":"object"}}]}`) + out := applyClaudeToolPrefix(input, "proxy_") + + if got := gjson.GetBytes(out, "tools.0.name").String(); got != "web_search" { + t.Fatalf("built-in tool name should not be prefixed: tools.0.name = %q, want %q", got, "web_search") + } + if got := gjson.GetBytes(out, "tools.1.name").String(); got != "proxy_my_custom_tool" { + t.Fatalf("custom tool should be prefixed: tools.1.name = %q, want %q", got, "proxy_my_custom_tool") + } +} + func TestStripClaudeToolPrefixFromResponse(t *testing.T) { input := []byte(`{"content":[{"type":"tool_use","name":"proxy_alpha","id":"t1","input":{}},{"type":"tool_use","name":"bravo","id":"t2","input":{}}]}`) out := stripClaudeToolPrefixFromResponse(input, "proxy_") diff --git a/internal/runtime/executor/codex_executor.go b/internal/runtime/executor/codex_executor.go index 16874c23..2a39e065 100644 --- a/internal/runtime/executor/codex_executor.go +++ b/internal/runtime/executor/codex_executor.go @@ -150,7 +150,7 @@ func (e *CodexExecutor) Execute(ctx context.Context, auth *cliproxyauth.Auth, re if httpResp.StatusCode < 200 || httpResp.StatusCode >= 300 { b, _ := io.ReadAll(httpResp.Body) appendAPIResponseChunk(ctx, e.cfg, b) - log.Debugf("request error, error status: %d, error body: %s", httpResp.StatusCode, summarizeErrorBody(httpResp.Header.Get("Content-Type"), b)) + logWithRequestID(ctx).Debugf("request error, error status: %d, error message: %s", httpResp.StatusCode, summarizeErrorBody(httpResp.Header.Get("Content-Type"), b)) err = statusErr{code: httpResp.StatusCode, msg: string(b)} return resp, err } @@ -265,7 +265,7 @@ func (e *CodexExecutor) ExecuteStream(ctx context.Context, auth *cliproxyauth.Au return nil, readErr } appendAPIResponseChunk(ctx, e.cfg, data) - log.Debugf("request error, error status: %d, error body: %s", httpResp.StatusCode, summarizeErrorBody(httpResp.Header.Get("Content-Type"), data)) + logWithRequestID(ctx).Debugf("request error, error status: %d, error message: %s", httpResp.StatusCode, summarizeErrorBody(httpResp.Header.Get("Content-Type"), data)) err = statusErr{code: httpResp.StatusCode, msg: string(data)} return nil, err } @@ -643,7 +643,7 @@ func (e *CodexExecutor) resolveCodexConfig(auth *cliproxyauth.Auth) *config.Code return nil } -// Embed is not supported by the Codex executor. +// Embed is not supported by the codex executor. func (e *CodexExecutor) Embed(context.Context, *cliproxyauth.Auth, cliproxyexecutor.Request, cliproxyexecutor.Options) (cliproxyexecutor.Response, error) { return cliproxyexecutor.Response{}, fmt.Errorf("codex executor does not support embeddings") } diff --git a/internal/runtime/executor/gemini_cli_executor.go b/internal/runtime/executor/gemini_cli_executor.go index 631eb9c5..678dc75e 100644 --- a/internal/runtime/executor/gemini_cli_executor.go +++ b/internal/runtime/executor/gemini_cli_executor.go @@ -227,7 +227,7 @@ func (e *GeminiCLIExecutor) Execute(ctx context.Context, auth *cliproxyauth.Auth lastStatus = httpResp.StatusCode lastBody = append([]byte(nil), data...) - log.Debugf("request error, error status: %d, error body: %s", httpResp.StatusCode, summarizeErrorBody(httpResp.Header.Get("Content-Type"), data)) + logWithRequestID(ctx).Debugf("request error, error status: %d, error message: %s", httpResp.StatusCode, summarizeErrorBody(httpResp.Header.Get("Content-Type"), data)) if httpResp.StatusCode == 429 { if idx+1 < len(models) { log.Debugf("gemini cli executor: rate limited, retrying with next model: %s", models[idx+1]) @@ -360,7 +360,7 @@ func (e *GeminiCLIExecutor) ExecuteStream(ctx context.Context, auth *cliproxyaut appendAPIResponseChunk(ctx, e.cfg, data) lastStatus = httpResp.StatusCode lastBody = append([]byte(nil), data...) - log.Debugf("request error, error status: %d, error body: %s", httpResp.StatusCode, summarizeErrorBody(httpResp.Header.Get("Content-Type"), data)) + logWithRequestID(ctx).Debugf("request error, error status: %d, error message: %s", httpResp.StatusCode, summarizeErrorBody(httpResp.Header.Get("Content-Type"), data)) if httpResp.StatusCode == 429 { if idx+1 < len(models) { log.Debugf("gemini cli executor: rate limited, retrying with next model: %s", models[idx+1]) @@ -900,7 +900,7 @@ func parseRetryDelay(errorBody []byte) (*time.Duration, error) { return nil, fmt.Errorf("no RetryInfo found") } -// Embed is not supported by the GeminiCLI executor. +// Embed is not supported by the gemini cli executor. func (e *GeminiCLIExecutor) Embed(context.Context, *cliproxyauth.Auth, cliproxyexecutor.Request, cliproxyexecutor.Options) (cliproxyexecutor.Response, error) { return cliproxyexecutor.Response{}, fmt.Errorf("gemini cli executor does not support embeddings") } diff --git a/internal/runtime/executor/gemini_executor.go b/internal/runtime/executor/gemini_executor.go index ee285b62..5bb16408 100644 --- a/internal/runtime/executor/gemini_executor.go +++ b/internal/runtime/executor/gemini_executor.go @@ -188,7 +188,7 @@ func (e *GeminiExecutor) Execute(ctx context.Context, auth *cliproxyauth.Auth, r if httpResp.StatusCode < 200 || httpResp.StatusCode >= 300 { b, _ := io.ReadAll(httpResp.Body) appendAPIResponseChunk(ctx, e.cfg, b) - log.Debugf("request error, error status: %d, error body: %s", httpResp.StatusCode, summarizeErrorBody(httpResp.Header.Get("Content-Type"), b)) + logWithRequestID(ctx).Debugf("request error, error status: %d, error message: %s", httpResp.StatusCode, summarizeErrorBody(httpResp.Header.Get("Content-Type"), b)) err = statusErr{code: httpResp.StatusCode, msg: string(b)} return resp, err } @@ -282,7 +282,7 @@ func (e *GeminiExecutor) ExecuteStream(ctx context.Context, auth *cliproxyauth.A if httpResp.StatusCode < 200 || httpResp.StatusCode >= 300 { b, _ := io.ReadAll(httpResp.Body) appendAPIResponseChunk(ctx, e.cfg, b) - log.Debugf("request error, error status: %d, error body: %s", httpResp.StatusCode, summarizeErrorBody(httpResp.Header.Get("Content-Type"), b)) + logWithRequestID(ctx).Debugf("request error, error status: %d, error message: %s", httpResp.StatusCode, summarizeErrorBody(httpResp.Header.Get("Content-Type"), b)) if errClose := httpResp.Body.Close(); errClose != nil { log.Errorf("gemini executor: close response body error: %v", errClose) } @@ -402,7 +402,7 @@ func (e *GeminiExecutor) CountTokens(ctx context.Context, auth *cliproxyauth.Aut } appendAPIResponseChunk(ctx, e.cfg, data) if resp.StatusCode < 200 || resp.StatusCode >= 300 { - log.Debugf("request error, error status: %d, error body: %s", resp.StatusCode, summarizeErrorBody(resp.Header.Get("Content-Type"), data)) + logWithRequestID(ctx).Debugf("request error, error status: %d, error message: %s", resp.StatusCode, summarizeErrorBody(resp.Header.Get("Content-Type"), data)) return cliproxyexecutor.Response{}, statusErr{code: resp.StatusCode, msg: string(data)} } @@ -541,7 +541,7 @@ func fixGeminiImageAspectRatio(modelName string, rawJSON []byte) []byte { return rawJSON } -// Embed is not supported by the Gemini executor. +// Embed is not supported by the gemini executor. func (e *GeminiExecutor) Embed(context.Context, *cliproxyauth.Auth, cliproxyexecutor.Request, cliproxyexecutor.Options) (cliproxyexecutor.Response, error) { return cliproxyexecutor.Response{}, fmt.Errorf("gemini executor does not support embeddings") } diff --git a/internal/runtime/executor/gemini_vertex_executor.go b/internal/runtime/executor/gemini_vertex_executor.go index 2951d92d..c3174ef7 100644 --- a/internal/runtime/executor/gemini_vertex_executor.go +++ b/internal/runtime/executor/gemini_vertex_executor.go @@ -389,7 +389,7 @@ func (e *GeminiVertexExecutor) executeWithServiceAccount(ctx context.Context, au if httpResp.StatusCode < 200 || httpResp.StatusCode >= 300 { b, _ := io.ReadAll(httpResp.Body) appendAPIResponseChunk(ctx, e.cfg, b) - log.Debugf("request error, error status: %d, error body: %s", httpResp.StatusCode, summarizeErrorBody(httpResp.Header.Get("Content-Type"), b)) + logWithRequestID(ctx).Debugf("request error, error status: %d, error message: %s", httpResp.StatusCode, summarizeErrorBody(httpResp.Header.Get("Content-Type"), b)) err = statusErr{code: httpResp.StatusCode, msg: string(b)} return resp, err } @@ -503,7 +503,7 @@ func (e *GeminiVertexExecutor) executeWithAPIKey(ctx context.Context, auth *clip if httpResp.StatusCode < 200 || httpResp.StatusCode >= 300 { b, _ := io.ReadAll(httpResp.Body) appendAPIResponseChunk(ctx, e.cfg, b) - log.Debugf("request error, error status: %d, error body: %s", httpResp.StatusCode, summarizeErrorBody(httpResp.Header.Get("Content-Type"), b)) + logWithRequestID(ctx).Debugf("request error, error status: %d, error message: %s", httpResp.StatusCode, summarizeErrorBody(httpResp.Header.Get("Content-Type"), b)) err = statusErr{code: httpResp.StatusCode, msg: string(b)} return resp, err } @@ -601,7 +601,7 @@ func (e *GeminiVertexExecutor) executeStreamWithServiceAccount(ctx context.Conte if httpResp.StatusCode < 200 || httpResp.StatusCode >= 300 { b, _ := io.ReadAll(httpResp.Body) appendAPIResponseChunk(ctx, e.cfg, b) - log.Debugf("request error, error status: %d, error body: %s", httpResp.StatusCode, summarizeErrorBody(httpResp.Header.Get("Content-Type"), b)) + logWithRequestID(ctx).Debugf("request error, error status: %d, error message: %s", httpResp.StatusCode, summarizeErrorBody(httpResp.Header.Get("Content-Type"), b)) if errClose := httpResp.Body.Close(); errClose != nil { log.Errorf("vertex executor: close response body error: %v", errClose) } @@ -725,7 +725,7 @@ func (e *GeminiVertexExecutor) executeStreamWithAPIKey(ctx context.Context, auth if httpResp.StatusCode < 200 || httpResp.StatusCode >= 300 { b, _ := io.ReadAll(httpResp.Body) appendAPIResponseChunk(ctx, e.cfg, b) - log.Debugf("request error, error status: %d, error body: %s", httpResp.StatusCode, summarizeErrorBody(httpResp.Header.Get("Content-Type"), b)) + logWithRequestID(ctx).Debugf("request error, error status: %d, error message: %s", httpResp.StatusCode, summarizeErrorBody(httpResp.Header.Get("Content-Type"), b)) if errClose := httpResp.Body.Close(); errClose != nil { log.Errorf("vertex executor: close response body error: %v", errClose) } @@ -838,7 +838,7 @@ func (e *GeminiVertexExecutor) countTokensWithServiceAccount(ctx context.Context if httpResp.StatusCode < 200 || httpResp.StatusCode >= 300 { b, _ := io.ReadAll(httpResp.Body) appendAPIResponseChunk(ctx, e.cfg, b) - log.Debugf("request error, error status: %d, error body: %s", httpResp.StatusCode, summarizeErrorBody(httpResp.Header.Get("Content-Type"), b)) + logWithRequestID(ctx).Debugf("request error, error status: %d, error message: %s", httpResp.StatusCode, summarizeErrorBody(httpResp.Header.Get("Content-Type"), b)) return cliproxyexecutor.Response{}, statusErr{code: httpResp.StatusCode, msg: string(b)} } data, errRead := io.ReadAll(httpResp.Body) @@ -922,7 +922,7 @@ func (e *GeminiVertexExecutor) countTokensWithAPIKey(ctx context.Context, auth * if httpResp.StatusCode < 200 || httpResp.StatusCode >= 300 { b, _ := io.ReadAll(httpResp.Body) appendAPIResponseChunk(ctx, e.cfg, b) - log.Debugf("request error, error status: %d, error body: %s", httpResp.StatusCode, summarizeErrorBody(httpResp.Header.Get("Content-Type"), b)) + logWithRequestID(ctx).Debugf("request error, error status: %d, error message: %s", httpResp.StatusCode, summarizeErrorBody(httpResp.Header.Get("Content-Type"), b)) return cliproxyexecutor.Response{}, statusErr{code: httpResp.StatusCode, msg: string(b)} } data, errRead := io.ReadAll(httpResp.Body) @@ -1057,7 +1057,7 @@ func (e *GeminiVertexExecutor) resolveVertexConfig(auth *cliproxyauth.Auth) *con return nil } -// Embed is not supported by the GeminiVertex executor. +// Embed is not supported by the gemini vertex executor. func (e *GeminiVertexExecutor) Embed(context.Context, *cliproxyauth.Auth, cliproxyexecutor.Request, cliproxyexecutor.Options) (cliproxyexecutor.Response, error) { return cliproxyexecutor.Response{}, fmt.Errorf("gemini vertex executor does not support embeddings") } diff --git a/internal/runtime/executor/logging_helpers.go b/internal/runtime/executor/logging_helpers.go index 26931f53..e9876243 100644 --- a/internal/runtime/executor/logging_helpers.go +++ b/internal/runtime/executor/logging_helpers.go @@ -12,7 +12,10 @@ import ( "github.com/gin-gonic/gin" "github.com/router-for-me/CLIProxyAPI/v6/internal/config" + "github.com/router-for-me/CLIProxyAPI/v6/internal/logging" "github.com/router-for-me/CLIProxyAPI/v6/internal/util" + log "github.com/sirupsen/logrus" + "github.com/tidwall/gjson" ) const ( @@ -304,11 +307,7 @@ func formatAuthInfo(info upstreamRequestLog) string { parts = append(parts, "type=api_key") } case "oauth": - if authValue != "" { - parts = append(parts, fmt.Sprintf("type=oauth account=%s", authValue)) - } else { - parts = append(parts, "type=oauth") - } + parts = append(parts, "type=oauth") default: if authType != "" { if authValue != "" { @@ -336,6 +335,12 @@ func summarizeErrorBody(contentType string, body []byte) string { } return "[html body omitted]" } + + // Try to extract error message from JSON response + if message := extractJSONErrorMessage(body); message != "" { + return message + } + return string(body) } @@ -362,3 +367,25 @@ func extractHTMLTitle(body []byte) string { } return strings.Join(strings.Fields(title), " ") } + +// extractJSONErrorMessage attempts to extract error.message from JSON error responses +func extractJSONErrorMessage(body []byte) string { + result := gjson.GetBytes(body, "error.message") + if result.Exists() && result.String() != "" { + return result.String() + } + return "" +} + +// logWithRequestID returns a logrus Entry with request_id field populated from context. +// If no request ID is found in context, it returns the standard logger. +func logWithRequestID(ctx context.Context) *log.Entry { + if ctx == nil { + return log.NewEntry(log.StandardLogger()) + } + requestID := logging.GetRequestID(ctx) + if requestID == "" { + return log.NewEntry(log.StandardLogger()) + } + return log.WithField("request_id", requestID) +} diff --git a/internal/runtime/executor/openai_compat_executor.go b/internal/runtime/executor/openai_compat_executor.go index 779d82d6..0cd33d13 100644 --- a/internal/runtime/executor/openai_compat_executor.go +++ b/internal/runtime/executor/openai_compat_executor.go @@ -146,7 +146,7 @@ func (e *OpenAICompatExecutor) Execute(ctx context.Context, auth *cliproxyauth.A if httpResp.StatusCode < 200 || httpResp.StatusCode >= 300 { b, _ := io.ReadAll(httpResp.Body) appendAPIResponseChunk(ctx, e.cfg, b) - log.Debugf("request error, error status: %d, error body: %s", httpResp.StatusCode, summarizeErrorBody(httpResp.Header.Get("Content-Type"), b)) + logWithRequestID(ctx).Debugf("request error, error status: %d, error message: %s", httpResp.StatusCode, summarizeErrorBody(httpResp.Header.Get("Content-Type"), b)) err = statusErr{code: httpResp.StatusCode, msg: string(b)} return resp, err } @@ -239,7 +239,7 @@ func (e *OpenAICompatExecutor) ExecuteStream(ctx context.Context, auth *cliproxy if httpResp.StatusCode < 200 || httpResp.StatusCode >= 300 { b, _ := io.ReadAll(httpResp.Body) appendAPIResponseChunk(ctx, e.cfg, b) - log.Debugf("request error, error status: %d, error body: %s", httpResp.StatusCode, summarizeErrorBody(httpResp.Header.Get("Content-Type"), b)) + logWithRequestID(ctx).Debugf("request error, error status: %d, error message: %s", httpResp.StatusCode, summarizeErrorBody(httpResp.Header.Get("Content-Type"), b)) if errClose := httpResp.Body.Close(); errClose != nil { log.Errorf("openai compat executor: close response body error: %v", errClose) } @@ -387,7 +387,7 @@ func (e statusErr) Error() string { func (e statusErr) StatusCode() int { return e.code } func (e statusErr) RetryAfter() *time.Duration { return e.retryAfter } -// Embed is not supported by the OpenAICompat executor. +// Embed is not supported by the openai compat executor. func (e *OpenAICompatExecutor) Embed(context.Context, *cliproxyauth.Auth, cliproxyexecutor.Request, cliproxyexecutor.Options) (cliproxyexecutor.Response, error) { return cliproxyexecutor.Response{}, fmt.Errorf("openai compat executor does not support embeddings") } diff --git a/internal/runtime/executor/qwen_executor.go b/internal/runtime/executor/qwen_executor.go index bc2e679c..25eaa45e 100644 --- a/internal/runtime/executor/qwen_executor.go +++ b/internal/runtime/executor/qwen_executor.go @@ -133,7 +133,7 @@ func (e *QwenExecutor) Execute(ctx context.Context, auth *cliproxyauth.Auth, req if httpResp.StatusCode < 200 || httpResp.StatusCode >= 300 { b, _ := io.ReadAll(httpResp.Body) appendAPIResponseChunk(ctx, e.cfg, b) - log.Debugf("request error, error status: %d, error body: %s", httpResp.StatusCode, summarizeErrorBody(httpResp.Header.Get("Content-Type"), b)) + logWithRequestID(ctx).Debugf("request error, error status: %d, error message: %s", httpResp.StatusCode, summarizeErrorBody(httpResp.Header.Get("Content-Type"), b)) err = statusErr{code: httpResp.StatusCode, msg: string(b)} return resp, err } @@ -222,7 +222,7 @@ func (e *QwenExecutor) ExecuteStream(ctx context.Context, auth *cliproxyauth.Aut if httpResp.StatusCode < 200 || httpResp.StatusCode >= 300 { b, _ := io.ReadAll(httpResp.Body) appendAPIResponseChunk(ctx, e.cfg, b) - log.Debugf("request error, error status: %d, error body: %s", httpResp.StatusCode, summarizeErrorBody(httpResp.Header.Get("Content-Type"), b)) + logWithRequestID(ctx).Debugf("request error, error status: %d, error message: %s", httpResp.StatusCode, summarizeErrorBody(httpResp.Header.Get("Content-Type"), b)) if errClose := httpResp.Body.Close(); errClose != nil { log.Errorf("qwen executor: close response body error: %v", errClose) } @@ -368,7 +368,7 @@ func qwenCreds(a *cliproxyauth.Auth) (token, baseURL string) { return } -// Embed is not supported by the Qwen executor. +// Embed is not supported by the qwen executor. func (e *QwenExecutor) Embed(context.Context, *cliproxyauth.Auth, cliproxyexecutor.Request, cliproxyexecutor.Options) (cliproxyexecutor.Response, error) { return cliproxyexecutor.Response{}, fmt.Errorf("qwen executor does not support embeddings") } diff --git a/internal/translator/openai/claude/openai_claude_request_test.go b/internal/translator/openai/claude/openai_claude_request_test.go new file mode 100644 index 00000000..d08de1b2 --- /dev/null +++ b/internal/translator/openai/claude/openai_claude_request_test.go @@ -0,0 +1,590 @@ +package claude + +import ( + "testing" + + "github.com/tidwall/gjson" +) + +// TestConvertClaudeRequestToOpenAI_ThinkingToReasoningContent tests the mapping +// of Claude thinking content to OpenAI reasoning_content field. +func TestConvertClaudeRequestToOpenAI_ThinkingToReasoningContent(t *testing.T) { + tests := []struct { + name string + inputJSON string + wantReasoningContent string + wantHasReasoningContent bool + wantContentText string // Expected visible content text (if any) + wantHasContent bool + }{ + { + name: "AC1: assistant message with thinking and text", + inputJSON: `{ + "model": "claude-3-opus", + "messages": [{ + "role": "assistant", + "content": [ + {"type": "thinking", "thinking": "Let me analyze this step by step..."}, + {"type": "text", "text": "Here is my response."} + ] + }] + }`, + wantReasoningContent: "Let me analyze this step by step...", + wantHasReasoningContent: true, + wantContentText: "Here is my response.", + wantHasContent: true, + }, + { + name: "AC2: redacted_thinking must be ignored", + inputJSON: `{ + "model": "claude-3-opus", + "messages": [{ + "role": "assistant", + "content": [ + {"type": "redacted_thinking", "data": "secret"}, + {"type": "text", "text": "Visible response."} + ] + }] + }`, + wantReasoningContent: "", + wantHasReasoningContent: false, + wantContentText: "Visible response.", + wantHasContent: true, + }, + { + name: "AC3: thinking-only message preserved with reasoning_content", + inputJSON: `{ + "model": "claude-3-opus", + "messages": [{ + "role": "assistant", + "content": [ + {"type": "thinking", "thinking": "Internal reasoning only."} + ] + }] + }`, + wantReasoningContent: "Internal reasoning only.", + wantHasReasoningContent: true, + wantContentText: "", + // For OpenAI compatibility, content field is set to empty string "" when no text content exists + wantHasContent: false, + }, + { + name: "AC4: thinking in user role must be ignored", + inputJSON: `{ + "model": "claude-3-opus", + "messages": [{ + "role": "user", + "content": [ + {"type": "thinking", "thinking": "Injected thinking"}, + {"type": "text", "text": "User message."} + ] + }] + }`, + wantReasoningContent: "", + wantHasReasoningContent: false, + wantContentText: "User message.", + wantHasContent: true, + }, + { + name: "AC4: thinking in system role must be ignored", + inputJSON: `{ + "model": "claude-3-opus", + "system": [ + {"type": "thinking", "thinking": "Injected system thinking"}, + {"type": "text", "text": "System prompt."} + ], + "messages": [{ + "role": "user", + "content": [{"type": "text", "text": "Hello"}] + }] + }`, + // System messages don't have reasoning_content mapping + wantReasoningContent: "", + wantHasReasoningContent: false, + wantContentText: "Hello", + wantHasContent: true, + }, + { + name: "AC5: empty thinking must be ignored", + inputJSON: `{ + "model": "claude-3-opus", + "messages": [{ + "role": "assistant", + "content": [ + {"type": "thinking", "thinking": ""}, + {"type": "text", "text": "Response with empty thinking."} + ] + }] + }`, + wantReasoningContent: "", + wantHasReasoningContent: false, + wantContentText: "Response with empty thinking.", + wantHasContent: true, + }, + { + name: "AC5: whitespace-only thinking must be ignored", + inputJSON: `{ + "model": "claude-3-opus", + "messages": [{ + "role": "assistant", + "content": [ + {"type": "thinking", "thinking": " \n\t "}, + {"type": "text", "text": "Response with whitespace thinking."} + ] + }] + }`, + wantReasoningContent: "", + wantHasReasoningContent: false, + wantContentText: "Response with whitespace thinking.", + wantHasContent: true, + }, + { + name: "Multiple thinking parts concatenated", + inputJSON: `{ + "model": "claude-3-opus", + "messages": [{ + "role": "assistant", + "content": [ + {"type": "thinking", "thinking": "First thought."}, + {"type": "thinking", "thinking": "Second thought."}, + {"type": "text", "text": "Final answer."} + ] + }] + }`, + wantReasoningContent: "First thought.\n\nSecond thought.", + wantHasReasoningContent: true, + wantContentText: "Final answer.", + wantHasContent: true, + }, + { + name: "Mixed thinking and redacted_thinking", + inputJSON: `{ + "model": "claude-3-opus", + "messages": [{ + "role": "assistant", + "content": [ + {"type": "thinking", "thinking": "Visible thought."}, + {"type": "redacted_thinking", "data": "hidden"}, + {"type": "text", "text": "Answer."} + ] + }] + }`, + wantReasoningContent: "Visible thought.", + wantHasReasoningContent: true, + wantContentText: "Answer.", + wantHasContent: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result := ConvertClaudeRequestToOpenAI("test-model", []byte(tt.inputJSON), false) + resultJSON := gjson.ParseBytes(result) + + // Find the relevant message + messages := resultJSON.Get("messages").Array() + if len(messages) < 1 { + if tt.wantHasReasoningContent || tt.wantHasContent { + t.Fatalf("Expected at least 1 message, got %d", len(messages)) + } + return + } + + // Check the last non-system message + var targetMsg gjson.Result + for i := len(messages) - 1; i >= 0; i-- { + if messages[i].Get("role").String() != "system" { + targetMsg = messages[i] + break + } + } + + // Check reasoning_content + gotReasoningContent := targetMsg.Get("reasoning_content").String() + gotHasReasoningContent := targetMsg.Get("reasoning_content").Exists() + + if gotHasReasoningContent != tt.wantHasReasoningContent { + t.Errorf("reasoning_content existence = %v, want %v", gotHasReasoningContent, tt.wantHasReasoningContent) + } + + if gotReasoningContent != tt.wantReasoningContent { + t.Errorf("reasoning_content = %q, want %q", gotReasoningContent, tt.wantReasoningContent) + } + + // Check content + content := targetMsg.Get("content") + // content has meaningful content if it's a non-empty array, or a non-empty string + var gotHasContent bool + switch { + case content.IsArray(): + gotHasContent = len(content.Array()) > 0 + case content.Type == gjson.String: + gotHasContent = content.String() != "" + default: + gotHasContent = false + } + + if gotHasContent != tt.wantHasContent { + t.Errorf("content existence = %v, want %v", gotHasContent, tt.wantHasContent) + } + + if tt.wantHasContent && tt.wantContentText != "" { + // Find text content + var foundText string + content.ForEach(func(_, v gjson.Result) bool { + if v.Get("type").String() == "text" { + foundText = v.Get("text").String() + return false + } + return true + }) + if foundText != tt.wantContentText { + t.Errorf("content text = %q, want %q", foundText, tt.wantContentText) + } + } + }) + } +} + +// TestConvertClaudeRequestToOpenAI_ThinkingOnlyMessagePreserved tests AC3: +// that a message with only thinking content is preserved (not dropped). +func TestConvertClaudeRequestToOpenAI_ThinkingOnlyMessagePreserved(t *testing.T) { + inputJSON := `{ + "model": "claude-3-opus", + "messages": [ + { + "role": "user", + "content": [{"type": "text", "text": "What is 2+2?"}] + }, + { + "role": "assistant", + "content": [{"type": "thinking", "thinking": "Let me calculate: 2+2=4"}] + }, + { + "role": "user", + "content": [{"type": "text", "text": "Thanks"}] + } + ] + }` + + result := ConvertClaudeRequestToOpenAI("test-model", []byte(inputJSON), false) + resultJSON := gjson.ParseBytes(result) + + messages := resultJSON.Get("messages").Array() + + // Should have: user + assistant (thinking-only) + user = 3 messages + if len(messages) != 3 { + t.Fatalf("Expected 3 messages, got %d. Messages: %v", len(messages), resultJSON.Get("messages").Raw) + } + + // Check the assistant message (index 1) has reasoning_content + assistantMsg := messages[1] + if assistantMsg.Get("role").String() != "assistant" { + t.Errorf("Expected message[1] to be assistant, got %s", assistantMsg.Get("role").String()) + } + + if !assistantMsg.Get("reasoning_content").Exists() { + t.Error("Expected assistant message to have reasoning_content") + } + + if assistantMsg.Get("reasoning_content").String() != "Let me calculate: 2+2=4" { + t.Errorf("Unexpected reasoning_content: %s", assistantMsg.Get("reasoning_content").String()) + } +} + +func TestConvertClaudeRequestToOpenAI_SystemMessageScenarios(t *testing.T) { + tests := []struct { + name string + inputJSON string + wantHasSys bool + wantSysText string + }{ + { + name: "No system field", + inputJSON: `{ + "model": "claude-3-opus", + "messages": [{"role": "user", "content": "hello"}] + }`, + wantHasSys: false, + }, + { + name: "Empty string system field", + inputJSON: `{ + "model": "claude-3-opus", + "system": "", + "messages": [{"role": "user", "content": "hello"}] + }`, + wantHasSys: false, + }, + { + name: "String system field", + inputJSON: `{ + "model": "claude-3-opus", + "system": "Be helpful", + "messages": [{"role": "user", "content": "hello"}] + }`, + wantHasSys: true, + wantSysText: "Be helpful", + }, + { + name: "Array system field with text", + inputJSON: `{ + "model": "claude-3-opus", + "system": [{"type": "text", "text": "Array system"}], + "messages": [{"role": "user", "content": "hello"}] + }`, + wantHasSys: true, + wantSysText: "Array system", + }, + { + name: "Array system field with multiple text blocks", + inputJSON: `{ + "model": "claude-3-opus", + "system": [ + {"type": "text", "text": "Block 1"}, + {"type": "text", "text": "Block 2"} + ], + "messages": [{"role": "user", "content": "hello"}] + }`, + wantHasSys: true, + wantSysText: "Block 2", // We will update the test logic to check all blocks or specifically the second one + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result := ConvertClaudeRequestToOpenAI("test-model", []byte(tt.inputJSON), false) + resultJSON := gjson.ParseBytes(result) + messages := resultJSON.Get("messages").Array() + + hasSys := false + var sysMsg gjson.Result + if len(messages) > 0 && messages[0].Get("role").String() == "system" { + hasSys = true + sysMsg = messages[0] + } + + if hasSys != tt.wantHasSys { + t.Errorf("got hasSystem = %v, want %v", hasSys, tt.wantHasSys) + } + + if tt.wantHasSys { + // Check content - it could be string or array in OpenAI + content := sysMsg.Get("content") + var gotText string + if content.IsArray() { + arr := content.Array() + if len(arr) > 0 { + // Get the last element's text for validation + gotText = arr[len(arr)-1].Get("text").String() + } + } else { + gotText = content.String() + } + + if tt.wantSysText != "" && gotText != tt.wantSysText { + t.Errorf("got system text = %q, want %q", gotText, tt.wantSysText) + } + } + }) + } +} + +func TestConvertClaudeRequestToOpenAI_ToolResultOrderAndContent(t *testing.T) { + inputJSON := `{ + "model": "claude-3-opus", + "messages": [ + { + "role": "assistant", + "content": [ + {"type": "tool_use", "id": "call_1", "name": "do_work", "input": {"a": 1}} + ] + }, + { + "role": "user", + "content": [ + {"type": "text", "text": "before"}, + {"type": "tool_result", "tool_use_id": "call_1", "content": [{"type":"text","text":"tool ok"}]}, + {"type": "text", "text": "after"} + ] + } + ] + }` + + result := ConvertClaudeRequestToOpenAI("test-model", []byte(inputJSON), false) + resultJSON := gjson.ParseBytes(result) + messages := resultJSON.Get("messages").Array() + + // OpenAI requires: tool messages MUST immediately follow assistant(tool_calls). + // Correct order: assistant(tool_calls) + tool(result) + user(before+after) + if len(messages) != 3 { + t.Fatalf("Expected 3 messages, got %d. Messages: %s", len(messages), resultJSON.Get("messages").Raw) + } + + if messages[0].Get("role").String() != "assistant" || !messages[0].Get("tool_calls").Exists() { + t.Fatalf("Expected messages[0] to be assistant tool_calls, got %s: %s", messages[0].Get("role").String(), messages[0].Raw) + } + + // tool message MUST immediately follow assistant(tool_calls) per OpenAI spec + if messages[1].Get("role").String() != "tool" { + t.Fatalf("Expected messages[1] to be tool (must follow tool_calls), got %s", messages[1].Get("role").String()) + } + if got := messages[1].Get("tool_call_id").String(); got != "call_1" { + t.Fatalf("Expected tool_call_id %q, got %q", "call_1", got) + } + if got := messages[1].Get("content").String(); got != "tool ok" { + t.Fatalf("Expected tool content %q, got %q", "tool ok", got) + } + + // User message comes after tool message + if messages[2].Get("role").String() != "user" { + t.Fatalf("Expected messages[2] to be user, got %s", messages[2].Get("role").String()) + } + // User message should contain both "before" and "after" text + if got := messages[2].Get("content.0.text").String(); got != "before" { + t.Fatalf("Expected user text[0] %q, got %q", "before", got) + } + if got := messages[2].Get("content.1.text").String(); got != "after" { + t.Fatalf("Expected user text[1] %q, got %q", "after", got) + } +} + +func TestConvertClaudeRequestToOpenAI_ToolResultObjectContent(t *testing.T) { + inputJSON := `{ + "model": "claude-3-opus", + "messages": [ + { + "role": "assistant", + "content": [ + {"type": "tool_use", "id": "call_1", "name": "do_work", "input": {"a": 1}} + ] + }, + { + "role": "user", + "content": [ + {"type": "tool_result", "tool_use_id": "call_1", "content": {"foo": "bar"}} + ] + } + ] + }` + + result := ConvertClaudeRequestToOpenAI("test-model", []byte(inputJSON), false) + resultJSON := gjson.ParseBytes(result) + messages := resultJSON.Get("messages").Array() + + // assistant(tool_calls) + tool(result) + if len(messages) != 2 { + t.Fatalf("Expected 2 messages, got %d. Messages: %s", len(messages), resultJSON.Get("messages").Raw) + } + + if messages[1].Get("role").String() != "tool" { + t.Fatalf("Expected messages[1] to be tool, got %s", messages[1].Get("role").String()) + } + + toolContent := messages[1].Get("content").String() + parsed := gjson.Parse(toolContent) + if parsed.Get("foo").String() != "bar" { + t.Fatalf("Expected tool content JSON foo=bar, got %q", toolContent) + } +} + +func TestConvertClaudeRequestToOpenAI_AssistantTextToolUseTextOrder(t *testing.T) { + inputJSON := `{ + "model": "claude-3-opus", + "messages": [ + { + "role": "assistant", + "content": [ + {"type": "text", "text": "pre"}, + {"type": "tool_use", "id": "call_1", "name": "do_work", "input": {"a": 1}}, + {"type": "text", "text": "post"} + ] + } + ] + }` + + result := ConvertClaudeRequestToOpenAI("test-model", []byte(inputJSON), false) + resultJSON := gjson.ParseBytes(result) + messages := resultJSON.Get("messages").Array() + + // New behavior: content + tool_calls unified in single assistant message + // Expect: assistant(content[pre,post] + tool_calls) + if len(messages) != 1 { + t.Fatalf("Expected 1 message, got %d. Messages: %s", len(messages), resultJSON.Get("messages").Raw) + } + + assistantMsg := messages[0] + if assistantMsg.Get("role").String() != "assistant" { + t.Fatalf("Expected messages[0] to be assistant, got %s", assistantMsg.Get("role").String()) + } + + // Should have both content and tool_calls in same message + if !assistantMsg.Get("tool_calls").Exists() { + t.Fatalf("Expected assistant message to have tool_calls") + } + if got := assistantMsg.Get("tool_calls.0.id").String(); got != "call_1" { + t.Fatalf("Expected tool_call id %q, got %q", "call_1", got) + } + if got := assistantMsg.Get("tool_calls.0.function.name").String(); got != "do_work" { + t.Fatalf("Expected tool_call name %q, got %q", "do_work", got) + } + + // Content should have both pre and post text + if got := assistantMsg.Get("content.0.text").String(); got != "pre" { + t.Fatalf("Expected content[0] text %q, got %q", "pre", got) + } + if got := assistantMsg.Get("content.1.text").String(); got != "post" { + t.Fatalf("Expected content[1] text %q, got %q", "post", got) + } +} + +func TestConvertClaudeRequestToOpenAI_AssistantThinkingToolUseThinkingSplit(t *testing.T) { + inputJSON := `{ + "model": "claude-3-opus", + "messages": [ + { + "role": "assistant", + "content": [ + {"type": "thinking", "thinking": "t1"}, + {"type": "text", "text": "pre"}, + {"type": "tool_use", "id": "call_1", "name": "do_work", "input": {"a": 1}}, + {"type": "thinking", "thinking": "t2"}, + {"type": "text", "text": "post"} + ] + } + ] + }` + + result := ConvertClaudeRequestToOpenAI("test-model", []byte(inputJSON), false) + resultJSON := gjson.ParseBytes(result) + messages := resultJSON.Get("messages").Array() + + // New behavior: all content, thinking, and tool_calls unified in single assistant message + // Expect: assistant(content[pre,post] + tool_calls + reasoning_content[t1+t2]) + if len(messages) != 1 { + t.Fatalf("Expected 1 message, got %d. Messages: %s", len(messages), resultJSON.Get("messages").Raw) + } + + assistantMsg := messages[0] + if assistantMsg.Get("role").String() != "assistant" { + t.Fatalf("Expected messages[0] to be assistant, got %s", assistantMsg.Get("role").String()) + } + + // Should have content with both pre and post + if got := assistantMsg.Get("content.0.text").String(); got != "pre" { + t.Fatalf("Expected content[0] text %q, got %q", "pre", got) + } + if got := assistantMsg.Get("content.1.text").String(); got != "post" { + t.Fatalf("Expected content[1] text %q, got %q", "post", got) + } + + // Should have tool_calls + if !assistantMsg.Get("tool_calls").Exists() { + t.Fatalf("Expected assistant message to have tool_calls") + } + + // Should have combined reasoning_content from both thinking blocks + if got := assistantMsg.Get("reasoning_content").String(); got != "t1\n\nt2" { + t.Fatalf("Expected reasoning_content %q, got %q", "t1\n\nt2", got) + } +}