mirror of
https://github.com/Finesssee/ProxyPilot.git
synced 2026-11-18 18:04:20 +00:00
Remove the q.us-east-1.amazonaws.com endpoint config, amazonq- prefixed model mappings, and amazonq- tokenizer prefix check.
950 lines
39 KiB
Go
950 lines
39 KiB
Go
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<<attempt) * time.Second
|
|
if backoff > 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<<attempt) * time.Second
|
|
if backoff > 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
|