package executor import ( "bytes" "context" "errors" "fmt" "io" "net/http" "strings" "sync" "time" "github.com/google/uuid" kiroauth "github.com/router-for-me/CLIProxyAPI/v6/internal/auth/kiro" "github.com/router-for-me/CLIProxyAPI/v6/internal/config" kiroclaude "github.com/router-for-me/CLIProxyAPI/v6/internal/translator/kiro/claude" cliproxyauth "github.com/router-for-me/CLIProxyAPI/v6/sdk/cliproxy/auth" cliproxyexecutor "github.com/router-for-me/CLIProxyAPI/v6/sdk/cliproxy/executor" sdktranslator "github.com/router-for-me/CLIProxyAPI/v6/sdk/translator" log "github.com/sirupsen/logrus" ) const ( // Kiro API common constants kiroContentType = "application/x-amz-json-1.0" kiroAcceptStream = "*/*" // Event Stream frame size constants for boundary protection // AWS Event Stream binary format: prelude (12 bytes) + headers + payload + message_crc (4 bytes) // Prelude consists of: total_length (4) + headers_length (4) + prelude_crc (4) minEventStreamFrameSize = 16 // Minimum: 4(total_len) + 4(headers_len) + 4(prelude_crc) + 4(message_crc) maxEventStreamMsgSize = 10 << 20 // Maximum message length: 10MB // Event Stream error type constants ErrStreamFatal = "fatal" // Connection/authentication errors, not recoverable ErrStreamMalformed = "malformed" // Format errors, data cannot be parsed // kiroUserAgent matches the User-Agent header for Kiro IDE kiroUserAgent = "aws-sdk-rust/1.3.9 os/macos lang/rust/1.87.0" // kiroFullUserAgent is the complete x-amz-user-agent header kiroFullUserAgent = "aws-sdk-rust/1.3.9 ua/2.1 api/ssooidc/1.88.0 os/macos lang/rust/1.87.0 m/E" // Kiro IDE style headers (from kiro2api - for IDC auth) kiroIDEUserAgent = "aws-sdk-js/1.0.18 ua/2.1 os/darwin#25.0.0 lang/js md/nodejs#20.16.0 api/codewhispererstreaming#1.0.18 m/E KiroIDE-0.2.13-66c23a8c5d15afabec89ef9954ef52a119f10d369df04d548fc6c1eac694b0d1" kiroIDEAmzUserAgent = "aws-sdk-js/1.0.18 KiroIDE-0.2.13-66c23a8c5d15afabec89ef9954ef52a119f10d369df04d548fc6c1eac694b0d1" kiroIDEAgentModeSpec = "spec" // Socket retry configuration constants (based on kiro2Api reference implementation) // Maximum number of retry attempts for socket/network errors kiroSocketMaxRetries = 3 // Base delay between retry attempts (uses exponential backoff: delay * 2^attempt) kiroSocketBaseRetryDelay = 1 * time.Second // Maximum delay between retry attempts (cap for exponential backoff) kiroSocketMaxRetryDelay = 30 * time.Second // First token timeout for streaming responses (how long to wait for first response) kiroFirstTokenTimeout = 15 * time.Second // Streaming read timeout (how long to wait between chunks) kiroStreamingReadTimeout = 300 * time.Second ) // retryableHTTPStatusCodes defines HTTP status codes that are considered retryable. // Based on kiro2Api reference: 502 (Bad Gateway), 503 (Service Unavailable), 504 (Gateway Timeout) var retryableHTTPStatusCodes = map[int]bool{ 502: true, // Bad Gateway - upstream server error 503: true, // Service Unavailable - server temporarily overloaded 504: true, // Gateway Timeout - upstream server timeout } // Real-time usage estimation configuration // These control how often usage updates are sent during streaming var ( usageUpdateCharThreshold = 5000 // Send usage update every 5000 characters usageUpdateTimeInterval = 15 * time.Second // Or every 15 seconds, whichever comes first ) // Global FingerprintManager for dynamic User-Agent generation per token // Each token gets a unique fingerprint on first use, which is cached for subsequent requests var ( globalFingerprintManager *kiroauth.FingerprintManager globalFingerprintManagerOnce sync.Once ) // getGlobalFingerprintManager returns the global FingerprintManager instance func getGlobalFingerprintManager() *kiroauth.FingerprintManager { globalFingerprintManagerOnce.Do(func() { globalFingerprintManager = kiroauth.NewFingerprintManager() log.Infof("kiro: initialized global FingerprintManager for dynamic UA generation") }) return globalFingerprintManager } // kiroHTTPClientPool provides a shared HTTP client with connection pooling for Kiro API. var ( kiroHTTPClientPool *http.Client kiroHTTPClientPoolOnce sync.Once ) // kiroEndpointConfig bundles endpoint URL with its compatible Origin and AmzTarget values. // This solves the "triple mismatch" problem where different endpoints require matching // Origin and X-Amz-Target header values. // // Based on reference implementations: // - AIClient-2-API: Uses CodeWhisperer endpoint with AI_EDITOR origin and AmazonCodeWhispererStreamingService target type kiroEndpointConfig struct { URL string // Endpoint URL Origin string // Request Origin: "AI_EDITOR" for Kiro IDE quota AmzTarget string // X-Amz-Target header value Name string // Endpoint name for logging } // kiroEndpointConfigs defines the available Kiro API endpoints with their compatible configurations. // The order determines fallback priority: primary endpoint first, then fallbacks. // // CRITICAL: Each endpoint MUST use its compatible Origin and AmzTarget values: // - CodeWhisperer endpoint (codewhisperer.us-east-1.amazonaws.com): Uses AI_EDITOR origin and AmazonCodeWhispererStreamingService target // // Mismatched combinations will result in 403 Forbidden errors. // // NOTE: CodeWhisperer is the default endpoint because: // 1. Most tokens come from Kiro IDE / VSCode extensions (AWS Builder ID auth) // 2. These tokens use AI_EDITOR origin which is only compatible with CodeWhisperer endpoint // This matches the AIClient-2-API-main project's configuration. var kiroEndpointConfigs = []kiroEndpointConfig{ { URL: "https://codewhisperer.us-east-1.amazonaws.com/generateAssistantResponse", Origin: "AI_EDITOR", AmzTarget: "AmazonCodeWhispererStreamingService.GenerateAssistantResponse", Name: "CodeWhisperer", }, } // KiroExecutor handles requests to AWS CodeWhisperer (Kiro) API. type KiroExecutor struct { cfg *config.Config refreshMu sync.Mutex // Serializes token refresh operations to prevent race conditions } // NewKiroExecutor creates a new Kiro executor instance. func NewKiroExecutor(cfg *config.Config) *KiroExecutor { return &KiroExecutor{cfg: cfg} } // Identifier returns the unique identifier for this executor. func (e *KiroExecutor) Identifier() string { return "kiro" } // Execute sends the request to Kiro API and returns the response. // Supports automatic token refresh on 401/403 errors. func (e *KiroExecutor) Execute(ctx context.Context, auth *cliproxyauth.Auth, req cliproxyexecutor.Request, opts cliproxyexecutor.Options) (resp cliproxyexecutor.Response, err error) { accessToken, profileArn := kiroCredentials(auth) if accessToken == "" { return resp, fmt.Errorf("kiro: access token not found in auth") } // Rate limiting: get token key for tracking tokenKey := getTokenKey(auth) rateLimiter := kiroauth.GetGlobalRateLimiter() cooldownMgr := kiroauth.GetGlobalCooldownManager() // Check if token is in cooldown period if cooldownMgr.IsInCooldown(tokenKey) { remaining := cooldownMgr.GetRemainingCooldown(tokenKey) reason := cooldownMgr.GetCooldownReason(tokenKey) log.Warnf("kiro: token %s is in cooldown (reason: %s), remaining: %v", tokenKey, reason, remaining) return resp, fmt.Errorf("kiro: token is in cooldown for %v (reason: %s)", remaining, reason) } // Wait for rate limiter before proceeding log.Debugf("kiro: waiting for rate limiter for token %s", tokenKey) rateLimiter.WaitForToken(tokenKey) log.Debugf("kiro: rate limiter cleared for token %s", tokenKey) reporter := newUsageReporter(ctx, e.Identifier(), req.Model, auth) defer reporter.trackFailure(ctx, &err) // Check if token is expired before making request if e.isTokenExpired(accessToken) { log.Infof("kiro: access token expired, attempting recovery") // Try to reload token from file first (background refresher may have updated it) reloadedAuth, reloadErr := e.reloadAuthFromFile(auth) if reloadErr == nil && reloadedAuth != nil { auth = reloadedAuth accessToken, profileArn = kiroCredentials(auth) log.Infof("kiro: recovered token from file (background refresh), expires_at: %v", auth.Metadata["expires_at"]) } else { // File reload failed, attempt active refresh log.Debugf("kiro: file reload failed (%v), attempting active refresh", reloadErr) refreshedAuth, refreshErr := e.Refresh(ctx, auth) if refreshErr != nil { log.Warnf("kiro: pre-request token refresh failed: %v", refreshErr) } else if refreshedAuth != nil { auth = refreshedAuth // Persist the refreshed auth to file so subsequent requests use it if persistErr := e.persistRefreshedAuth(auth); persistErr != nil { log.Warnf("kiro: failed to persist refreshed auth: %v", persistErr) } accessToken, profileArn = kiroCredentials(auth) log.Infof("kiro: token refreshed successfully before request") } } } from := opts.SourceFormat to := sdktranslator.FromString("kiro") body := sdktranslator.TranslateRequest(from, to, req.Model, bytes.Clone(req.Payload), true) kiroModelID := e.mapModelToKiro(req.Model) // Determine agentic mode and effective profile ARN using helper functions isAgentic, isChatOnly := determineAgenticMode(req.Model) effectiveProfileArn := getEffectiveProfileArnWithWarning(auth, profileArn) // Execute with retry on 401/403 and 429 (quota exhausted) resp, err = e.executeWithRetry(ctx, auth, req, opts, accessToken, effectiveProfileArn, nil, body, from, to, reporter, "", kiroModelID, isAgentic, isChatOnly, tokenKey) return resp, err } // executeWithRetry performs the actual HTTP request with automatic retry on auth errors. // Supports automatic fallback between endpoints with different quotas: // - Amazon Q endpoint (CLI origin) uses Amazon Q Developer quota // - CodeWhisperer endpoint (AI_EDITOR origin) uses Kiro IDE quota // Also supports multi-endpoint fallback similar to Antigravity implementation. // tokenKey is used for rate limiting and cooldown tracking. func (e *KiroExecutor) executeWithRetry(ctx context.Context, auth *cliproxyauth.Auth, req cliproxyexecutor.Request, opts cliproxyexecutor.Options, accessToken, profileArn string, kiroPayload, body []byte, from, to sdktranslator.Format, reporter *usageReporter, currentOrigin, kiroModelID string, isAgentic, isChatOnly bool, tokenKey string) (cliproxyexecutor.Response, error) { var resp cliproxyexecutor.Response maxRetries := 2 // Allow retries for token refresh + endpoint fallback rateLimiter := kiroauth.GetGlobalRateLimiter() cooldownMgr := kiroauth.GetGlobalCooldownManager() endpointConfigs := getKiroEndpointConfigs(auth) var last429Err error for endpointIdx := 0; endpointIdx < len(endpointConfigs); endpointIdx++ { endpointConfig := endpointConfigs[endpointIdx] url := endpointConfig.URL // Use this endpoint's compatible Origin (critical for avoiding 403 errors) currentOrigin = endpointConfig.Origin // Rebuild payload with the correct origin for this endpoint // Each endpoint requires its matching Origin value in the request body kiroPayload, _ = buildKiroPayloadForFormat(body, kiroModelID, profileArn, currentOrigin, isAgentic, isChatOnly, from, opts.Headers) log.Debugf("kiro: trying endpoint %d/%d: %s (Name: %s, Origin: %s)", endpointIdx+1, len(endpointConfigs), url, endpointConfig.Name, currentOrigin) for attempt := 0; attempt <= maxRetries; attempt++ { // Apply human-like delay before first request (not on retries) if attempt == 0 && endpointIdx == 0 { kiroauth.ApplyHumanLikeDelay() } httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(kiroPayload)) if err != nil { return resp, err } httpReq.Header.Set("Content-Type", kiroContentType) httpReq.Header.Set("Accept", kiroAcceptStream) // Use endpoint-specific X-Amz-Target (critical for avoiding 403 errors) httpReq.Header.Set("X-Amz-Target", endpointConfig.AmzTarget) // Apply dynamic fingerprint-based headers applyDynamicFingerprint(httpReq, auth) httpReq.Header.Set("Amz-Sdk-Request", "attempt=1; max=3") httpReq.Header.Set("Amz-Sdk-Invocation-Id", uuid.New().String()) // Bearer token authentication for all auth types (Builder ID, IDC, social, etc.) httpReq.Header.Set("Authorization", "Bearer "+accessToken) var authID, authLabel, authType, authValue string if auth != nil { authID = auth.ID authLabel = auth.Label authType, authValue = auth.AccountInfo() } recordAPIRequest(ctx, e.cfg, upstreamRequestLog{ URL: url, Method: http.MethodPost, Headers: httpReq.Header.Clone(), Body: kiroPayload, Provider: e.Identifier(), AuthID: authID, AuthLabel: authLabel, AuthType: authType, AuthValue: authValue, }) httpClient := newKiroHTTPClientWithPooling(ctx, e.cfg, auth, 120*time.Second) httpResp, err := httpClient.Do(httpReq) if err != nil { // Check for context cancellation first - client disconnected, not a server error if errors.Is(err, context.Canceled) { log.Debugf("kiro: request canceled by client (context.Canceled)") return resp, statusErr{code: 499, msg: "client canceled request"} } // Check for context deadline exceeded - request timed out if errors.Is(err, context.DeadlineExceeded) { log.Debugf("kiro: request timed out (context.DeadlineExceeded)") return resp, statusErr{code: http.StatusGatewayTimeout, msg: "upstream request timed out"} } recordAPIResponseError(ctx, e.cfg, err) // Enhanced socket retry: Check if error is retryable retryCfg := defaultRetryConfig() if isRetryableError(err) && attempt < retryCfg.MaxRetries { delay := calculateRetryDelay(attempt, retryCfg) logRetryAttempt(attempt, retryCfg.MaxRetries, fmt.Sprintf("socket error: %v", err), delay, endpointConfig.Name) time.Sleep(delay) continue } return resp, err } recordAPIResponseMetadata(ctx, e.cfg, httpResp.StatusCode, httpResp.Header.Clone()) // Handle 429 errors (quota exhausted) - try next endpoint if httpResp.StatusCode == 429 { respBody, _ := io.ReadAll(httpResp.Body) _ = httpResp.Body.Close() appendAPIResponseChunk(ctx, e.cfg, respBody) // Record failure and set cooldown for 429 rateLimiter.MarkTokenFailed(tokenKey) cooldownDuration := kiroauth.CalculateCooldownFor429(attempt) cooldownMgr.SetCooldown(tokenKey, cooldownDuration, kiroauth.CooldownReason429) log.Warnf("kiro: rate limit hit (429), token %s set to cooldown for %v", tokenKey, cooldownDuration) // Preserve last 429 so callers can correctly backoff when all endpoints are exhausted last429Err = statusErr{code: httpResp.StatusCode, msg: string(respBody)} log.Warnf("kiro: %s endpoint quota exhausted (429), will try next endpoint, body: %s", endpointConfig.Name, summarizeErrorBody(httpResp.Header.Get("Content-Type"), respBody)) // Break inner retry loop to try next endpoint break } // Handle 5xx server errors with exponential backoff retry if httpResp.StatusCode >= 500 && httpResp.StatusCode < 600 { respBody, _ := io.ReadAll(httpResp.Body) _ = httpResp.Body.Close() appendAPIResponseChunk(ctx, e.cfg, respBody) retryCfg := defaultRetryConfig() if isRetryableHTTPStatus(httpResp.StatusCode) && attempt < retryCfg.MaxRetries { delay := calculateRetryDelay(attempt, retryCfg) logRetryAttempt(attempt, retryCfg.MaxRetries, fmt.Sprintf("HTTP %d", httpResp.StatusCode), delay, endpointConfig.Name) time.Sleep(delay) continue } else if attempt < maxRetries { backoff := time.Duration(1< 30*time.Second { backoff = 30 * time.Second } log.Warnf("kiro: server error %d, retrying in %v (attempt %d/%d)", httpResp.StatusCode, backoff, attempt+1, maxRetries) time.Sleep(backoff) continue } log.Errorf("kiro: server error %d after %d retries", httpResp.StatusCode, maxRetries) return resp, statusErr{code: httpResp.StatusCode, msg: string(respBody)} } // Handle 401 errors with token refresh and retry if httpResp.StatusCode == 401 { respBody, _ := io.ReadAll(httpResp.Body) _ = httpResp.Body.Close() appendAPIResponseChunk(ctx, e.cfg, respBody) log.Warnf("kiro: received 401 error, attempting token refresh") refreshedAuth, refreshErr := e.Refresh(ctx, auth) if refreshErr != nil { log.Errorf("kiro: token refresh failed: %v", refreshErr) return resp, statusErr{code: httpResp.StatusCode, msg: string(respBody)} } if refreshedAuth != nil { auth = refreshedAuth if persistErr := e.persistRefreshedAuth(auth); persistErr != nil { log.Warnf("kiro: failed to persist refreshed auth: %v", persistErr) } accessToken, profileArn = kiroCredentials(auth) kiroPayload, _ = buildKiroPayloadForFormat(body, kiroModelID, profileArn, currentOrigin, isAgentic, isChatOnly, from, opts.Headers) if attempt < maxRetries { log.Infof("kiro: token refreshed successfully, retrying request (attempt %d/%d)", attempt+1, maxRetries+1) continue } } log.Warnf("kiro request error, status: 401, body: %s", summarizeErrorBody(httpResp.Header.Get("Content-Type"), respBody)) return resp, statusErr{code: httpResp.StatusCode, msg: string(respBody)} } // Handle 402 errors - Monthly Limit Reached if httpResp.StatusCode == 402 { respBody, _ := io.ReadAll(httpResp.Body) _ = httpResp.Body.Close() appendAPIResponseChunk(ctx, e.cfg, respBody) log.Warnf("kiro: received 402 (monthly limit). Upstream body: %s", string(respBody)) return resp, statusErr{code: httpResp.StatusCode, msg: string(respBody)} } // Handle 403 errors - Access Denied / Token Expired if httpResp.StatusCode == 403 { respBody, _ := io.ReadAll(httpResp.Body) _ = httpResp.Body.Close() appendAPIResponseChunk(ctx, e.cfg, respBody) log.Warnf("kiro: received 403 error (attempt %d/%d), body: %s", attempt+1, maxRetries+1, summarizeErrorBody(httpResp.Header.Get("Content-Type"), respBody)) respBodyStr := string(respBody) // Check for SUSPENDED status - return immediately without retry if strings.Contains(respBodyStr, "SUSPENDED") || strings.Contains(respBodyStr, "TEMPORARILY_SUSPENDED") { rateLimiter.CheckAndMarkSuspended(tokenKey, respBodyStr) cooldownMgr.SetCooldown(tokenKey, kiroauth.LongCooldown, kiroauth.CooldownReasonSuspended) log.Errorf("kiro: account is suspended, token %s set to cooldown for %v", tokenKey, kiroauth.LongCooldown) return resp, statusErr{code: httpResp.StatusCode, msg: "account suspended: " + string(respBody)} } // Check if this looks like a token-related 403 isTokenRelated := strings.Contains(respBodyStr, "token") || strings.Contains(respBodyStr, "expired") || strings.Contains(respBodyStr, "invalid") || strings.Contains(respBodyStr, "unauthorized") if isTokenRelated && attempt < maxRetries { log.Warnf("kiro: 403 appears token-related, attempting token refresh") refreshedAuth, refreshErr := e.Refresh(ctx, auth) if refreshErr != nil { log.Errorf("kiro: token refresh failed: %v", refreshErr) return resp, statusErr{code: httpResp.StatusCode, msg: string(respBody)} } if refreshedAuth != nil { auth = refreshedAuth if persistErr := e.persistRefreshedAuth(auth); persistErr != nil { log.Warnf("kiro: failed to persist refreshed auth: %v", persistErr) } accessToken, profileArn = kiroCredentials(auth) kiroPayload, _ = buildKiroPayloadForFormat(body, kiroModelID, profileArn, currentOrigin, isAgentic, isChatOnly, from, opts.Headers) log.Infof("kiro: token refreshed for 403, retrying request") continue } } log.Warnf("kiro: 403 error, returning immediately (no endpoint switch)") return resp, statusErr{code: httpResp.StatusCode, msg: string(respBody)} } if httpResp.StatusCode < 200 || httpResp.StatusCode >= 300 { b, _ := io.ReadAll(httpResp.Body) appendAPIResponseChunk(ctx, e.cfg, b) log.Debugf("kiro request error, status: %d, body: %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) } return resp, err } defer func() { if errClose := httpResp.Body.Close(); errClose != nil { log.Errorf("response body close error: %v", errClose) } }() content, toolUses, usageInfo, stopReason, err := e.parseEventStream(httpResp.Body) if err != nil { recordAPIResponseError(ctx, e.cfg, err) return resp, err } // Fallback for usage if missing from upstream if usageInfo.TotalTokens == 0 { if enc, encErr := getTokenizer(req.Model); encErr == nil { if inp, countErr := countOpenAIChatTokens(enc, opts.OriginalRequest); countErr == nil { usageInfo.InputTokens = inp } } if len(content) > 0 { if enc, encErr := getTokenizer(req.Model); encErr == nil { if tokenCount, countErr := enc.Count(content); countErr == nil { usageInfo.OutputTokens = int64(tokenCount) } } if usageInfo.OutputTokens == 0 { usageInfo.OutputTokens = int64(len(content) / 4) if usageInfo.OutputTokens == 0 { usageInfo.OutputTokens = 1 } } } usageInfo.TotalTokens = usageInfo.InputTokens + usageInfo.OutputTokens } appendAPIResponseChunk(ctx, e.cfg, []byte(content)) reporter.publish(ctx, usageInfo) // Record success for rate limiting rateLimiter.MarkTokenSuccess(tokenKey) log.Debugf("kiro: request successful, token %s marked as success", tokenKey) // Build response in Claude format for Kiro translator kiroResponse := kiroclaude.BuildClaudeResponse(content, toolUses, req.Model, usageInfo, stopReason) out := sdktranslator.TranslateNonStream(ctx, to, from, req.Model, bytes.Clone(opts.OriginalRequest), body, kiroResponse, nil) resp = cliproxyexecutor.Response{Payload: []byte(out)} return resp, nil } } // All endpoints exhausted if last429Err != nil { return resp, last429Err } return resp, fmt.Errorf("kiro: all endpoints exhausted") } // ExecuteStream handles streaming requests to Kiro API. // Supports automatic token refresh on 401/403 errors and quota fallback on 429. func (e *KiroExecutor) ExecuteStream(ctx context.Context, auth *cliproxyauth.Auth, req cliproxyexecutor.Request, opts cliproxyexecutor.Options) (stream <-chan cliproxyexecutor.StreamChunk, err error) { accessToken, profileArn := kiroCredentials(auth) if accessToken == "" { return nil, fmt.Errorf("kiro: access token not found in auth") } // Rate limiting: get token key for tracking tokenKey := getTokenKey(auth) rateLimiter := kiroauth.GetGlobalRateLimiter() cooldownMgr := kiroauth.GetGlobalCooldownManager() // Check if token is in cooldown period if cooldownMgr.IsInCooldown(tokenKey) { remaining := cooldownMgr.GetRemainingCooldown(tokenKey) reason := cooldownMgr.GetCooldownReason(tokenKey) log.Warnf("kiro: token %s is in cooldown (reason: %s), remaining: %v", tokenKey, reason, remaining) return nil, fmt.Errorf("kiro: token is in cooldown for %v (reason: %s)", remaining, reason) } // Wait for rate limiter before proceeding log.Debugf("kiro: stream waiting for rate limiter for token %s", tokenKey) rateLimiter.WaitForToken(tokenKey) log.Debugf("kiro: stream rate limiter cleared for token %s", tokenKey) reporter := newUsageReporter(ctx, e.Identifier(), req.Model, auth) defer reporter.trackFailure(ctx, &err) // Check if token is expired before making request if e.isTokenExpired(accessToken) { log.Infof("kiro: access token expired, attempting recovery before stream request") reloadedAuth, reloadErr := e.reloadAuthFromFile(auth) if reloadErr == nil && reloadedAuth != nil { auth = reloadedAuth accessToken, profileArn = kiroCredentials(auth) log.Infof("kiro: recovered token from file (background refresh) for stream, expires_at: %v", auth.Metadata["expires_at"]) } else { log.Debugf("kiro: file reload failed (%v), attempting active refresh for stream", reloadErr) refreshedAuth, refreshErr := e.Refresh(ctx, auth) if refreshErr != nil { log.Warnf("kiro: pre-request token refresh failed: %v", refreshErr) } else if refreshedAuth != nil { auth = refreshedAuth if persistErr := e.persistRefreshedAuth(auth); persistErr != nil { log.Warnf("kiro: failed to persist refreshed auth: %v", persistErr) } accessToken, profileArn = kiroCredentials(auth) log.Infof("kiro: token refreshed successfully before stream request") } } } from := opts.SourceFormat to := sdktranslator.FromString("kiro") body := sdktranslator.TranslateRequest(from, to, req.Model, bytes.Clone(req.Payload), true) kiroModelID := e.mapModelToKiro(req.Model) // Determine agentic mode and effective profile ARN using helper functions isAgentic, isChatOnly := determineAgenticMode(req.Model) effectiveProfileArn := getEffectiveProfileArnWithWarning(auth, profileArn) // Execute stream with retry on 401/403 and 429 (quota exhausted) return e.executeStreamWithRetry(ctx, auth, req, opts, accessToken, effectiveProfileArn, nil, body, from, reporter, "", kiroModelID, isAgentic, isChatOnly, tokenKey) } // executeStreamWithRetry performs the streaming HTTP request with automatic retry on auth errors. func (e *KiroExecutor) executeStreamWithRetry(ctx context.Context, auth *cliproxyauth.Auth, req cliproxyexecutor.Request, opts cliproxyexecutor.Options, accessToken, profileArn string, kiroPayload, body []byte, from sdktranslator.Format, reporter *usageReporter, currentOrigin, kiroModelID string, isAgentic, isChatOnly bool, tokenKey string) (<-chan cliproxyexecutor.StreamChunk, error) { maxRetries := 2 rateLimiter := kiroauth.GetGlobalRateLimiter() cooldownMgr := kiroauth.GetGlobalCooldownManager() endpointConfigs := getKiroEndpointConfigs(auth) var last429Err error for endpointIdx := 0; endpointIdx < len(endpointConfigs); endpointIdx++ { endpointConfig := endpointConfigs[endpointIdx] url := endpointConfig.URL currentOrigin = endpointConfig.Origin kiroPayload, thinkingEnabled := buildKiroPayloadForFormat(body, kiroModelID, profileArn, currentOrigin, isAgentic, isChatOnly, from, opts.Headers) log.Debugf("kiro: stream trying endpoint %d/%d: %s (Name: %s, Origin: %s)", endpointIdx+1, len(endpointConfigs), url, endpointConfig.Name, currentOrigin) for attempt := 0; attempt <= maxRetries; attempt++ { if attempt == 0 && endpointIdx == 0 { kiroauth.ApplyHumanLikeDelay() } httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(kiroPayload)) if err != nil { return nil, err } httpReq.Header.Set("Content-Type", kiroContentType) httpReq.Header.Set("Accept", kiroAcceptStream) httpReq.Header.Set("X-Amz-Target", endpointConfig.AmzTarget) applyDynamicFingerprint(httpReq, auth) httpReq.Header.Set("Amz-Sdk-Request", "attempt=1; max=3") httpReq.Header.Set("Amz-Sdk-Invocation-Id", uuid.New().String()) httpReq.Header.Set("Authorization", "Bearer "+accessToken) var authID, authLabel, authType, authValue string if auth != nil { authID = auth.ID authLabel = auth.Label authType, authValue = auth.AccountInfo() } recordAPIRequest(ctx, e.cfg, upstreamRequestLog{ URL: url, Method: http.MethodPost, Headers: httpReq.Header.Clone(), Body: kiroPayload, Provider: e.Identifier(), AuthID: authID, AuthLabel: authLabel, AuthType: authType, AuthValue: authValue, }) httpClient := newKiroHTTPClientWithPooling(ctx, e.cfg, auth, 0) httpResp, err := httpClient.Do(httpReq) if err != nil { recordAPIResponseError(ctx, e.cfg, err) retryCfg := defaultRetryConfig() if isRetryableError(err) && attempt < retryCfg.MaxRetries { delay := calculateRetryDelay(attempt, retryCfg) logRetryAttempt(attempt, retryCfg.MaxRetries, fmt.Sprintf("stream socket error: %v", err), delay, endpointConfig.Name) time.Sleep(delay) continue } return nil, err } recordAPIResponseMetadata(ctx, e.cfg, httpResp.StatusCode, httpResp.Header.Clone()) // Handle 429 errors if httpResp.StatusCode == 429 { respBody, _ := io.ReadAll(httpResp.Body) _ = httpResp.Body.Close() appendAPIResponseChunk(ctx, e.cfg, respBody) rateLimiter.MarkTokenFailed(tokenKey) cooldownDuration := kiroauth.CalculateCooldownFor429(attempt) cooldownMgr.SetCooldown(tokenKey, cooldownDuration, kiroauth.CooldownReason429) log.Warnf("kiro: stream rate limit hit (429), token %s set to cooldown for %v", tokenKey, cooldownDuration) last429Err = statusErr{code: httpResp.StatusCode, msg: string(respBody)} log.Warnf("kiro: stream %s endpoint quota exhausted (429), will try next endpoint, body: %s", endpointConfig.Name, summarizeErrorBody(httpResp.Header.Get("Content-Type"), respBody)) break } // Handle 5xx server errors if httpResp.StatusCode >= 500 && httpResp.StatusCode < 600 { respBody, _ := io.ReadAll(httpResp.Body) _ = httpResp.Body.Close() appendAPIResponseChunk(ctx, e.cfg, respBody) retryCfg := defaultRetryConfig() if isRetryableHTTPStatus(httpResp.StatusCode) && attempt < retryCfg.MaxRetries { delay := calculateRetryDelay(attempt, retryCfg) logRetryAttempt(attempt, retryCfg.MaxRetries, fmt.Sprintf("stream HTTP %d", httpResp.StatusCode), delay, endpointConfig.Name) time.Sleep(delay) continue } else if attempt < maxRetries { backoff := time.Duration(1< 30*time.Second { backoff = 30 * time.Second } log.Warnf("kiro: stream server error %d, retrying in %v (attempt %d/%d)", httpResp.StatusCode, backoff, attempt+1, maxRetries) time.Sleep(backoff) continue } log.Errorf("kiro: stream server error %d after %d retries", httpResp.StatusCode, maxRetries) return nil, statusErr{code: httpResp.StatusCode, msg: string(respBody)} } // Handle 400 errors if httpResp.StatusCode == 400 { respBody, _ := io.ReadAll(httpResp.Body) _ = httpResp.Body.Close() appendAPIResponseChunk(ctx, e.cfg, respBody) log.Warnf("kiro: received 400 error (attempt %d/%d), body: %s", attempt+1, maxRetries+1, summarizeErrorBody(httpResp.Header.Get("Content-Type"), respBody)) return nil, statusErr{code: httpResp.StatusCode, msg: string(respBody)} } // Handle 401 errors if httpResp.StatusCode == 401 { respBody, _ := io.ReadAll(httpResp.Body) _ = httpResp.Body.Close() appendAPIResponseChunk(ctx, e.cfg, respBody) log.Warnf("kiro: stream received 401 error, attempting token refresh") refreshedAuth, refreshErr := e.Refresh(ctx, auth) if refreshErr != nil { log.Errorf("kiro: token refresh failed: %v", refreshErr) return nil, statusErr{code: httpResp.StatusCode, msg: string(respBody)} } if refreshedAuth != nil { auth = refreshedAuth if persistErr := e.persistRefreshedAuth(auth); persistErr != nil { log.Warnf("kiro: failed to persist refreshed auth: %v", persistErr) } accessToken, profileArn = kiroCredentials(auth) kiroPayload, _ = buildKiroPayloadForFormat(body, kiroModelID, profileArn, currentOrigin, isAgentic, isChatOnly, from, opts.Headers) if attempt < maxRetries { log.Infof("kiro: token refreshed successfully, retrying stream request (attempt %d/%d)", attempt+1, maxRetries+1) continue } } log.Warnf("kiro stream error, status: 401, body: %s", string(respBody)) return nil, statusErr{code: httpResp.StatusCode, msg: string(respBody)} } // Handle 402 errors if httpResp.StatusCode == 402 { respBody, _ := io.ReadAll(httpResp.Body) _ = httpResp.Body.Close() appendAPIResponseChunk(ctx, e.cfg, respBody) log.Warnf("kiro: stream received 402 (monthly limit). Upstream body: %s", string(respBody)) return nil, statusErr{code: httpResp.StatusCode, msg: string(respBody)} } // Handle 403 errors if httpResp.StatusCode == 403 { respBody, _ := io.ReadAll(httpResp.Body) _ = httpResp.Body.Close() appendAPIResponseChunk(ctx, e.cfg, respBody) log.Warnf("kiro: stream received 403 error (attempt %d/%d), body: %s", attempt+1, maxRetries+1, string(respBody)) respBodyStr := string(respBody) if strings.Contains(respBodyStr, "SUSPENDED") || strings.Contains(respBodyStr, "TEMPORARILY_SUSPENDED") { rateLimiter.CheckAndMarkSuspended(tokenKey, respBodyStr) cooldownMgr.SetCooldown(tokenKey, kiroauth.LongCooldown, kiroauth.CooldownReasonSuspended) log.Errorf("kiro: stream account is suspended, token %s set to cooldown for %v", tokenKey, kiroauth.LongCooldown) return nil, statusErr{code: httpResp.StatusCode, msg: "account suspended: " + string(respBody)} } isTokenRelated := strings.Contains(respBodyStr, "token") || strings.Contains(respBodyStr, "expired") || strings.Contains(respBodyStr, "invalid") || strings.Contains(respBodyStr, "unauthorized") if isTokenRelated && attempt < maxRetries { log.Warnf("kiro: 403 appears token-related, attempting token refresh") refreshedAuth, refreshErr := e.Refresh(ctx, auth) if refreshErr != nil { log.Errorf("kiro: token refresh failed: %v", refreshErr) return nil, statusErr{code: httpResp.StatusCode, msg: string(respBody)} } if refreshedAuth != nil { auth = refreshedAuth if persistErr := e.persistRefreshedAuth(auth); persistErr != nil { log.Warnf("kiro: failed to persist refreshed auth: %v", persistErr) } accessToken, profileArn = kiroCredentials(auth) kiroPayload, _ = buildKiroPayloadForFormat(body, kiroModelID, profileArn, currentOrigin, isAgentic, isChatOnly, from, opts.Headers) log.Infof("kiro: token refreshed for 403, retrying stream request") continue } } log.Warnf("kiro: 403 error, returning immediately (no endpoint switch)") return nil, statusErr{code: httpResp.StatusCode, msg: string(respBody)} } if httpResp.StatusCode < 200 || httpResp.StatusCode >= 300 { b, _ := io.ReadAll(httpResp.Body) appendAPIResponseChunk(ctx, e.cfg, b) log.Debugf("kiro stream error, status: %d, body: %s", httpResp.StatusCode, string(b)) if errClose := httpResp.Body.Close(); errClose != nil { log.Errorf("response body close error: %v", errClose) } return nil, statusErr{code: httpResp.StatusCode, msg: string(b)} } out := make(chan cliproxyexecutor.StreamChunk) rateLimiter.MarkTokenSuccess(tokenKey) log.Debugf("kiro: stream request successful, token %s marked as success", tokenKey) go func(resp *http.Response, thinkingEnabled bool) { defer close(out) defer func() { if r := recover(); r != nil { log.Errorf("kiro: panic in stream handler: %v", r) out <- cliproxyexecutor.StreamChunk{Err: fmt.Errorf("internal error: %v", r)} } }() defer func() { if errClose := resp.Body.Close(); errClose != nil { log.Errorf("response body close error: %v", errClose) } }() log.Debugf("kiro: stream thinkingEnabled = %v (always true for Kiro)", thinkingEnabled) e.streamToChannel(ctx, resp.Body, out, from, req.Model, opts.OriginalRequest, body, reporter, thinkingEnabled) }(httpResp, thinkingEnabled) return out, nil } } if last429Err != nil { return nil, last429Err } return nil, fmt.Errorf("kiro: stream all endpoints exhausted") } // mapModelToKiro maps external model names to Kiro model IDs. func (e *KiroExecutor) mapModelToKiro(model string) string { modelMap := map[string]string{ // Kiro format (kiro- prefix) "kiro-claude-opus-4-5": "claude-opus-4.5", "kiro-claude-sonnet-4-5": "claude-sonnet-4.5", "kiro-claude-sonnet-4-5-20250929": "claude-sonnet-4.5", "kiro-claude-sonnet-4": "claude-sonnet-4", "kiro-claude-sonnet-4-20250514": "claude-sonnet-4", "kiro-claude-haiku-4-5": "claude-haiku-4.5", "kiro-auto": "auto", // Native format (no prefix) "claude-opus-4-5": "claude-opus-4.5", "claude-opus-4.5": "claude-opus-4.5", "claude-haiku-4-5": "claude-haiku-4.5", "claude-haiku-4.5": "claude-haiku-4.5", "claude-sonnet-4-5": "claude-sonnet-4.5", "claude-sonnet-4-5-20250929": "claude-sonnet-4.5", "claude-sonnet-4.5": "claude-sonnet-4.5", "claude-sonnet-4": "claude-sonnet-4", "claude-sonnet-4-20250514": "claude-sonnet-4", "auto": "auto", // Agentic variants "claude-opus-4.5-agentic": "claude-opus-4.5", "claude-sonnet-4.5-agentic": "claude-sonnet-4.5", "claude-sonnet-4-agentic": "claude-sonnet-4", "claude-haiku-4.5-agentic": "claude-haiku-4.5", "kiro-claude-opus-4-5-agentic": "claude-opus-4.5", "kiro-claude-sonnet-4-5-agentic": "claude-sonnet-4.5", "kiro-claude-sonnet-4-agentic": "claude-sonnet-4", "kiro-claude-haiku-4-5-agentic": "claude-haiku-4.5", } if kiroID, ok := modelMap[model]; ok { return kiroID } // Smart fallback: try to infer model type from name patterns modelLower := strings.ToLower(model) if strings.Contains(modelLower, "haiku") { log.Debugf("kiro: unknown Haiku model '%s', mapping to claude-haiku-4.5", model) return "claude-haiku-4.5" } if strings.Contains(modelLower, "sonnet") { if strings.Contains(modelLower, "3-7") || strings.Contains(modelLower, "3.7") { log.Debugf("kiro: unknown Sonnet 3.7 model '%s', mapping to claude-3-7-sonnet-20250219", model) return "claude-3-7-sonnet-20250219" } if strings.Contains(modelLower, "4-5") || strings.Contains(modelLower, "4.5") { log.Debugf("kiro: unknown Sonnet 4.5 model '%s', mapping to claude-sonnet-4.5", model) return "claude-sonnet-4.5" } log.Debugf("kiro: unknown Sonnet model '%s', mapping to claude-sonnet-4", model) return "claude-sonnet-4" } if strings.Contains(modelLower, "opus") { log.Debugf("kiro: unknown Opus model '%s', mapping to claude-opus-4.5", model) return "claude-opus-4.5" } log.Warnf("kiro: unknown model '%s', falling back to claude-sonnet-4.5", model) return "claude-sonnet-4.5" } // CountTokens counts tokens locally using tiktoken since Kiro API doesn't expose a token counting endpoint. func (e *KiroExecutor) CountTokens(ctx context.Context, auth *cliproxyauth.Auth, req cliproxyexecutor.Request, opts cliproxyexecutor.Options) (cliproxyexecutor.Response, error) { enc, err := getTokenizer(req.Model) if err != nil { log.Warnf("kiro: CountTokens failed to get tokenizer: %v, falling back to estimate", err) estimatedTokens := len(req.Payload) / 4 if estimatedTokens == 0 && len(req.Payload) > 0 { estimatedTokens = 1 } return cliproxyexecutor.Response{ Payload: []byte(fmt.Sprintf(`{"count":%d}`, estimatedTokens)), }, nil } var totalTokens int64 if tokens, countErr := countOpenAIChatTokens(enc, req.Payload); countErr == nil && tokens > 0 { totalTokens = tokens log.Debugf("kiro: CountTokens counted %d tokens using OpenAI chat format", totalTokens) } else { if tokenCount, countErr := enc.Count(string(req.Payload)); countErr == nil { totalTokens = int64(tokenCount) log.Debugf("kiro: CountTokens counted %d tokens from raw payload", totalTokens) } else { totalTokens = int64(len(req.Payload) / 4) if totalTokens == 0 && len(req.Payload) > 0 { totalTokens = 1 } log.Debugf("kiro: CountTokens estimated %d tokens from payload size", totalTokens) } } return cliproxyexecutor.Response{ Payload: []byte(fmt.Sprintf(`{"count":%d}`, totalTokens)), }, nil } // NOTE: Authentication functions moved to kiro_auth.go // NOTE: Request preparation functions moved to kiro_request.go // NOTE: Response parsing functions moved to kiro_response.go