Update HF Spaces deployment with latest changes

- Refactored middleware (removed correlation, rate_limit)
- Added security and request_id middleware
- Updated error handling and logging
- Added new plans directory structure
- Various executor and translator improvements

Co-Authored-By: Claude <noreply@anthropic.com>

.factory/settings.json

@@ -51,9 +51,9 @@
     },
     {
       "model": "gemini-3-pro-preview",
-      "displayName": "gemini-3-pro-preview",
-      "baseUrl": "https://shimen-cliproxyapi.hf.space/v1",
-      "apiKey": "shin",
+      "displayName": "Gemini 3 Pro [Google]",
+      "baseUrl": "https://generativelanguage.googleapis.com/v1beta/",
+      "apiKey": "AIzaSyCc9zZOS82GvtbQQFItyHNbQwc7zzxFkN0",
       "provider": "generic-chat-completion-api"
     },
     {

.github/workflows/lint.yml

@@ -0,0 +1,25 @@
+name: Lint
+
+on:
+  push:
+    branches: [main, develop]
+  pull_request:
+    branches: [main, develop]
+
+jobs:
+  golangci:
+    name: lint
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-go@v5
+        with:
+          go-version: '1.24'
+
+      - name: golangci-lint
+        uses: golangci/golangci-lint-action@v6
+        with:
+          version: latest
+          args: --timeout=5m
+          only-new-issues: true

.github/workflows/security.yml

@@ -0,0 +1,67 @@
+name: Security
+
+on:
+  push:
+    branches: [main, develop]
+  pull_request:
+    branches: [main, develop]
+  schedule:
+    - cron: '0 0 * * 0'  # Weekly
+
+jobs:
+  gosec:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Run Gosec
+        uses: securego/gosec@master
+        with:
+          args: '-fmt sarif -out results.sarif ./...'
+
+      - name: Upload SARIF
+        uses: github/codeql-action/upload-sarif@v2
+        with:
+          sarif_file: results.sarif
+
+  govulncheck:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-go@v5
+        with:
+          go-version: '1.24'
+
+      - name: Install govulncheck
+        run: go install golang.org/x/vuln/cmd/govulncheck@latest
+
+      - name: Run govulncheck
+        run: govulncheck ./...
+
+  trivy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Build image
+        run: docker build -t cliproxy:test .
+
+      - name: Run Trivy
+        uses: aquasecurity/trivy-action@master
+        with:
+          image-ref: 'cliproxy:test'
+          format: 'sarif'
+          output: 'trivy-results.sarif'
+
+      - name: Upload SARIF
+        uses: github/codeql-action/upload-sarif@v2
+        with:
+          sarif_file: trivy-results.sarif
+
+  dependency-review:
+    runs-on: ubuntu-latest
+    if: github.event_name == 'pull_request'
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/dependency-review-action@v3

.gitignore

@@ -1,6 +1,7 @@
 # Binaries
 cli-proxy-api
 *.exe
+main
 
 # Configuration
 config.yaml

.golangci.yml

@@ -0,0 +1,101 @@
+run:
+  timeout: 5m
+  go: '1.24'
+  
+issues:
+  exclude-dirs:
+    - management-center
+    - kiro-gateway
+  exclude-rules:
+    # Exclude init() function warnings in translator registrations
+    - path: internal/translator/.*/init\.go
+      linters:
+        - gochecknoinits
+
+    # Exclude underscore variable warnings in test files
+    - path: _test\.go
+      linters:
+        - errcheck
+
+    # Exclude long function warnings in handlers (will refactor separately)
+    - path: internal/api/handlers/
+      linters:
+        - funlen
+        - gocognit
+
+  exclude-use-default: false
+  max-issues-per-linter: 0
+  max-same-issues: 0
+
+linters:
+  enable:
+    # Default
+    - errcheck
+    - gosimple
+    - govet
+    - ineffassign
+    - staticcheck
+    - unused
+    # Additional
+    - bodyclose
+    - dogsled
+    - dupl
+    - exhaustive
+    - goconst
+    - gocritic
+    - gofmt
+    - goimports
+    - mnd
+    - goprintffuncname
+    - gosec
+    - misspell
+    - nakedret
+    - noctx
+    - nolintlint
+    - prealloc
+    - revive
+    - stylecheck
+    - unconvert
+    - unparam
+    - whitespace
+
+linters-settings:
+  gocritic:
+    enabled-tags:
+      - performance
+      - style
+      - experimental
+    disabled-checks:
+      - wrapperFunc
+      - dupImport
+
+  revive:
+    rules:
+      - name: unexported-return
+        disabled: false
+      - name: exported
+        disabled: false
+      - name: package-comments
+        disabled: true
+
+  mnd:
+    checks:
+      - argument
+      - case
+      - condition
+      - operation
+      - return
+    ignored-numbers:
+      - '0'
+      - '1'
+      - '2'
+      - '10'
+      - '60'
+      - '100'
+
+  dupl:
+    threshold: 100
+
+  gosec:
+    excludes:
+      - G104  # Audit errors not checked (handled by errcheck)

.kilocode/mcp.json

@@ -0,0 +1,21 @@
+{
+  "mcpServers": {
+    "context7": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@upstash/context7-mcp"
+      ],
+      "env": {
+        "DEFAULT_MINIMUM_TOKENS": ""
+      }
+    },
+    "sequentialthinking": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@modelcontextprotocol/server-sequential-thinking"
+      ]
+    }
+  }
+}

HF_SPACES_DEPLOYMENT.md

@@ -0,0 +1,129 @@
+# HF Spaces Deployment - Claude Multi-API Key Feature
+
+## Overview
+This version of CLIProxyAPI includes support for multiple Claude API keys with round-robin load balancing, accessible through both the Management UI and API endpoints.
+
+## What's New
+
+### 1. Multiple Claude API Keys
+- Add multiple API keys per Claude configuration
+- Each key can have its own proxy URL
+- Automatic round-robin load balancing across all keys
+- Backward compatible with single-key configurations
+
+### 2. Updated Management UI
+The management UI (`/management.html`) now includes:
+- **AI Providers** → **Claude API Configuration** section
+- Add/remove multiple API keys with individual proxy settings
+- Visual interface for managing key entries
+
+### 3. API Endpoints
+The following endpoints support the new `api-key-entries` field:
+
+- `GET /api/config/claude-api-key` - Returns configurations with `api-key-entries`
+- `PUT /api/config/claude-api-key` - Create/update with multiple keys
+- `PATCH /api/config/claude-api-key` - Update specific fields including `api-key-entries`
+- `DELETE /api/config/claude-api-key` - Delete by API key or index
+
+## Configuration Examples
+
+### Via Management UI
+1. Access `https://your-space.hf.space/management.html`
+2. Navigate to **AI Providers** → **Claude API Configuration**
+3. Click **Add Configuration**
+4. Add multiple API keys in the **API Keys** section
+5. Save
+
+### Via Config File (config.yaml)
+
+```yaml
+claude-api-key:
+  - api-key-entries:
+      - api-key: "sk-ant-api03-key1..."
+        proxy-url: "http://proxy1:8080"
+      - api-key: "sk-ant-api03-key2..."
+        proxy-url: "http://proxy2:8080"
+      - api-key: "sk-ant-api03-key3..."
+    base-url: "https://api.anthropic.com"
+    priority: 10
+    prefix: "team-a/"
+    models:
+      - name: claude-3-5-sonnet-20241022
+        alias: claude-sonnet
+      - name: claude-3-opus-20240229
+        alias: claude-opus
+```
+
+### Via API
+
+```bash
+# Add Claude configuration with multiple keys
+curl -X PUT https://your-space.hf.space/api/config/claude-api-key \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer your-api-key" \
+  -d '[{
+    "api-key-entries": [
+      {"api-key": "sk-ant-api03-key1...", "proxy-url": "http://proxy1:8080"},
+      {"api-key": "sk-ant-api03-key2...", "proxy-url": "http://proxy2:8080"}
+    ],
+    "base-url": "https://api.anthropic.com",
+    "priority": 10,
+    "models": [
+      {"name": "claude-3-5-sonnet-20241022", "alias": "claude-sonnet"}
+    ]
+  }]'
+```
+
+## How It Works
+
+1. **Load Balancing**: Each API key becomes a separate Auth entry. The system uses round-robin selection to distribute requests across all available keys.
+
+2. **Per-Key Proxy**: Each API key entry can specify its own `proxy-url`. If not specified, it falls back to the key-level `proxy-url` or no proxy.
+
+3. **Backward Compatibility**: The old single `api-key` field still works. If `api-key-entries` is empty, the system uses the single `api-key`.
+
+4. **Failover**: If one API key fails (e.g., rate limited), the system automatically tries the next key in the rotation.
+
+## Files Modified
+
+### Backend (Go)
+- `internal/config/config.go` - Added `ClaudeAPIKeyEntry` type and updated `ClaudeKey`
+- `internal/watcher/synthesizer/config.go` - Updated `synthesizeClaudeKeys()` for multi-key support
+- `internal/watcher/diff/config_diff.go` - Added diff detection for `api-key-entries`
+- `internal/api/handlers/management/config_lists.go` - Updated API handlers
+- `internal/managementasset/management.html` - Updated React UI build
+
+### Frontend (React/TypeScript)
+- `management-center/src/types/provider.ts` - Added `apiKeyEntries` to types
+- `management-center/src/components/providers/ClaudeSection/ClaudeModal.tsx` - New multi-key UI
+- `management-center/src/components/providers/types.ts` - Updated form state types
+- `management-center/src/i18n/locales/*.json` - Added translation keys
+
+## Testing
+
+All tests pass for the modified components:
+```bash
+go test ./internal/config/... ./internal/watcher/... ./internal/api/handlers/management/... -v
+```
+
+## Deployment Notes
+
+1. The `management.html` file is embedded in the binary at `/home/internal/managementasset/management.html`
+2. The Dockerfile copies the entire project, so the management UI is included automatically
+3. No additional environment variables are required for the multi-key feature
+4. The feature works out of the box once deployed
+
+## Troubleshooting
+
+### Management UI Not Loading
+- Ensure the `management.html` file exists in the Docker image
+- Check that `RemoteManagement.DisableControlPanel` is not set to `true` in config
+
+### API Keys Not Rotating
+- Verify that `api-key-entries` is properly formatted in the config
+- Check logs for any synthesis errors
+- Ensure at least one API key has a non-empty value
+
+### Per-Key Proxy Not Working
+- Verify the proxy URL format (e.g., `http://proxy.example.com:8080`)
+- Check that the proxy is accessible from the HF Spaces environment

Makefile

@@ -0,0 +1,20 @@
+GOPATH=$(shell go env GOPATH)
+GOLANGCI_LINT=$(GOPATH)/bin/golangci-lint
+
+.PHONY: lint lint-fix lint-install lint-precommit
+
+lint-install:
+	go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest
+
+lint:
+	$(GOLANGCI_LINT) run ./...
+
+lint-fix:
+	$(GOLANGCI_LINT) run --fix ./...
+
+# Pre-commit hook
+lint-precommit:
+	@echo "#!/bin/sh" > .git/hooks/pre-commit
+	@echo '$(GOLANGCI_LINT) run --fast ./...' >> .git/hooks/pre-commit
+	@chmod +x .git/hooks/pre-commit
+	@echo "Pre-commit hook installed"

internal/access/config_access/provider.go

@@ -105,7 +105,7 @@ func extractBearerToken(header string) string {
 	if len(parts) != 2 {
 		return header
 	}
-	if strings.ToLower(parts[0]) != "bearer" {
+	if !strings.EqualFold(parts[0], "bearer") {
 		return header
 	}
 	return strings.TrimSpace(parts[1])

internal/api/handlers/management/auth_files.go

@@ -1103,7 +1103,7 @@ func (h *Handler) RequestGeminiCLIToken(c *gin.Context) {
 
 		// Create token storage (mirrors internal/auth/gemini createTokenStorage)
 		authHTTPClient := conf.Client(ctx, token)
-		req, errNewRequest := http.NewRequestWithContext(ctx, "GET", "https://www.googleapis.com/oauth2/v1/userinfo?alt=json", nil)
+		req, errNewRequest := http.NewRequestWithContext(ctx, "GET", "https://www.googleapis.com/oauth2/v1/userinfo?alt=json", http.NoBody)
 		if errNewRequest != nil {
 			log.Errorf("Could not get user info: %v", errNewRequest)
 			SetOAuthSessionError(state, "Could not get user info")
@@ -2079,7 +2079,7 @@ func callGeminiCLI(ctx context.Context, httpClient *http.Client, endpoint string
 }
 
 func fetchGCPProjects(ctx context.Context, httpClient *http.Client) ([]interfaces.GCPProjectProjects, error) {
-	req, errRequest := http.NewRequestWithContext(ctx, http.MethodGet, "https://cloudresourcemanager.googleapis.com/v1/projects", nil)
+	req, errRequest := http.NewRequestWithContext(ctx, http.MethodGet, "https://cloudresourcemanager.googleapis.com/v1/projects", http.NoBody)
 	if errRequest != nil {
 		return nil, fmt.Errorf("could not create project list request: %w", errRequest)
 	}
@@ -2114,7 +2114,7 @@ func checkCloudAPIIsEnabled(ctx context.Context, httpClient *http.Client, projec
 	}
 	for _, service := range requiredServices {
 		checkURL := fmt.Sprintf("%s/v1/projects/%s/services/%s", serviceUsageURL, projectID, service)
-		req, errRequest := http.NewRequestWithContext(ctx, http.MethodGet, checkURL, nil)
+		req, errRequest := http.NewRequestWithContext(ctx, http.MethodGet, checkURL, http.NoBody)
 		if errRequest != nil {
 			return false, fmt.Errorf("failed to create request: %w", errRequest)
 		}

internal/api/handlers/management/config_basic.go

@@ -49,7 +49,7 @@ func (h *Handler) GetLatestVersion(c *gin.Context) {
 		util.SetProxy(sdkCfg, client)
 	}
 
-	req, err := http.NewRequestWithContext(c.Request.Context(), http.MethodGet, latestReleaseURL, nil)
+	req, err := http.NewRequestWithContext(c.Request.Context(), http.MethodGet, latestReleaseURL, http.NoBody)
 	if err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"error": "request_create_failed", "message": err.Error()})
 		return

internal/api/handlers/management/handler.go

@@ -205,7 +205,7 @@ func (h *Handler) Middleware() gin.HandlerFunc {
 		var provided string
 		if ah := c.GetHeader("Authorization"); ah != "" {
 			parts := strings.SplitN(ah, " ", 2)
-			if len(parts) == 2 && strings.ToLower(parts[0]) == "bearer" {
+			if len(parts) == 2 && strings.EqualFold(parts[0], "bearer") {
 				provided = parts[1]
 			} else {
 				provided = ah

internal/api/middleware/correlation.go

@@ -1,54 +0,0 @@
-// Package middleware provides HTTP middleware components for the CLI Proxy API server.
-// This file contains correlation ID middleware for request tracing.
-package middleware
-
-import (
-	"github.com/gin-gonic/gin"
-	"github.com/google/uuid"
-)
-
-const (
-	// CorrelationIDHeader is the HTTP header name for correlation IDs
-	CorrelationIDHeader = "X-Correlation-ID"
-	// CorrelationIDContextKey is the context key for correlation IDs
-	CorrelationIDContextKey = "correlation_id"
-)
-
-// CorrelationIDMiddleware creates a Gin middleware that ensures every request
-// has a correlation ID for distributed tracing. It checks for an existing ID
-// in the request headers and generates a new one if not present.
-func CorrelationIDMiddleware() gin.HandlerFunc {
-	return func(c *gin.Context) {
-		// Check for existing correlation ID in header
-		correlationID := c.GetHeader(CorrelationIDHeader)
-		
-		// Generate new ID if not present
-		if correlationID == "" {
-			correlationID = generateCorrelationID()
-		}
-		
-		// Store in context
-		c.Set(CorrelationIDContextKey, correlationID)
-		
-		// Add to response headers
-		c.Header(CorrelationIDHeader, correlationID)
-		
-		c.Next()
-	}
-}
-
-// GetCorrelationID retrieves the correlation ID from the Gin context.
-// Returns empty string if no correlation ID is found.
-func GetCorrelationID(c *gin.Context) string {
-	if id, exists := c.Get(CorrelationIDContextKey); exists {
-		if str, ok := id.(string); ok {
-			return str
-		}
-	}
-	return ""
-}
-
-// generateCorrelationID generates a new unique correlation ID.
-func generateCorrelationID() string {
-	return uuid.New().String()
-}

internal/api/middleware/error_handler.go

@@ -1,108 +1,80 @@
-// Package middleware provides HTTP middleware components for the CLI Proxy API server.
-// This file contains centralized error handling middleware for consistent API responses.
 package middleware
 
 import (
+	"errors"
 	"net/http"
 
 	"github.com/gin-gonic/gin"
-	"github.com/router-for-me/CLIProxyAPI/v6/internal/domain/errors"
-)
-
-// ErrorResponse represents a standardized error response
-type ErrorResponse struct {
-	Success   bool       `json:"success"`
-	Error     *APIError  `json:"error,omitempty"`
-	RequestID string     `json:"request_id,omitempty"`
-}
+	"github.com/sirupsen/logrus"
 
-// APIError represents error details
-type APIError struct {
-	Code    string `json:"code"`
-	Message string `json:"message"`
-	Field   string `json:"field,omitempty"`
-}
+	"github.com/router-for-me/CLIProxyAPI/v6/internal/application/dto"
+	domainerrors "github.com/router-for-me/CLIProxyAPI/v6/internal/domain/errors"
+)
 
-// ErrorHandlerMiddleware creates a Gin middleware that provides centralized
-// error handling. It catches errors from the context and formats them into
-// standardized error responses.
-func ErrorHandlerMiddleware() gin.HandlerFunc {
+// ErrorHandler returns a middleware that handles domain errors
+func ErrorHandler(logger *logrus.Logger) gin.HandlerFunc {
 	return func(c *gin.Context) {
 		c.Next()
 
 		// Check if there are any errors
-		if len(c.Errors) > 0 {
-			err := c.Errors.Last()
-			handleError(c, err)
+		if len(c.Errors) == 0 {
+			return
 		}
-	}
-}
 
-// handleError converts various error types to standardized HTTP responses
-func handleError(c *gin.Context, err *gin.Error) {
-	requestID := GetCorrelationID(c)
-	
-	// Check if it's a domain error
-	if domainErr, ok := err.Err.(*errors.DomainError); ok {
-		statusCode := domainErr.HTTPStatusCode()
-		apiErr := &APIError{
-			Code:    string(domainErr.Code),
-			Message: domainErr.Message,
-		}
-		// Extract field from details if available
-		if domainErr.Details != nil {
-			if field, ok := domainErr.Details["field"].(string); ok {
-				apiErr.Field = field
-			}
+		// Get the last error
+		err := c.Errors.Last().Err
+		requestID := c.GetString("request_id")
+
+		// Handle domain errors
+		if domainErr, ok := err.(*domainerrors.DomainError); ok {
+			handleDomainError(c, domainErr, requestID, logger)
+			return
 		}
-		response := ErrorResponse{
-			Success:   false,
-			RequestID: requestID,
-			Error:     apiErr,
+
+		// Handle wrapped domain errors
+		var domainErr *domainerrors.DomainError
+		if errors.As(err, &domainErr) {
+			handleDomainError(c, domainErr, requestID, logger)
+			return
 		}
-		c.JSON(statusCode, response)
-		return
-	}
 
-	// Handle common HTTP status errors
-	switch err.Type {
-	case gin.ErrorTypeBind:
-		c.JSON(http.StatusBadRequest, ErrorResponse{
-			Success:   false,
-			RequestID: requestID,
-			Error: &APIError{
-				Code:    "INVALID_INPUT",
-				Message: "Invalid request format: " + err.Err.Error(),
-			},
-		})
-	case gin.ErrorTypeRender:
-		c.JSON(http.StatusInternalServerError, ErrorResponse{
-			Success:   false,
-			RequestID: requestID,
-			Error: &APIError{
-				Code:    "RENDER_ERROR",
-				Message: "Failed to render response",
-			},
-		})
-	default:
-		c.JSON(http.StatusInternalServerError, ErrorResponse{
+		// Unknown error - log full details but return generic message
+		logger.WithError(err).
+			WithField("request_id", requestID).
+			WithField("path", c.Request.URL.Path).
+			Error("Unhandled error")
+
+		c.JSON(http.StatusInternalServerError, dto.InternalErrorResponse{
 			Success:   false,
+			Error:     "An unexpected error occurred",
 			RequestID: requestID,
-			Error: &APIError{
-				Code:    "INTERNAL_ERROR",
-				Message: "An internal error occurred",
-			},
 		})
 	}
 }
 
-// AbortWithDomainError aborts the request with a domain error
-func AbortWithDomainError(c *gin.Context, err *errors.DomainError) {
-	c.Error(err)
-	c.Abort()
-}
+func handleDomainError(c *gin.Context, err *domainerrors.DomainError, requestID string, logger *logrus.Logger) {
+	// Log with appropriate level based on status code
+	entry := logger.WithError(err).
+		WithField("request_id", requestID).
+		WithField("error_code", err.Code).
+		WithField("path", c.Request.URL.Path)
+
+	statusCode := err.HTTPStatusCode()
+
+	if statusCode >= 500 {
+		entry.Error("Server error")
+	} else if statusCode >= 400 {
+		entry.Warn("Client error")
+	}
 
-// RespondWithError adds an error to the context without aborting
-func RespondWithError(c *gin.Context, err error) {
-	c.Error(err)
+	// Return structured error response
+	c.JSON(statusCode, dto.ErrorResponse{
+		Success: false,
+		Error: dto.ErrorInfo{
+			Code:    string(err.Code),
+			Message: err.Message,
+			Details: err.Details,
+		},
+		RequestID: requestID,
+	})
 }

internal/api/middleware/middleware_test.go

@@ -9,6 +9,7 @@ import (
 	"testing"
 
 	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -17,42 +18,42 @@ func setupTestRouter() *gin.Engine {
 	return gin.New()
 }
 
-func TestCorrelationIDMiddleware(t *testing.T) {
+func TestRequestIDMiddleware(t *testing.T) {
 	router := setupTestRouter()
-	router.Use(CorrelationIDMiddleware())
+	router.Use(RequestID())
 	router.GET("/test", func(c *gin.Context) {
-		id := GetCorrelationID(c)
-		c.JSON(200, gin.H{"correlation_id": id})
+		id := c.GetString("request_id")
+		c.JSON(200, gin.H{"request_id": id})
 	})
 
-	t.Run("generates correlation ID when not provided", func(t *testing.T) {
+	t.Run("generates request ID when not provided", func(t *testing.T) {
 		w := httptest.NewRecorder()
-		req, _ := http.NewRequest("GET", "/test", nil)
+		req, _ := http.NewRequest("GET", "/test", http.NoBody)
 		router.ServeHTTP(w, req)
 
 		assert.Equal(t, 200, w.Code)
-		// Check that response contains a correlation ID
-		assert.Contains(t, w.Body.String(), "correlation_id")
-		// Check that response header contains the correlation ID
-		assert.NotEmpty(t, w.Header().Get(CorrelationIDHeader))
+		// Check that response contains a request ID
+		assert.Contains(t, w.Body.String(), "request_id")
+		// Check that response header contains the request ID
+		assert.NotEmpty(t, w.Header().Get("X-Request-ID"))
 	})
 
-	t.Run("uses existing correlation ID from header", func(t *testing.T) {
+	t.Run("uses existing request ID from header", func(t *testing.T) {
 		w := httptest.NewRecorder()
-		req, _ := http.NewRequest("GET", "/test", nil)
-		req.Header.Set(CorrelationIDHeader, "test-correlation-id-123")
+		req, _ := http.NewRequest("GET", "/test", http.NoBody)
+		req.Header.Set("X-Request-ID", "test-request-id-123")
 		router.ServeHTTP(w, req)
 
 		assert.Equal(t, 200, w.Code)
-		assert.Contains(t, w.Body.String(), "test-correlation-id-123")
-		assert.Equal(t, "test-correlation-id-123", w.Header().Get(CorrelationIDHeader))
+		assert.Contains(t, w.Body.String(), "test-request-id-123")
+		assert.Equal(t, "test-request-id-123", w.Header().Get("X-Request-ID"))
 	})
 }
 
-func TestErrorHandlerMiddleware(t *testing.T) {
+func TestErrorHandler(t *testing.T) {
 	router := setupTestRouter()
-	router.Use(CorrelationIDMiddleware())
-	router.Use(ErrorHandlerMiddleware())
+	router.Use(RequestID())
+	router.Use(ErrorHandler(logrus.New()))
 
 	router.GET("/error", func(c *gin.Context) {
 		c.Error(errors.New("test error"))
@@ -65,16 +66,16 @@ func TestErrorHandlerMiddleware(t *testing.T) {
 
 	t.Run("handles errors gracefully", func(t *testing.T) {
 		w := httptest.NewRecorder()
-		req, _ := http.NewRequest("GET", "/error", nil)
+		req, _ := http.NewRequest("GET", "/error", http.NoBody)
 		router.ServeHTTP(w, req)
 
 		assert.Equal(t, 500, w.Code)
-		assert.Contains(t, w.Body.String(), "INTERNAL_ERROR")
+		assert.Contains(t, w.Body.String(), "An unexpected error occurred")
 	})
 
 	t.Run("passes through successful requests", func(t *testing.T) {
 		w := httptest.NewRecorder()
-		req, _ := http.NewRequest("GET", "/success", nil)
+		req, _ := http.NewRequest("GET", "/success", http.NoBody)
 		router.ServeHTTP(w, req)
 
 		assert.Equal(t, 200, w.Code)
@@ -85,8 +86,8 @@ func TestErrorHandlerMiddleware(t *testing.T) {
 func TestRecoveryMiddleware(t *testing.T) {
 	router := setupTestRouter()
 	router.Use(RecoveryMiddleware(nil))
-	router.Use(CorrelationIDMiddleware())
-	router.Use(ErrorHandlerMiddleware())
+	router.Use(RequestID())
+	router.Use(ErrorHandler(logrus.New()))
 
 	router.GET("/panic", func(c *gin.Context) {
 		panic("test panic")
@@ -98,16 +99,16 @@ func TestRecoveryMiddleware(t *testing.T) {
 
 	t.Run("recovers from panic", func(t *testing.T) {
 		w := httptest.NewRecorder()
-		req, _ := http.NewRequest("GET", "/panic", nil)
+		req, _ := http.NewRequest("GET", "/panic", http.NoBody)
 		router.ServeHTTP(w, req)
 
 		assert.Equal(t, 500, w.Code)
-		assert.Contains(t, w.Body.String(), "INTERNAL_ERROR")
+		assert.Contains(t, w.Body.String(), "An internal server error occurred")
 	})
 
 	t.Run("normal requests work after panic recovery", func(t *testing.T) {
 		w := httptest.NewRecorder()
-		req, _ := http.NewRequest("GET", "/normal", nil)
+		req, _ := http.NewRequest("GET", "/normal", http.NoBody)
 		router.ServeHTTP(w, req)
 
 		assert.Equal(t, 200, w.Code)
@@ -117,8 +118,8 @@ func TestRecoveryMiddleware(t *testing.T) {
 
 func TestSafeHandler(t *testing.T) {
 	router := setupTestRouter()
-	router.Use(CorrelationIDMiddleware())
-	router.Use(ErrorHandlerMiddleware())
+	router.Use(RequestID())
+	router.Use(ErrorHandler(logrus.New()))
 
 	router.GET("/safe-panic", SafeHandler(func(c *gin.Context) {
 		panic("safe handler panic")
@@ -126,10 +127,10 @@ func TestSafeHandler(t *testing.T) {
 
 	t.Run("safe handler recovers from panic", func(t *testing.T) {
 		w := httptest.NewRecorder()
-		req, _ := http.NewRequest("GET", "/safe-panic", nil)
+		req, _ := http.NewRequest("GET", "/safe-panic", http.NoBody)
 		router.ServeHTTP(w, req)
 
 		assert.Equal(t, 500, w.Code)
-		assert.Contains(t, w.Body.String(), "INTERNAL_ERROR")
+		assert.Contains(t, w.Body.String(), "An internal server error occurred")
 	})
 }

internal/api/middleware/rate_limit.go

@@ -1,148 +0,0 @@
-// Package middleware provides HTTP middleware components for the CLI Proxy API server.
-// This file contains the rate limiting middleware that integrates with the domain
-// rate limiting service to enforce request limits and block abusive clients.
-package middleware
-
-import (
-	"net/http"
-	"time"
-
-	"github.com/gin-gonic/gin"
-	"github.com/router-for-me/CLIProxyAPI/v6/internal/domain/ports"
-)
-
-// RateLimitMiddleware creates a Gin middleware that enforces rate limiting
-// using the provided RateLimitService. It checks if the client IP is blocked
-// and records failed authentication attempts.
-type RateLimitMiddleware struct {
-	service ports.RateLimitService
-}
-
-// NewRateLimitMiddleware creates a new rate limiting middleware instance.
-func NewRateLimitMiddleware(service ports.RateLimitService) *RateLimitMiddleware {
-	return &RateLimitMiddleware{
-		service: service,
-	}
-}
-
-// Middleware returns the Gin middleware function that enforces rate limiting.
-// It should be used for management endpoints that require authentication.
-func (m *RateLimitMiddleware) Middleware() gin.HandlerFunc {
-	return func(c *gin.Context) {
-		if m.service == nil {
-			c.Next()
-			return
-		}
-
-		clientIP := c.ClientIP()
-		ctx := c.Request.Context()
-
-		// Check if client is blocked
-		blocked, blockedUntil, err := m.service.IsBlocked(ctx, clientIP)
-		if err != nil {
-			c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{
-				"error": "rate limit check failed",
-			})
-			return
-		}
-		if blocked {
-			remaining := time.Until(blockedUntil)
-			if remaining < 0 {
-				remaining = 0
-			}
-			c.AbortWithStatusJSON(http.StatusForbidden, gin.H{
-				"error":       "IP banned due to too many failed attempts",
-				"retry_after": remaining.String(),
-			})
-			return
-		}
-
-		// Check if request is allowed
-		allowed, err := m.service.Allow(ctx, clientIP)
-		if err != nil {
-			c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{
-				"error": "rate limit check failed",
-			})
-			return
-		}
-		if !allowed {
-			c.AbortWithStatusJSON(http.StatusTooManyRequests, gin.H{
-				"error": "rate limit exceeded",
-			})
-			return
-		}
-
-		c.Next()
-	}
-}
-
-// AuthMiddleware wraps the rate limiting middleware with authentication logic.
-// It records failed attempts when authentication fails.
-type AuthMiddleware struct {
-	rateLimitService ports.RateLimitService
-	getSecretHash    func() string
-	getEnvSecret     func() string
-	allowRemote      func() bool
-}
-
-// NewAuthMiddleware creates a new authentication middleware with rate limiting.
-func NewAuthMiddleware(
-	service ports.RateLimitService,
-	getSecretHash func() string,
-	getEnvSecret func() string,
-	allowRemote func() bool,
-) *AuthMiddleware {
-	return &AuthMiddleware{
-		rateLimitService: service,
-		getSecretHash:    getSecretHash,
-		getEnvSecret:     getEnvSecret,
-		allowRemote:      allowRemote,
-	}
-}
-
-// OnAuthFailure should be called when authentication fails to record the attempt.
-func (m *AuthMiddleware) OnAuthFailure(c *gin.Context) {
-	if m.rateLimitService == nil {
-		return
-	}
-
-	clientIP := c.ClientIP()
-	ctx := c.Request.Context()
-
-	m.rateLimitService.RecordAttempt(ctx, clientIP, false)
-}
-
-// OnAuthSuccess should be called when authentication succeeds to reset attempts.
-func (m *AuthMiddleware) OnAuthSuccess(c *gin.Context) {
-	if m.rateLimitService == nil {
-		return
-	}
-
-	clientIP := c.ClientIP()
-	ctx := c.Request.Context()
-
-	m.rateLimitService.RecordAttempt(ctx, clientIP, true)
-}
-
-// GetRetryAfter returns the duration until the client can retry after being blocked.
-func (m *AuthMiddleware) GetRetryAfter(c *gin.Context) time.Duration {
-	if m.rateLimitService == nil {
-		return 0
-	}
-
-	clientIP := c.ClientIP()
-	ctx := c.Request.Context()
-
-	blocked, blockedUntil, err := m.rateLimitService.IsBlocked(ctx, clientIP)
-	if err != nil {
-		return 0
-	}
-	if blocked {
-		remaining := time.Until(blockedUntil)
-		if remaining > 0 {
-			return remaining
-		}
-	}
-
-	return 0
-}

internal/api/middleware/recovery.go

@@ -9,6 +9,8 @@ import (
 
 	"github.com/gin-gonic/gin"
 	"github.com/sirupsen/logrus"
+
+	"github.com/router-for-me/CLIProxyAPI/v6/internal/application/dto"
 )
 
 // RecoveryMiddleware creates a Gin middleware that recovers from panics
@@ -18,6 +20,7 @@ func RecoveryMiddleware(logger *logrus.Logger) gin.HandlerFunc {
 	return func(c *gin.Context) {
 		defer func() {
 			if r := recover(); r != nil {
+				requestID := c.GetString("request_id")
 				// Log the panic with stack trace if logger is available
 				if logger != nil {
 					logger.WithFields(logrus.Fields{
@@ -26,19 +29,15 @@ func RecoveryMiddleware(logger *logrus.Logger) gin.HandlerFunc {
 						"path":       c.Request.URL.Path,
 						"method":     c.Request.Method,
 						"client_ip":  c.ClientIP(),
-						"request_id": GetCorrelationID(c),
+						"request_id": requestID,
 					}).Error("Panic recovered in HTTP handler")
 				}
 
 				// Return graceful error response
-				requestID := GetCorrelationID(c)
-				c.AbortWithStatusJSON(http.StatusInternalServerError, ErrorResponse{
+				c.AbortWithStatusJSON(http.StatusInternalServerError, dto.InternalErrorResponse{
 					Success:   false,
 					RequestID: requestID,
-					Error: &APIError{
-						Code:    "INTERNAL_ERROR",
-						Message: "An internal server error occurred",
-					},
+					Error:     "An internal server error occurred",
 				})
 			}
 		}()
@@ -53,22 +52,19 @@ func SafeHandler(handler gin.HandlerFunc) gin.HandlerFunc {
 	return func(c *gin.Context) {
 		defer func() {
 			if r := recover(); r != nil {
+				requestID := c.GetString("request_id")
 				// Log the panic
 				logrus.WithFields(logrus.Fields{
 					"panic":      fmt.Sprintf("%v", r),
 					"path":       c.Request.URL.Path,
 					"method":     c.Request.Method,
-					"request_id": GetCorrelationID(c),
+					"request_id": requestID,
 				}).Error("Panic recovered in handler")
 
-				requestID := GetCorrelationID(c)
-				c.AbortWithStatusJSON(http.StatusInternalServerError, ErrorResponse{
+				c.AbortWithStatusJSON(http.StatusInternalServerError, dto.InternalErrorResponse{
 					Success:   false,
 					RequestID: requestID,
-					Error: &APIError{
-						Code:    "INTERNAL_ERROR",
-						Message: "An internal server error occurred",
-					},
+					Error:     "An internal server error occurred",
 				})
 			}
 		}()

internal/api/middleware/request_id.go

@@ -0,0 +1,18 @@
+package middleware
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/google/uuid"
+)
+
+func RequestID() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		requestID := c.GetHeader("X-Request-ID")
+		if requestID == "" {
+			requestID = uuid.New().String()
+		}
+		c.Set("request_id", requestID)
+		c.Header("X-Request-ID", requestID)
+		c.Next()
+	}
+}

internal/api/middleware/security.go

@@ -0,0 +1,56 @@
+package middleware
+
+import (
+	"strings"
+
+	"github.com/gin-gonic/gin"
+)
+
+func SecurityHeaders() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		// Prevent clickjacking
+		c.Header("X-Frame-Options", "DENY")
+
+		// Prevent MIME type sniffing
+		c.Header("X-Content-Type-Options", "nosniff")
+
+		// XSS Protection
+		c.Header("X-XSS-Protection", "1; mode=block")
+
+		// Referrer Policy
+		c.Header("Referrer-Policy", "strict-origin-when-cross-origin")
+
+		// Permissions Policy
+		c.Header("Permissions-Policy", "geolocation=(), microphone=(), camera=()")
+
+		// HSTS (HTTPS only)
+		c.Header("Strict-Transport-Security", "max-age=31536000; includeSubDomains; preload")
+
+		// CSP for API (restrictive)
+		if !strings.HasPrefix(c.Request.URL.Path, "/management") {
+			c.Header("Content-Security-Policy", "default-src 'none'")
+		}
+
+		c.Next()
+	}
+}
+
+// CSP for Management UI
+func ManagementCSP() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		csp := strings.Join([]string{
+			"default-src 'self'",
+			"script-src 'self' 'unsafe-inline' 'unsafe-eval'",
+			"style-src 'self' 'unsafe-inline'",
+			"img-src 'self' data: https:",
+			"font-src 'self'",
+			"connect-src 'self'",
+			"frame-ancestors 'none'",
+			"base-uri 'self'",
+			"form-action 'self'",
+		}, "; ")
+
+		c.Header("Content-Security-Policy", csp)
+		c.Next()
+	}
+}

internal/api/modules/amp/amp.go

@@ -246,7 +246,6 @@ func (m *AmpModule) OnConfigUpdated(cfg *config.Config) error {
 				}
 			}
 		}
-
 	}
 
 	// Store current config for next comparison

internal/api/modules/amp/amp_test.go

@@ -2,6 +2,7 @@ package amp
 
 import (
 	"context"
+	"net/http"
 	"net/http/httptest"
 	"os"
 	"path/filepath"
@@ -106,7 +107,7 @@ func TestAmpModule_Register_WithoutUpstream(t *testing.T) {
 	}
 
 	// But provider aliases should still be registered
-	req := httptest.NewRequest("GET", "/api/provider/openai/models", nil)
+	req := httptest.NewRequest("GET", "/api/provider/openai/models", http.NoBody)
 	w := httptest.NewRecorder()
 	r.ServeHTTP(w, req)
 
@@ -226,7 +227,7 @@ func TestAmpModule_AuthMiddleware_Fallback(t *testing.T) {
 		c.String(200, "ok")
 	})
 
-	req := httptest.NewRequest("GET", "/test", nil)
+	req := httptest.NewRequest("GET", "/test", http.NoBody)
 	w := httptest.NewRecorder()
 	r.ServeHTTP(w, req)
 
@@ -302,7 +303,7 @@ func TestAmpModule_ProviderAliasesAlwaysRegistered(t *testing.T) {
 			}
 
 			// Provider aliases should always be available
-			req := httptest.NewRequest("GET", "/api/provider/openai/models", nil)
+			req := httptest.NewRequest("GET", "/api/provider/openai/models", http.NoBody)
 			w := httptest.NewRecorder()
 			r.ServeHTTP(w, req)
 

internal/api/modules/amp/gemini_bridge_test.go

@@ -58,7 +58,7 @@ func TestCreateGeminiBridgeHandler_ActionParameterExtraction(t *testing.T) {
 			}
 			r.POST("/api/provider/google/v1beta1/*path", bridgeHandler)
 
-			req := httptest.NewRequest(http.MethodPost, "/api/provider/google/v1beta1"+tt.path, nil)
+			req := httptest.NewRequest(http.MethodPost, "/api/provider/google/v1beta1"+tt.path, http.NoBody)
 			w := httptest.NewRecorder()
 			r.ServeHTTP(w, req)
 
@@ -83,7 +83,7 @@ func TestCreateGeminiBridgeHandler_InvalidPath(t *testing.T) {
 	r := gin.New()
 	r.POST("/api/provider/google/v1beta1/*path", bridgeHandler)
 
-	req := httptest.NewRequest(http.MethodPost, "/api/provider/google/v1beta1/invalid/path", nil)
+	req := httptest.NewRequest(http.MethodPost, "/api/provider/google/v1beta1/invalid/path", http.NoBody)
 	w := httptest.NewRecorder()
 	r.ServeHTTP(w, req)
 

internal/api/modules/amp/proxy_test.go

@@ -335,7 +335,7 @@ func TestReverseProxy_StripsClientCredentialsFromHeadersAndQuery(t *testing.T) {
 	}))
 	defer srv.Close()
 
-	req, err := http.NewRequest(http.MethodGet, srv.URL+"/test?key=client-key&key=keep&auth_token=client-key&foo=bar", nil)
+	req, err := http.NewRequest(http.MethodGet, srv.URL+"/test?key=client-key&key=keep&auth_token=client-key&foo=bar", http.NoBody)
 	if err != nil {
 		t.Fatal(err)
 	}

internal/api/modules/amp/response_rewriter_test.go

@@ -106,7 +106,7 @@ func TestResponseRewriter_SplitJSONTokensAcrossChunks(t *testing.T) {
 
 			// Simulate streaming response
 			for _, chunk := range tt.chunks {
-				rw.Write([]byte(chunk))
+				rw.WriteString(chunk)
 			}
 			rw.Flush()
 
@@ -176,7 +176,7 @@ func TestResponseRewriter_InvalidMalformedJSON(t *testing.T) {
 			rw := NewResponseRewriter(mock, tt.originalModel)
 
 			// For non-streaming, we buffer and flush
-			rw.Write([]byte(tt.input))
+			rw.WriteString(tt.input)
 			rw.Flush()
 
 			result := mock.body.String()
@@ -256,7 +256,7 @@ func TestResponseRewriter_MixedContentTypes(t *testing.T) {
 			rw := NewResponseRewriter(mock, tt.originalModel)
 
 			// First write triggers streaming detection
-			rw.Write([]byte(tt.input))
+			rw.WriteString(tt.input)
 
 			if rw.isStreaming != tt.isStreaming {
 				t.Errorf("isStreaming = %v, want %v", rw.isStreaming, tt.isStreaming)
@@ -320,7 +320,7 @@ func TestResponseRewriter_FallbackStrategy(t *testing.T) {
 
 			// Write all chunks
 			for _, chunk := range tt.input {
-				_, err := rw.Write([]byte(chunk))
+				_, err := rw.WriteString(chunk)
 				if err != nil && !tt.expectError {
 					t.Errorf("unexpected error: %v", err)
 				}
@@ -403,7 +403,7 @@ func TestResponseRewriter_SSEEdgeCases(t *testing.T) {
 			rw := NewResponseRewriter(mock, tt.originalModel)
 
 			for _, chunk := range tt.chunks {
-				rw.Write([]byte(chunk))
+				rw.WriteString(chunk)
 			}
 
 			result := mock.body.String()
@@ -456,7 +456,7 @@ func TestResponseRewriter_ThinkingBlockSuppression(t *testing.T) {
 			mock := newMockResponseWriter()
 			rw := NewResponseRewriter(mock, tt.originalModel)
 
-			rw.Write([]byte(tt.input))
+			rw.WriteString(tt.input)
 			rw.Flush()
 
 			result := mock.body.String()
@@ -495,7 +495,7 @@ func TestResponseRewriter_ConcurrentWrites(t *testing.T) {
 	}
 
 	for _, chunk := range chunks {
-		rw.Write([]byte(chunk))
+		rw.WriteString(chunk)
 	}
 	rw.Flush()
 
@@ -515,7 +515,7 @@ func TestResponseRewriter_LargeResponse(t *testing.T) {
 	largeContent := strings.Repeat("a", 100000)
 	input := `{"model": "mapped-model", "content": "` + largeContent + `"}`
 
-	rw.Write([]byte(input))
+	rw.WriteString(input)
 	rw.Flush()
 
 	result := mock.body.String()
@@ -594,27 +594,27 @@ func TestNewResponseRewriter(t *testing.T) {
 // TestResponseRewriter_FlushBehavior tests Flush method behavior
 func TestResponseRewriter_FlushBehavior(t *testing.T) {
 	tests := []struct {
-		name       string
+		name        string
 		isStreaming bool
-		writeData  string
+		writeData   string
 		expectFlush bool
 	}{
 		{
-			name:       "flush non-streaming",
+			name:        "flush non-streaming",
 			isStreaming: false,
-			writeData:  `{"model": "mapped"}`,
+			writeData:   `{"model": "mapped"}`,
 			expectFlush: true,
 		},
 		{
-			name:       "flush streaming",
+			name:        "flush streaming",
 			isStreaming: true,
-			writeData:  `data: {"model": "mapped"}`,
+			writeData:   `data: {"model": "mapped"}`,
 			expectFlush: true,
 		},
 		{
-			name:       "flush empty body",
+			name:        "flush empty body",
 			isStreaming: false,
-			writeData:  "",
+			writeData:   "",
 			expectFlush: false,
 		},
 	}
@@ -628,7 +628,7 @@ func TestResponseRewriter_FlushBehavior(t *testing.T) {
 			rw := NewResponseRewriter(mock, "original")
 
 			if tt.writeData != "" {
-				rw.Write([]byte(tt.writeData))
+				rw.WriteString(tt.writeData)
 			}
 
 			// Reset flushed flag

internal/api/modules/amp/routes_test.go

@@ -65,7 +65,7 @@ func TestRegisterManagementRoutes(t *testing.T) {
 	for _, path := range managementPaths {
 		t.Run(path.path, func(t *testing.T) {
 			proxyCalled = false
-			req, err := http.NewRequest(path.method, srv.URL+path.path, nil)
+			req, err := http.NewRequest(path.method, srv.URL+path.path, http.NoBody)
 			if err != nil {
 				t.Fatalf("failed to build request: %v", err)
 			}
@@ -120,7 +120,7 @@ func TestRegisterProviderAliases_AllProvidersRegistered(t *testing.T) {
 	for _, tc := range paths {
 		t.Run(tc.path, func(t *testing.T) {
 			authCalled = false
-			req := httptest.NewRequest(tc.method, tc.path, nil)
+			req := httptest.NewRequest(tc.method, tc.path, http.NoBody)
 			w := httptest.NewRecorder()
 			r.ServeHTTP(w, req)
 
@@ -151,7 +151,7 @@ func TestRegisterProviderAliases_DynamicModelsHandler(t *testing.T) {
 	for _, provider := range providers {
 		t.Run(provider, func(t *testing.T) {
 			path := "/api/provider/" + provider + "/models"
-			req := httptest.NewRequest(http.MethodGet, path, nil)
+			req := httptest.NewRequest(http.MethodGet, path, http.NoBody)
 			w := httptest.NewRecorder()
 			r.ServeHTTP(w, req)
 
@@ -185,7 +185,7 @@ func TestRegisterProviderAliases_V1Routes(t *testing.T) {
 
 	for _, tc := range v1Paths {
 		t.Run(tc.path, func(t *testing.T) {
-			req := httptest.NewRequest(tc.method, tc.path, nil)
+			req := httptest.NewRequest(tc.method, tc.path, http.NoBody)
 			w := httptest.NewRecorder()
 			r.ServeHTTP(w, req)
 
@@ -215,7 +215,7 @@ func TestRegisterProviderAliases_V1BetaRoutes(t *testing.T) {
 
 	for _, tc := range v1betaPaths {
 		t.Run(tc.path, func(t *testing.T) {
-			req := httptest.NewRequest(tc.method, tc.path, nil)
+			req := httptest.NewRequest(tc.method, tc.path, http.NoBody)
 			w := httptest.NewRecorder()
 			r.ServeHTTP(w, req)
 
@@ -236,7 +236,7 @@ func TestRegisterProviderAliases_NoAuthMiddleware(t *testing.T) {
 	m := &AmpModule{authMiddleware_: nil} // No auth middleware
 	m.registerProviderAliases(r, base, func(c *gin.Context) { c.AbortWithStatus(http.StatusOK) })
 
-	req := httptest.NewRequest(http.MethodGet, "/api/provider/openai/models", nil)
+	req := httptest.NewRequest(http.MethodGet, "/api/provider/openai/models", http.NoBody)
 	w := httptest.NewRecorder()
 	r.ServeHTTP(w, req)
 
@@ -314,7 +314,7 @@ func TestLocalhostOnlyMiddleware_PreventsSpoofing(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			req := httptest.NewRequest(http.MethodGet, "/test", nil)
+			req := httptest.NewRequest(http.MethodGet, "/test", http.NoBody)
 			req.RemoteAddr = tt.remoteAddr
 			if tt.forwardedFor != "" {
 				req.Header.Set("X-Forwarded-For", tt.forwardedFor)
@@ -346,7 +346,7 @@ func TestLocalhostOnlyMiddleware_HotReload(t *testing.T) {
 	})
 
 	// Test 1: Remote IP should be blocked when restriction is enabled
-	req := httptest.NewRequest(http.MethodGet, "/test", nil)
+	req := httptest.NewRequest(http.MethodGet, "/test", http.NoBody)
 	req.RemoteAddr = "192.168.1.100:12345"
 	w := httptest.NewRecorder()
 	r.ServeHTTP(w, req)
@@ -358,7 +358,7 @@ func TestLocalhostOnlyMiddleware_HotReload(t *testing.T) {
 	// Test 2: Hot-reload - disable restriction
 	m.setRestrictToLocalhost(false)
 
-	req = httptest.NewRequest(http.MethodGet, "/test", nil)
+	req = httptest.NewRequest(http.MethodGet, "/test", http.NoBody)
 	req.RemoteAddr = "192.168.1.100:12345"
 	w = httptest.NewRecorder()
 	r.ServeHTTP(w, req)
@@ -370,7 +370,7 @@ func TestLocalhostOnlyMiddleware_HotReload(t *testing.T) {
 	// Test 3: Hot-reload - re-enable restriction
 	m.setRestrictToLocalhost(true)
 
-	req = httptest.NewRequest(http.MethodGet, "/test", nil)
+	req = httptest.NewRequest(http.MethodGet, "/test", http.NoBody)
 	req.RemoteAddr = "192.168.1.100:12345"
 	w = httptest.NewRecorder()
 	r.ServeHTTP(w, req)

internal/api/server.go

@@ -201,6 +201,9 @@ func NewServer(cfg *config.Config, authManager *auth.Manager, accessManager *sdk
 	}
 
 	// Add middleware
+	engine.Use(middleware.RequestID())
+	engine.Use(middleware.SecurityHeaders())
+	engine.Use(middleware.ErrorHandler(log.StandardLogger()))
 	engine.Use(logging.GinLogrusLogger())
 	engine.Use(logging.GinLogrusRecovery())
 	for _, mw := range optionState.extraMiddleware {

internal/api/server_test.go

@@ -94,7 +94,7 @@ func TestAmpProviderModelRoutes(t *testing.T) {
 		t.Run(tc.name, func(t *testing.T) {
 			server := newTestServer(t)
 
-			req := httptest.NewRequest(http.MethodGet, tc.path, nil)
+			req := httptest.NewRequest(http.MethodGet, tc.path, http.NoBody)
 			req.Header.Set("Authorization", "Bearer test-key")
 
 			rr := httptest.NewRecorder()

internal/application/dto/config_dto.go

@@ -7,29 +7,29 @@ import (
 
 // ConfigResponse represents a configuration response
 type ConfigResponse struct {
-	Debug                  bool                              `json:"debug"`
-	UsageStatisticsEnabled bool                              `json:"usage_statistics_enabled"`
-	LoggingToFile          bool                              `json:"logging_to_file"`
-	LogsMaxTotalSizeMB     int                               `json:"logs_max_total_size_mb"`
-	RequestLog             bool                              `json:"request_log"`
-	WebsocketAuth          bool                              `json:"websocket_auth"`
-	RequestRetry           int                               `json:"request_retry"`
-	MaxRetryInterval       int                               `json:"max_retry_interval"`
-	ForceModelPrefix       bool                              `json:"force_model_prefix"`
-	ProxyURL               string                            `json:"proxy_url,omitempty"`
-	Routing                RoutingConfig                     `json:"routing"`
-	RemoteManagement       RemoteManagementConfig            `json:"remote_management"`
-	QuotaExceeded          QuotaExceededConfig               `json:"quota_exceeded"`
-	APIKeys                []string                          `json:"api_keys,omitempty"`
-	GeminiKey              []config.GeminiKey                `json:"gemini_key,omitempty"`
-	ClaudeKey              []config.ClaudeKey                `json:"claude_key,omitempty"`
-	CodexKey               []config.CodexKey                 `json:"codex_key,omitempty"`
-	OpenAICompatibility    []config.OpenAICompatibility      `json:"openai_compatibility,omitempty"`
-	VertexCompatAPIKey     []config.VertexCompatKey          `json:"vertex_compat_api_key,omitempty"`
-	KiroKey                []config.KiroKey                  `json:"kiro_key,omitempty"`
-	OAuthExcludedModels    map[string][]string               `json:"oauth_excluded_models,omitempty"`
+	Debug                  bool                                `json:"debug"`
+	UsageStatisticsEnabled bool                                `json:"usage_statistics_enabled"`
+	LoggingToFile          bool                                `json:"logging_to_file"`
+	LogsMaxTotalSizeMB     int                                 `json:"logs_max_total_size_mb"`
+	RequestLog             bool                                `json:"request_log"`
+	WebsocketAuth          bool                                `json:"websocket_auth"`
+	RequestRetry           int                                 `json:"request_retry"`
+	MaxRetryInterval       int                                 `json:"max_retry_interval"`
+	ForceModelPrefix       bool                                `json:"force_model_prefix"`
+	ProxyURL               string                              `json:"proxy_url,omitempty"`
+	Routing                RoutingConfig                       `json:"routing"`
+	RemoteManagement       RemoteManagementConfig              `json:"remote_management"`
+	QuotaExceeded          QuotaExceededConfig                 `json:"quota_exceeded"`
+	APIKeys                []string                            `json:"api_keys,omitempty"`
+	GeminiKey              []config.GeminiKey                  `json:"gemini_key,omitempty"`
+	ClaudeKey              []config.ClaudeKey                  `json:"claude_key,omitempty"`
+	CodexKey               []config.CodexKey                   `json:"codex_key,omitempty"`
+	OpenAICompatibility    []config.OpenAICompatibility        `json:"openai_compatibility,omitempty"`
+	VertexCompatAPIKey     []config.VertexCompatKey            `json:"vertex_compat_api_key,omitempty"`
+	KiroKey                []config.KiroKey                    `json:"kiro_key,omitempty"`
+	OAuthExcludedModels    map[string][]string                 `json:"oauth_excluded_models,omitempty"`
 	OAuthModelAlias        map[string][]config.OAuthModelAlias `json:"oauth_model_alias,omitempty"`
-	AmpCode                config.AmpCode                    `json:"amp_code"`
+	AmpCode                config.AmpCode                      `json:"amp_code"`
 }
 
 // RoutingConfig represents routing configuration
@@ -149,4 +149,4 @@ type BoolFieldUpdateRequest struct {
 // IntFieldUpdateRequest represents a request to update an int field
 type IntFieldUpdateRequest struct {
 	Value *int `json:"value"`
-}
+}

internal/application/dto/error.go

@@ -0,0 +1,21 @@
+package dto
+
+// ErrorResponse is the standardized error response for clients
+type ErrorResponse struct {
+	Success   bool      `json:"success" example:"false"`
+	Error     ErrorInfo `json:"error"`
+	RequestID string    `json:"request_id,omitempty"`
+}
+
+type ErrorInfo struct {
+	Code    string                 `json:"code" example:"AUTH_INVALID_CREDENTIALS"`
+	Message string                 `json:"message" example:"Invalid credentials provided"`
+	Details map[string]interface{} `json:"details,omitempty"`
+}
+
+// InternalErrorResponse is returned for 500 errors (no sensitive info)
+type InternalErrorResponse struct {
+	Success   bool   `json:"success"`
+	Error     string `json:"error"`
+	RequestID string `json:"request_id"`
+}

internal/application/mapper/config_mapper.go

@@ -103,4 +103,4 @@ func ToConfigFromResponse(resp *dto.ConfigResponse) *config.Config {
 	cfg.SDKConfig.APIKeys = resp.APIKeys
 
 	return cfg
-}
+}

internal/application/usecase/config_usecase.go

@@ -537,4 +537,4 @@ func (uc *ConfigUseCase) GetLatestVersion(ctx context.Context) (*dto.VersionResp
 	return &dto.VersionResponse{
 		LatestVersion: version,
 	}, nil
-}
+}

internal/auth/antigravity/auth.go

@@ -113,7 +113,7 @@ func (o *AntigravityAuth) FetchUserInfo(ctx context.Context, accessToken string)
 	if accessToken == "" {
 		return "", fmt.Errorf("antigravity userinfo: missing access token")
 	}
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, UserInfoEndpoint, nil)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, UserInfoEndpoint, http.NoBody)
 	if err != nil {
 		return "", fmt.Errorf("antigravity userinfo: create request: %w", err)
 	}

internal/auth/codex/token.go

@@ -62,5 +62,4 @@ func (ts *CodexTokenStorage) SaveTokenToFile(authFilePath string) error {
 		return fmt.Errorf("failed to write token to file: %w", err)
 	}
 	return nil
-
 }

internal/auth/gemini/gemini_auth.go

@@ -161,7 +161,7 @@ func (g *GeminiAuth) GetAuthenticatedClient(ctx context.Context, ts *GeminiToken
 //   - error: An error if the token storage creation fails, nil otherwise
 func (g *GeminiAuth) createTokenStorage(ctx context.Context, config *oauth2.Config, token *oauth2.Token, projectID string) (*GeminiTokenStorage, error) {
 	httpClient := config.Client(ctx, token)
-	req, err := http.NewRequestWithContext(ctx, "GET", "https://www.googleapis.com/oauth2/v1/userinfo?alt=json", nil)
+	req, err := http.NewRequestWithContext(ctx, "GET", "https://www.googleapis.com/oauth2/v1/userinfo?alt=json", http.NoBody)
 	if err != nil {
 		return nil, fmt.Errorf("could not get user info: %v", err)
 	}

internal/auth/iflow/iflow_auth.go

@@ -173,7 +173,7 @@ func (ia *IFlowAuth) FetchUserInfo(ctx context.Context, accessToken string) (*us
 	}
 
 	endpoint := fmt.Sprintf("%s?accessToken=%s", iFlowUserInfoEndpoint, url.QueryEscape(accessToken))
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, http.NoBody)
 	if err != nil {
 		return nil, fmt.Errorf("iflow api key: create request failed: %w", err)
 	}
@@ -334,7 +334,7 @@ func (ia *IFlowAuth) AuthenticateWithCookie(ctx context.Context, cookie string)
 
 // fetchAPIKeyInfo retrieves API key information using GET request with cookie
 func (ia *IFlowAuth) fetchAPIKeyInfo(ctx context.Context, cookie string) (*iFlowKeyData, error) {
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, iFlowAPIKeyEndpoint, nil)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, iFlowAPIKeyEndpoint, http.NoBody)
 	if err != nil {
 		return nil, fmt.Errorf("iflow cookie: create GET request failed: %w", err)
 	}

internal/cmd/login.go

@@ -375,7 +375,7 @@ func callGeminiCLI(ctx context.Context, httpClient *http.Client, endpoint string
 }
 
 func fetchGCPProjects(ctx context.Context, httpClient *http.Client) ([]interfaces.GCPProjectProjects, error) {
-	req, errRequest := http.NewRequestWithContext(ctx, http.MethodGet, "https://cloudresourcemanager.googleapis.com/v1/projects", nil)
+	req, errRequest := http.NewRequestWithContext(ctx, http.MethodGet, "https://cloudresourcemanager.googleapis.com/v1/projects", http.NoBody)
 	if errRequest != nil {
 		return nil, fmt.Errorf("could not create project list request: %w", errRequest)
 	}
@@ -559,7 +559,7 @@ func checkCloudAPIIsEnabled(ctx context.Context, httpClient *http.Client, projec
 	}
 	for _, service := range requiredServices {
 		checkUrl := fmt.Sprintf("%s/v1/projects/%s/services/%s", serviceUsageURL, projectID, service)
-		req, errRequest := http.NewRequestWithContext(ctx, http.MethodGet, checkUrl, nil)
+		req, errRequest := http.NewRequestWithContext(ctx, http.MethodGet, checkUrl, http.NoBody)
 		if errRequest != nil {
 			return false, fmt.Errorf("failed to create request: %w", errRequest)
 		}

internal/domain/errors/errors.go

@@ -32,6 +32,37 @@ const (
 	ValidationFailed ErrorCode = "VALIDATION_FAILED"
 	// AlreadyExists indicates a resource already exists
 	AlreadyExists ErrorCode = "ALREADY_EXISTS"
+
+	// New Error Codes (Standardization Plan)
+	// Authentication errors
+	ErrCodeInvalidCredentials ErrorCode = "AUTH_INVALID_CREDENTIALS"
+	ErrCodeTokenExpired       ErrorCode = "AUTH_TOKEN_EXPIRED"
+	ErrCodeTokenInvalid       ErrorCode = "AUTH_TOKEN_INVALID"
+	ErrCodeUnauthorized       ErrorCode = "AUTH_UNAUTHORIZED"
+
+	// Configuration errors
+	ErrCodeConfigNotFound   ErrorCode = "CONFIG_NOT_FOUND"
+	ErrCodeConfigInvalid    ErrorCode = "CONFIG_INVALID"
+	ErrCodeConfigValidation ErrorCode = "CONFIG_VALIDATION_FAILED"
+
+	// Provider errors
+	ErrCodeProviderNotFound    ErrorCode = "PROVIDER_NOT_FOUND"
+	ErrCodeProviderUnavailable ErrorCode = "PROVIDER_UNAVAILABLE"
+	ErrCodeProviderRateLimited ErrorCode = "PROVIDER_RATE_LIMITED"
+
+	// Request errors
+	ErrCodeInvalidRequest ErrorCode = "REQUEST_INVALID"
+	ErrCodeMissingField   ErrorCode = "REQUEST_MISSING_FIELD"
+	ErrCodeInvalidFormat  ErrorCode = "REQUEST_INVALID_FORMAT"
+
+	// Storage errors
+	ErrCodeStorageFailure ErrorCode = "STORAGE_FAILURE"
+	ErrCodeNotFound       ErrorCode = "RESOURCE_NOT_FOUND"
+	ErrCodeConflict       ErrorCode = "RESOURCE_CONFLICT"
+
+	// Internal errors
+	ErrCodeInternal       ErrorCode = "INTERNAL_ERROR"
+	ErrCodeNotImplemented ErrorCode = "NOT_IMPLEMENTED"
 )
 
 // DomainError is the base error type for all domain errors.
@@ -40,8 +71,9 @@ const (
 type DomainError struct {
 	Code       ErrorCode
 	Message    string
-	Cause      error
 	Details    map[string]interface{}
+	Cause      error
+	HTTPStatus int
 }
 
 // Error implements the error interface
@@ -184,6 +216,9 @@ func NewTimeoutError(operation string) *DomainError {
 
 // HTTPStatusCode returns the appropriate HTTP status code for the error
 func (e *DomainError) HTTPStatusCode() int {
+	if e.HTTPStatus > 0 {
+		return e.HTTPStatus
+	}
 	switch e.Code {
 	case NotFound:
 		return 404
@@ -216,26 +251,76 @@ func (e *DomainError) ToResponse() map[string]interface{} {
 	return response
 }
 
+// NewInvalidCredentials creates an AUTH_INVALID_CREDENTIALS error
+func NewInvalidCredentials(msg string) *DomainError {
+	return &DomainError{
+		Code:       ErrCodeInvalidCredentials,
+		Message:    msg,
+		HTTPStatus: 401,
+	}
+}
+
+// NewConfigNotFound creates a CONFIG_NOT_FOUND error
+func NewConfigNotFound(resource string) *DomainError {
+	return &DomainError{
+		Code:       ErrCodeConfigNotFound,
+		Message:    fmt.Sprintf("configuration not found: %s", resource),
+		HTTPStatus: 404,
+		Details:    map[string]interface{}{"resource": resource},
+	}
+}
+
+// NewProviderUnavailable creates a PROVIDER_UNAVAILABLE error
+func NewProviderUnavailable(provider string, cause error) *DomainError {
+	return &DomainError{
+		Code:       ErrCodeProviderUnavailable,
+		Message:    fmt.Sprintf("provider %s is unavailable", provider),
+		HTTPStatus: 503,
+		Cause:      cause,
+		Details:    map[string]interface{}{"provider": provider},
+	}
+}
+
+// NewConfigValidationError creates a CONFIG_VALIDATION_FAILED error
+func NewConfigValidationError(field string, msg string) *DomainError {
+	return &DomainError{
+		Code:       ErrCodeConfigValidation,
+		Message:    fmt.Sprintf("validation failed for %s: %s", field, msg),
+		HTTPStatus: 400,
+		Details:    map[string]interface{}{"field": field},
+	}
+}
+
+// NewInternalErrorWrapped creates an INTERNAL_ERROR
+func NewInternalErrorWrapped(cause error) *DomainError {
+	return &DomainError{
+		Code:       ErrCodeInternal,
+		Message:    "an internal error occurred",
+		HTTPStatus: 500,
+		Cause:      cause,
+	}
+}
+
 // Common error instances for reuse
 var (
 	// ErrConfigNotFound is returned when configuration is not found
 	ErrConfigNotFound = New(NotFound, "configuration not found")
-	
+
 	// ErrAuthFileNotFound is returned when an auth file is not found
 	ErrAuthFileNotFound = New(NotFound, "auth file not found")
-	
+
 	// ErrInvalidConfig is returned when configuration is invalid
 	ErrInvalidConfig = New(ValidationFailed, "invalid configuration")
-	
+
 	// ErrAuthManagerUnavailable is returned when the auth manager is not available
 	ErrAuthManagerUnavailable = New(ServiceUnavailable, "auth manager unavailable")
-	
+
 	// ErrTokenStoreUnavailable is returned when the token store is not available
 	ErrTokenStoreUnavailable = New(ServiceUnavailable, "token store unavailable")
-	
+
 	// ErrLogDirectoryNotConfigured is returned when log directory is not set
 	ErrLogDirectoryNotConfigured = New(InternalError, "log directory not configured")
-	
+
 	// ErrLoggingDisabled is returned when logging to file is disabled
 	ErrLoggingDisabled = New(ServiceUnavailable, "logging to file disabled")
-)
+)

internal/domain/ports/rate_limit.go

@@ -1,43 +0,0 @@
-package ports
-
-import (
-	"context"
-	"time"
-)
-
-// RateLimitEntry represents the state of a rate limit for a key (e.g., IP address).
-type RateLimitEntry struct {
-	Key          string
-	Count        int       // Current count of attempts or tokens used
-	LastAttempt  time.Time // Timestamp of the last attempt
-	BlockedUntil time.Time // Time until which the key is blocked (zero time if not blocked)
-}
-
-// RateLimitRepository defines the interface for persisting rate limit data.
-type RateLimitRepository interface {
-	// Get retrieves the rate limit entry for a given key.
-	Get(ctx context.Context, key string) (*RateLimitEntry, error)
-
-	// Set saves the rate limit entry for a given key with an expiration.
-	Set(ctx context.Context, key string, entry *RateLimitEntry, expiration time.Duration) error
-
-	// Cleanup removes entries older than the specified time.
-	Cleanup(ctx context.Context, olderThan time.Time) error
-}
-
-// RateLimitService defines the interface for the rate limiting logic.
-type RateLimitService interface {
-	// Allow checks if a request from the given key is allowed based on the rate limit policy.
-	// It basically checks if the key is currently blocked.
-	Allow(ctx context.Context, key string) (bool, error)
-
-	// RecordAttempt records a request or action attempt for the given key.
-	// success: indicates if the attempt was successful.
-	// If success is true, it might reset the failure count.
-	// If success is false, it increments the failure count and might block the key.
-	RecordAttempt(ctx context.Context, key string, success bool) error
-
-	// IsBlocked checks if the key is currently blocked and returns the blockage details.
-	// Returns true if blocked, the time until it's blocked, and any error.
-	IsBlocked(ctx context.Context, key string) (bool, time.Time, error)
-}

internal/domain/ports/repositories.go

@@ -15,67 +15,67 @@ import (
 type ConfigRepository interface {
 	// Load retrieves the current configuration
 	Load(ctx context.Context) (*config.Config, error)
-	
+
 	// Save persists the configuration
 	Save(ctx context.Context, cfg *config.Config) error
-	
+
 	// SaveWithPath persists the configuration to a specific path
 	SaveWithPath(ctx context.Context, path string, cfg *config.Config) error
-	
+
 	// Validate validates the configuration without saving
 	Validate(ctx context.Context, cfg *config.Config) error
-	
+
 	// GetConfigPath returns the current configuration file path
 	GetConfigPath() string
 }
 
 // AuthFile represents an authentication file in the domain
 type AuthFile struct {
-	ID             string
-	Provider       string
-	FileName       string
-	Label          string
-	Email          string
-	Status         string
-	StatusMessage  string
-	Disabled       bool
-	Unavailable    bool
-	RuntimeOnly    bool
-	Path           string
-	Size           int64
-	CreatedAt      time.Time
-	UpdatedAt      time.Time
+	ID              string
+	Provider        string
+	FileName        string
+	Label           string
+	Email           string
+	Status          string
+	StatusMessage   string
+	Disabled        bool
+	Unavailable     bool
+	RuntimeOnly     bool
+	Path            string
+	Size            int64
+	CreatedAt       time.Time
+	UpdatedAt       time.Time
 	LastRefreshedAt time.Time
-	Metadata       map[string]interface{}
-	Attributes     map[string]string
+	Metadata        map[string]interface{}
+	Attributes      map[string]string
 }
 
 // AuthRepository defines the interface for authentication file persistence
 type AuthRepository interface {
 	// List retrieves all authentication files
 	List(ctx context.Context) ([]*AuthFile, error)
-	
+
 	// GetByID retrieves an authentication file by its ID
 	GetByID(ctx context.Context, id string) (*AuthFile, error)
-	
+
 	// GetByName retrieves an authentication file by its filename
 	GetByName(ctx context.Context, name string) (*AuthFile, error)
-	
+
 	// Save persists an authentication file
 	Save(ctx context.Context, file *AuthFile) error
-	
+
 	// Delete removes an authentication file
 	Delete(ctx context.Context, id string) error
-	
+
 	// DeleteAll removes all authentication files
 	DeleteAll(ctx context.Context) (int, error)
-	
+
 	// Disable marks an authentication file as disabled
 	Disable(ctx context.Context, id string, reason string) error
-	
+
 	// Enable marks an authentication file as enabled
 	Enable(ctx context.Context, id string) error
-	
+
 	// GetAuthDir returns the authentication directory path
 	GetAuthDir() string
 }
@@ -94,25 +94,25 @@ type LogEntry struct {
 type LogRepository interface {
 	// ListLogFiles retrieves all log files
 	ListLogFiles(ctx context.Context) ([]*LogFileInfo, error)
-	
+
 	// ReadLogFile reads a log file with optional filtering
 	ReadLogFile(ctx context.Context, filename string, after int64, limit int) (*LogContent, error)
-	
+
 	// DeleteLogFiles removes all log files and truncates the active log
 	DeleteLogFiles(ctx context.Context) (*DeleteLogResult, error)
-	
+
 	// GetRequestErrorLogs retrieves error request log files
 	GetRequestErrorLogs(ctx context.Context) ([]*LogFileInfo, error)
-	
+
 	// GetRequestLogByID retrieves a specific request log by ID
 	GetRequestLogByID(ctx context.Context, requestID string) ([]byte, error)
-	
+
 	// DownloadRequestErrorLog downloads a specific error log file
 	DownloadRequestErrorLog(ctx context.Context, filename string) ([]byte, error)
-	
+
 	// GetLogDirectory returns the log directory path
 	GetLogDirectory() string
-	
+
 	// IsLoggingEnabled returns whether logging to file is enabled
 	IsLoggingEnabled() bool
 }
@@ -155,35 +155,35 @@ type TokenRecord struct {
 type TokenStore interface {
 	// Save persists a token record
 	Save(ctx context.Context, record *TokenRecord) (string, error)
-	
+
 	// Delete removes a token record
 	Delete(ctx context.Context, path string) error
-	
+
 	// Get retrieves a token record by path
 	Get(ctx context.Context, path string) (*TokenRecord, error)
-	
+
 	// List retrieves all token records
 	List(ctx context.Context) ([]*TokenRecord, error)
 }
 
 // UsageStatistics represents usage statistics data
 type UsageStatistics struct {
-	TotalRequests  int64
-	FailureCount   int64
-	RequestCount   int64
-	TokenCount     int64
-	LastUpdated    time.Time
-	Data           map[string]interface{}
+	TotalRequests int64
+	FailureCount  int64
+	RequestCount  int64
+	TokenCount    int64
+	LastUpdated   time.Time
+	Data          map[string]interface{}
 }
 
 // UsageRepository defines the interface for usage statistics persistence
 type UsageRepository interface {
 	// GetStatistics retrieves current usage statistics
 	GetStatistics(ctx context.Context) (*UsageStatistics, error)
-	
+
 	// ExportStatistics exports statistics for backup
 	ExportStatistics(ctx context.Context) (*UsageStatistics, error)
-	
+
 	// ImportStatistics imports statistics from backup
 	ImportStatistics(ctx context.Context, stats *UsageStatistics) (*ImportResult, error)
 }
@@ -197,34 +197,34 @@ type ImportResult struct {
 
 // OAuthSession represents an OAuth session
 type OAuthSession struct {
-	State       string
-	Provider    string
-	Status      string
-	Error       string
-	CreatedAt   time.Time
-	ExpiresAt   time.Time
+	State     string
+	Provider  string
+	Status    string
+	Error     string
+	CreatedAt time.Time
+	ExpiresAt time.Time
 }
 
 // OAuthSessionRepository defines the interface for OAuth session management
 type OAuthSessionRepository interface {
 	// Create creates a new OAuth session
 	Create(ctx context.Context, session *OAuthSession) error
-	
+
 	// Get retrieves an OAuth session by state
 	Get(ctx context.Context, state string) (*OAuthSession, error)
-	
+
 	// Update updates an OAuth session
 	Update(ctx context.Context, session *OAuthSession) error
-	
+
 	// Complete marks an OAuth session as complete
 	Complete(ctx context.Context, state string) error
-	
+
 	// SetError sets an error on an OAuth session
 	SetError(ctx context.Context, state string, err string) error
-	
+
 	// IsPending checks if a session is pending
 	IsPending(ctx context.Context, state string) bool
-	
+
 	// Cleanup removes expired sessions
 	Cleanup(ctx context.Context) error
-}
+}

internal/domain/ports/services.go

@@ -13,97 +13,97 @@ import (
 type ConfigService interface {
 	// GetConfig retrieves the current configuration
 	GetConfig(ctx context.Context) (*config.Config, error)
-	
+
 	// UpdateConfig updates the entire configuration
 	UpdateConfig(ctx context.Context, cfg *config.Config) error
-	
+
 	// UpdateField updates a single configuration field
 	UpdateField(ctx context.Context, field string, value interface{}) error
-	
+
 	// UpdateAPIKeys updates the API keys list
 	UpdateAPIKeys(ctx context.Context, keys []string) error
-	
+
 	// UpdateGeminiKeys updates the Gemini keys list
 	UpdateGeminiKeys(ctx context.Context, keys []config.GeminiKey) error
-	
+
 	// UpdateClaudeKeys updates the Claude keys list
 	UpdateClaudeKeys(ctx context.Context, keys []config.ClaudeKey) error
-	
+
 	// UpdateCodexKeys updates the Codex keys list
 	UpdateCodexKeys(ctx context.Context, keys []config.CodexKey) error
-	
+
 	// UpdateOpenAICompatibility updates the OpenAI compatibility entries
 	UpdateOpenAICompatibility(ctx context.Context, entries []config.OpenAICompatibility) error
-	
+
 	// UpdateVertexCompatKeys updates the Vertex compatibility keys
 	UpdateVertexCompatKeys(ctx context.Context, keys []config.VertexCompatKey) error
-	
+
 	// UpdateKiroKeys updates the Kiro keys list
 	UpdateKiroKeys(ctx context.Context, keys []config.KiroKey) error
-	
+
 	// UpdateOAuthExcludedModels updates OAuth excluded models
 	UpdateOAuthExcludedModels(ctx context.Context, models map[string][]string) error
-	
+
 	// UpdateOAuthModelAlias updates OAuth model aliases
 	UpdateOAuthModelAlias(ctx context.Context, aliases map[string][]config.OAuthModelAlias) error
-	
+
 	// UpdateAmpCode updates the AmpCode configuration
 	UpdateAmpCode(ctx context.Context, ampCode config.AmpCode) error
-	
+
 	// UpdateAmpUpstreamURL updates the Amp upstream URL
 	UpdateAmpUpstreamURL(ctx context.Context, url string) error
-	
+
 	// UpdateAmpModelMappings updates Amp model mappings
 	UpdateAmpModelMappings(ctx context.Context, mappings []config.AmpModelMapping) error
-	
+
 	// UpdateAmpUpstreamAPIKeys updates Amp upstream API keys
 	UpdateAmpUpstreamAPIKeys(ctx context.Context, keys []config.AmpUpstreamAPIKeyEntry) error
-	
+
 	// UpdateDebug updates the debug setting
 	UpdateDebug(ctx context.Context, enabled bool) error
-	
+
 	// UpdateUsageStatisticsEnabled updates the usage statistics enabled setting
 	UpdateUsageStatisticsEnabled(ctx context.Context, enabled bool) error
-	
+
 	// UpdateLoggingToFile updates the logging to file setting
 	UpdateLoggingToFile(ctx context.Context, enabled bool) error
-	
+
 	// UpdateLogsMaxTotalSizeMB updates the max log size
 	UpdateLogsMaxTotalSizeMB(ctx context.Context, sizeMB int) error
-	
+
 	// UpdateRequestLog updates the request log setting
 	UpdateRequestLog(ctx context.Context, enabled bool) error
-	
+
 	// UpdateWebsocketAuth updates the websocket auth setting
 	UpdateWebsocketAuth(ctx context.Context, enabled bool) error
-	
+
 	// UpdateRequestRetry updates the request retry count
 	UpdateRequestRetry(ctx context.Context, retry int) error
-	
+
 	// UpdateMaxRetryInterval updates the max retry interval
 	UpdateMaxRetryInterval(ctx context.Context, interval int) error
-	
+
 	// UpdateForceModelPrefix updates the force model prefix setting
 	UpdateForceModelPrefix(ctx context.Context, enabled bool) error
-	
+
 	// UpdateRoutingStrategy updates the routing strategy
 	UpdateRoutingStrategy(ctx context.Context, strategy string) error
-	
+
 	// UpdateProxyURL updates the proxy URL
 	UpdateProxyURL(ctx context.Context, url string) error
-	
+
 	// UpdateRemoteManagement updates the remote management settings
 	UpdateRemoteManagement(ctx context.Context, allowRemote bool, secretHash string) error
-	
+
 	// UpdateQuotaExceeded updates the quota exceeded settings
 	UpdateQuotaExceeded(ctx context.Context, switchProject, switchPreviewModel bool) error
-	
+
 	// Validate validates the current configuration
 	Validate(ctx context.Context) error
-	
+
 	// ValidateConfig validates a specific configuration
 	ValidateConfig(ctx context.Context, cfg *config.Config) error
-	
+
 	// GetLatestVersion retrieves the latest version from GitHub
 	GetLatestVersion(ctx context.Context) (string, error)
 }
@@ -112,31 +112,31 @@ type ConfigService interface {
 type AuthFileService interface {
 	// ListAuthFiles retrieves all authentication files
 	ListAuthFiles(ctx context.Context) ([]*AuthFile, error)
-	
+
 	// GetAuthFile retrieves a single authentication file by ID
 	GetAuthFile(ctx context.Context, id string) (*AuthFile, error)
-	
+
 	// GetAuthFileModels retrieves models supported by an auth file
 	GetAuthFileModels(ctx context.Context, id string) ([]*AuthFileModel, error)
-	
+
 	// UploadAuthFile uploads a new authentication file
 	UploadAuthFile(ctx context.Context, filename string, data []byte) (*AuthFile, error)
-	
+
 	// DownloadAuthFile retrieves the raw content of an auth file
 	DownloadAuthFile(ctx context.Context, id string) ([]byte, error)
-	
+
 	// DeleteAuthFile deletes an authentication file
 	DeleteAuthFile(ctx context.Context, id string) error
-	
+
 	// DeleteAllAuthFiles deletes all authentication files
 	DeleteAllAuthFiles(ctx context.Context) (int, error)
-	
+
 	// DisableAuthFile disables an authentication file
 	DisableAuthFile(ctx context.Context, id string) error
-	
+
 	// EnableAuthFile enables an authentication file
 	EnableAuthFile(ctx context.Context, id string) error
-	
+
 	// RefreshAuthToken refreshes the token for an auth file
 	RefreshAuthToken(ctx context.Context, id string) error
 }
@@ -153,16 +153,16 @@ type AuthFileModel struct {
 type LogService interface {
 	// GetLogs retrieves log entries with optional filtering
 	GetLogs(ctx context.Context, after int64, limit int) (*LogContent, error)
-	
+
 	// DeleteLogs removes all log files
 	DeleteLogs(ctx context.Context) (*DeleteLogResult, error)
-	
+
 	// GetRequestErrorLogs retrieves error request log files
 	GetRequestErrorLogs(ctx context.Context) ([]*LogFileInfo, error)
-	
+
 	// GetRequestLogByID retrieves a specific request log by ID
 	GetRequestLogByID(ctx context.Context, requestID string) ([]byte, error)
-	
+
 	// DownloadRequestErrorLog downloads a specific error log file
 	DownloadRequestErrorLog(ctx context.Context, filename string) ([]byte, error)
 }
@@ -171,10 +171,10 @@ type LogService interface {
 type UsageService interface {
 	// GetUsageStatistics retrieves current usage statistics
 	GetUsageStatistics(ctx context.Context) (*UsageStatistics, error)
-	
+
 	// ExportUsageStatistics exports statistics for backup
 	ExportUsageStatistics(ctx context.Context) (*UsageStatistics, error)
-	
+
 	// ImportUsageStatistics imports statistics from backup
 	ImportUsageStatistics(ctx context.Context, stats *UsageStatistics) (*ImportResult, error)
 }
@@ -183,13 +183,13 @@ type UsageService interface {
 type OAuthService interface {
 	// InitiateAuth initiates OAuth authentication for a provider
 	InitiateAuth(ctx context.Context, provider string, options *OAuthOptions) (*OAuthInitResult, error)
-	
+
 	// CompleteAuth completes OAuth authentication with a code
 	CompleteAuth(ctx context.Context, state string, code string) (*AuthFile, error)
-	
+
 	// GetAuthStatus retrieves the status of an OAuth session
 	GetAuthStatus(ctx context.Context, state string) (*OAuthSessionStatus, error)
-	
+
 	// CancelAuth cancels an ongoing OAuth session
 	CancelAuth(ctx context.Context, state string) error
 }
@@ -209,26 +209,26 @@ type OAuthInitResult struct {
 
 // OAuthSessionStatus represents the status of an OAuth session
 type OAuthSessionStatus struct {
-	State     string
-	Status    string // "pending", "complete", "error"
-	Error     string
-	Provider  string
+	State    string
+	Status   string // "pending", "complete", "error"
+	Error    string
+	Provider string
 }
 
 // ManagementService defines operations for management functionality
 type ManagementService interface {
 	// VerifyManagementKey verifies a management key
 	VerifyManagementKey(ctx context.Context, key string, clientIP string) error
-	
+
 	// IsRemoteAllowed checks if remote management is allowed for a client
 	IsRemoteAllowed(ctx context.Context, clientIP string) bool
-	
+
 	// RecordFailedAttempt records a failed authentication attempt
 	RecordFailedAttempt(ctx context.Context, clientIP string)
-	
+
 	// IsBlocked checks if a client IP is blocked
 	IsBlocked(ctx context.Context, clientIP string) (bool, string)
-	
+
 	// GetVersionInfo retrieves version information
 	GetVersionInfo(ctx context.Context) (*VersionInfo, error)
 }
@@ -244,18 +244,18 @@ type VersionInfo struct {
 type APICallService interface {
 	// MakeAPICall makes a generic HTTP API call
 	MakeAPICall(ctx context.Context, req *APICallRequest) (*APICallResponse, error)
-	
+
 	// ResolveToken resolves a token for an auth index
 	ResolveToken(ctx context.Context, authIndex string) (string, error)
 }
 
 // APICallRequest contains parameters for an API call
 type APICallRequest struct {
-	AuthIndex  string
-	Method     string
-	URL        string
-	Headers    map[string]string
-	Body       string
+	AuthIndex string
+	Method    string
+	URL       string
+	Headers   map[string]string
+	Body      string
 }
 
 // APICallResponse contains the response from an API call
@@ -263,4 +263,4 @@ type APICallResponse struct {
 	StatusCode int
 	Headers    map[string][]string
 	Body       string
-}
+}

internal/domain/services/auth_service.go

@@ -319,4 +319,4 @@ func (s *AuthService) RefreshAuthToken(ctx context.Context, id string) error {
 }
 
 // Ensure AuthService implements the interface
-var _ ports.AuthFileService = (*AuthService)(nil)
+var _ ports.AuthFileService = (*AuthService)(nil)

internal/domain/services/config_service.go

@@ -508,7 +508,7 @@ func (s *ConfigService) GetLatestVersion(ctx context.Context) (string, error) {
 		util.SetProxy(sdkCfg, client)
 	}
 
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, latestReleaseURL, nil)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, latestReleaseURL, http.NoBody)
 	if err != nil {
 		return "", errors.Wrap(errors.InternalError, "failed to create request", err)
 	}
@@ -674,4 +674,4 @@ func toInt(v interface{}) (int, bool) {
 }
 
 // Ensure ConfigService implements the interface
-var _ ports.ConfigService = (*ConfigService)(nil)
+var _ ports.ConfigService = (*ConfigService)(nil)

internal/domain/services/log_service.go

@@ -128,4 +128,4 @@ func (s *LogService) DownloadRequestErrorLog(ctx context.Context, filename strin
 }
 
 // Ensure LogService implements the interface
-var _ ports.LogService = (*LogService)(nil)
+var _ ports.LogService = (*LogService)(nil)

internal/domain/services/rate_limit_service.go

@@ -1,153 +0,0 @@
-package services
-
-import (
-	"context"
-	"time"
-
-	"github.com/router-for-me/CLIProxyAPI/v6/internal/domain/ports"
-)
-
-// RateLimitConfig holds the configuration for the RateLimitService.
-type RateLimitConfig struct {
-	MaxFailures          int           // Maximum number of failures allowed before blocking
-	FailureDecayInterval time.Duration // Time duration to forgive one failure (leak rate)
-	BlockDuration        time.Duration // Duration to block the key after MaxFailures is reached
-}
-
-// RateLimitService implements the RateLimitService interface.
-type RateLimitService struct {
-	repo   ports.RateLimitRepository
-	config RateLimitConfig
-	// now returns the current time. It is a field to allow mocking in tests.
-	now func() time.Time
-}
-
-// NewRateLimitService creates a new instance of RateLimitService.
-func NewRateLimitService(repo ports.RateLimitRepository, config RateLimitConfig) *RateLimitService {
-	return &RateLimitService{
-		repo:   repo,
-		config: config,
-		now:    time.Now,
-	}
-}
-
-// Allow checks if the request is allowed.
-func (s *RateLimitService) Allow(ctx context.Context, key string) (bool, error) {
-	blocked, _, err := s.IsBlocked(ctx, key)
-	if err != nil {
-		return false, err
-	}
-	return !blocked, nil
-}
-
-// IsBlocked checks if the key is currently blocked.
-func (s *RateLimitService) IsBlocked(ctx context.Context, key string) (bool, time.Time, error) {
-	entry, err := s.repo.Get(ctx, key)
-	if err != nil {
-		return false, time.Time{}, err
-	}
-	if entry == nil {
-		return false, time.Time{}, nil
-	}
-
-	// Check if blocked
-	if !entry.BlockedUntil.IsZero() {
-		if s.now().After(entry.BlockedUntil) {
-			// Block has expired.
-			// Ideally, we should clear the block state in the repo, but "Get" is read-only.
-			// The next RecordAttempt will clean it up or we can lazily accept it as allowed.
-			return false, time.Time{}, nil
-		}
-		return true, entry.BlockedUntil, nil
-	}
-
-	return false, time.Time{}, nil
-}
-
-// RecordAttempt records the result of an action.
-func (s *RateLimitService) RecordAttempt(ctx context.Context, key string, success bool) error {
-	entry, err := s.repo.Get(ctx, key)
-	if err != nil {
-		return err
-	}
-
-	now := s.now()
-
-	if entry == nil {
-		entry = &ports.RateLimitEntry{
-			Key:         key,
-			LastAttempt: now,
-		}
-	}
-
-	// If the block has expired, reset the state
-	if !entry.BlockedUntil.IsZero() && now.After(entry.BlockedUntil) {
-		entry.BlockedUntil = time.Time{}
-		entry.Count = 0 // Reset count after block expiry
-		entry.LastAttempt = now
-	}
-
-	// If currently blocked, we might choose to extend or just return.
-	// For now, if blocked, we don't count further failures (or we could).
-	// Let's assume we don't process attempts while blocked (caller should have checked Allow).
-	if !entry.BlockedUntil.IsZero() && now.Before(entry.BlockedUntil) {
-		// Still blocked, nothing to update?
-		// Or should we extend? Let's just keep the existing block.
-		return nil
-	}
-
-	// Apply Leaky Bucket Logic (Decay)
-	if s.config.FailureDecayInterval > 0 {
-		elapsed := now.Sub(entry.LastAttempt)
-		decay := int(elapsed / s.config.FailureDecayInterval)
-		if decay > 0 {
-			entry.Count -= decay
-			if entry.Count < 0 {
-				entry.Count = 0
-			}
-			// We effectively used up the time for these decays.
-			// To be precise with remaining time, we could adjust LastAttempt,
-			// but for simplicity, we'll just set LastAttempt to now at the end if we update.
-		}
-	}
-
-	if success {
-		// On success, we generally don't increase failure count.
-		// We could decrease it (reward) or just let time decay it.
-		// Let's just update LastAttempt to keep the record alive and accurate for decay calculation.
-		// Actually, if we update LastAttempt without reducing count (via decay), we stop the decay from happening?
-		// Wait.
-		// T0: Count=5. Last=T0.
-		// T10 (Decay=10s): Success. Elapsed=10s. Decay=1. Count=4. Last=T10.
-		// This works. We applied the decay that happened during the interval.
-		// So yes, we should run the decay logic and update LastAttempt even on success.
-		entry.LastAttempt = now
-	} else {
-		// Failure
-		entry.Count++
-		entry.LastAttempt = now
-
-		if entry.Count >= s.config.MaxFailures {
-			entry.BlockedUntil = now.Add(s.config.BlockDuration)
-			// Reset count or keep it at max?
-			// Often helpful to keep it at max or 0.
-			// If we keep it at max, future failures after unblock will immediately reblock?
-			// That depends on if we reset on unblock (handled above).
-		}
-	}
-
-
-	// Calculate TTL for the storage entry
-	// It should survive at least until block expires OR until count decays to 0.
-	ttl := s.config.BlockDuration
-	if s.config.FailureDecayInterval > 0 {
-		decayTTL := time.Duration(entry.Count) * s.config.FailureDecayInterval
-		if decayTTL > ttl {
-			ttl = decayTTL
-		}
-	}
-	// Add a buffer to TTL
-	ttl += time.Minute
-
-	return s.repo.Set(ctx, key, entry, ttl)
-}

internal/domain/services/rate_limit_service_test.go

@@ -1,200 +0,0 @@
-package services
-
-import (
-	"context"
-	"testing"
-	"time"
-
-	"github.com/router-for-me/CLIProxyAPI/v6/internal/domain/ports"
-	"github.com/router-for-me/CLIProxyAPI/v6/internal/infrastructure/persistence"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestRateLimitService(t *testing.T) {
-	repo := persistence.NewInMemoryRateLimitRepository()
-	config := RateLimitConfig{
-		MaxFailures:          3,
-		FailureDecayInterval: time.Minute,
-		BlockDuration:        10 * time.Minute,
-	}
-
-	service := NewRateLimitService(repo, config)
-
-	// Mock time
-	currentTime := time.Date(2023, 1, 1, 10, 0, 0, 0, time.UTC)
-	service.now = func() time.Time {
-		return currentTime
-	}
-
-	ctx := context.Background()
-	key := "127.0.0.1"
-
-	// 1. Initial State: Allowed
-	allowed, err := service.Allow(ctx, key)
-	assert.NoError(t, err)
-	assert.True(t, allowed, "Initial state should be allowed")
-
-	// 2. Record 2 Failures
-	err = service.RecordAttempt(ctx, key, false)
-	assert.NoError(t, err)
-	err = service.RecordAttempt(ctx, key, false)
-	assert.NoError(t, err)
-
-	// Still allowed
-	allowed, err = service.Allow(ctx, key)
-	assert.NoError(t, err)
-	assert.True(t, allowed, "Should be allowed after 2 failures (max 3)")
-
-	// Check underlying state (optional, white-box testing)
-	entry, _ := repo.Get(ctx, key)
-	assert.Equal(t, 2, entry.Count)
-
-	// 3. Record 3rd Failure -> Blocked
-	err = service.RecordAttempt(ctx, key, false)
-	assert.NoError(t, err)
-
-	allowed, err = service.Allow(ctx, key)
-	assert.NoError(t, err)
-	assert.False(t, allowed, "Should be blocked after 3 failures")
-
-	isBlocked, until, err := service.IsBlocked(ctx, key)
-	assert.NoError(t, err)
-	assert.True(t, isBlocked)
-	assert.Equal(t, currentTime.Add(config.BlockDuration), until)
-
-	// 4. Advance time past block duration
-	currentTime = currentTime.Add(config.BlockDuration).Add(time.Second)
-
-	allowed, err = service.Allow(ctx, key)
-	assert.NoError(t, err)
-	assert.True(t, allowed, "Should be allowed after block expires")
-	
-	// Record an attempt after expiry - should reset logic
-	err = service.RecordAttempt(ctx, key, true) // Success attempt
-	assert.NoError(t, err)
-	
-	entry, _ = repo.Get(ctx, key)
-	assert.Equal(t, 0, entry.Count, "Count should be reset after block expiry")
-
-	// 5. Test Decay
-	// Reset
-	currentTime = time.Date(2023, 1, 1, 12, 0, 0, 0, time.UTC)
-	repo = persistence.NewInMemoryRateLimitRepository()
-	service = NewRateLimitService(repo, config)
-	service.now = func() time.Time { return currentTime }
-
-	// 2 failures
-	service.RecordAttempt(ctx, key, false)
-	service.RecordAttempt(ctx, key, false)
-
-	entry, _ = repo.Get(ctx, key)
-	assert.Equal(t, 2, entry.Count)
-
-	// Advance time by 1 minute (1 decay interval)
-	currentTime = currentTime.Add(time.Minute)
-
-	// Record another failure. 
-	// Before record: elapsed=1m, decay=1. Count becomes 1.
-	// After record: Count becomes 2.
-	service.RecordAttempt(ctx, key, false)
-
-	entry, _ = repo.Get(ctx, key)
-	assert.Equal(t, 2, entry.Count, "Count should be 2 (2 decayed to 1, then +1)")
-	
-	allowed, err = service.Allow(ctx, key)
-	assert.True(t, allowed, "Should still be allowed")
-
-	// 6. Test Success resets nothing but updates time (Leaky Bucket Standard)
-	// Reset
-	currentTime = time.Date(2023, 1, 1, 13, 0, 0, 0, time.UTC)
-	repo = persistence.NewInMemoryRateLimitRepository()
-	service = NewRateLimitService(repo, config)
-	service.now = func() time.Time { return currentTime }
-	
-	service.RecordAttempt(ctx, key, false) // Count 1
-	currentTime = currentTime.Add(30 * time.Second) // 0.5 decay
-	service.RecordAttempt(ctx, key, true) // Success. Should update LastAttempt.
-	
-	entry, _ = repo.Get(ctx, key)
-	assert.Equal(t, 1, entry.Count)
-	assert.Equal(t, currentTime, entry.LastAttempt)
-	
-	currentTime = currentTime.Add(30 * time.Second) // Another 0.5 decay. Total 1 min since start.
-	// But LastAttempt was updated at 30s. So elapsed is 30s. Decay = 0.
-	// This is the "Leaky Bucket" behavior where consistent activity keeps it full?
-	// Wait. If I update LastAttempt on success without reducing count, I am resetting the decay timer.
-	// If I have 0.9 decay pending, and I succeed, I reset timer to 0 decay pending.
-	// This penalizes frequent successful requests if they happen faster than decay rate?
-	// No, because success doesn't add to count.
-	// But it does delay the decay of existing failures.
-	// If I fail once, then spam successes every second, the failure will never decay because elapsed < interval always.
-	// This might be unintended.
-	// FIX: We should accumulate partial decay or NOT update LastAttempt on success if we want purely time-based decay regardless of activity.
-	// However, usually Rate Limiters *do* care about activity.
-	// But for "Failure Rate Limiting", success shouldn't prevent failure decay.
-	// Implementation choice:
-	// A) Update LastAttempt on success: Active users keep their "failure score" longer. (Strict)
-	// B) Don't update LastAttempt on success: Failures decay based on absolute time since last failure (or last check).
-	// My implementation does (A).
-	
-	// Let's verify behavior A is what we have.
-	service.RecordAttempt(ctx, key, false) // Count 1 + 0 (decay) = 2.
-	// If behavior B (don't update on success), elapsed would be 30s from last failure check? No, LastAttempt was updated on success.
-	// So we expect Count to be 2.
-	// If we hadn't updated on success, elapsed would be 60s from first failure. Decay 1. Count would be 1.
-	
-	assert.Equal(t, 2, entry.Count + 1) // Logic check, wait.
-	
-	// Let's not assert on implementation detail of success-decay interaction unless specified.
-	// I'll stick to asserting the "failures trigger block" and "time decays failures" basics.
-}
-
-func TestRateLimitService_Cleanup(t *testing.T) {
-	repo := persistence.NewInMemoryRateLimitRepository()
-	config := RateLimitConfig{
-		MaxFailures: 3,
-		BlockDuration: time.Minute,
-	}
-	service := NewRateLimitService(repo, config)
-	
-	// Mock time
-	currentTime := time.Date(2023, 1, 1, 10, 0, 0, 0, time.UTC)
-	service.now = func() time.Time { return currentTime }
-	
-	ctx := context.Background()
-	
-	// Add entry
-	service.RecordAttempt(ctx, "key1", false)
-	
-	// Verify exists
-	entry, _ := repo.Get(ctx, "key1")
-	assert.NotNil(t, entry)
-	
-	// Advance time past expiration (Repo sets TTL = BlockDuration + buffer)
-	// TTL logic: BlockDuration (1m) + 1m buffer = 2m.
-	// Wait, code says `ttl += time.Minute`.
-	
-	// Manually invoke cleanup on repo?
-	// Persistence layer relies on expiration check in Get() or manual Cleanup().
-	// Let's test manual cleanup.
-	
-	// Add old entry directly to repo to test Cleanup logic
-	oldTime := currentTime.Add(-24 * time.Hour)
-	repo.Set(ctx, "old_key", &ports.RateLimitEntry{
-		Key: "old_key",
-		LastAttempt: oldTime,
-	}, time.Hour)
-	
-	// We need to advance "real" time for `Get` to see it as expired?
-	// `Get` uses `time.Now()`, not the service mocked time.
-	// Ah, the repository implementation uses `time.Now()` directly!
-	// My mock only affects the Service.
-	// Testing expiration in `Get` relies on system time.
-	
-	// To test Cleanup properly, we should probably mock time in Repo too, or just test logic that doesn't rely on `time.Now()` inside Repo for this specific unit test, 
-	// OR just trust the logic I wrote:
-	// `if now.After(item.expiresAt) { delete }`
-	
-	// Since I cannot mock time in the Repo (it uses `time.Now`), I will skip strict expiration tests that rely on waiting,
-	// or assume `Cleanup` works as implemented.
-}

internal/infrastructure/logging/structured.go

@@ -20,7 +20,7 @@ type contextKey string
 
 const (
 	// CorrelationIDKey is the context key for correlation IDs
-	CorrelationIDKey contextKey = "correlation_id"
+	CorrelationIDKey contextKey = "request_id"
 	// ServiceKey is the context key for service name
 	ServiceKey contextKey = "service_name"
 	// OperationKey is the context key for operation name
@@ -79,7 +79,7 @@ func (l *StructuredLogger) Configure(cfg *config.Config) error {
 		}
 
 		logPath := filepath.Join(logDir, "main.log")
-		
+
 		if l.logWriter != nil {
 			_ = l.logWriter.Close()
 		}
@@ -232,6 +232,11 @@ func GetCorrelationID(ctx context.Context) string {
 	if ctx == nil {
 		return ""
 	}
+	// Try string key first (from Gin middleware)
+	if id, ok := ctx.Value("request_id").(string); ok {
+		return id
+	}
+	// Try typed key
 	if id, ok := ctx.Value(CorrelationIDKey).(string); ok {
 		return id
 	}
@@ -292,4 +297,4 @@ func GetLogger() *StructuredLogger {
 // SetLogger sets the global structured logger instance
 func SetLogger(logger *StructuredLogger) {
 	globalLogger = logger
-}
+}

internal/infrastructure/persistence/auth_repository.go

@@ -17,9 +17,9 @@ import (
 
 // AuthRepository implements the ports.AuthRepository interface
 type AuthRepository struct {
-	authDir    string
+	authDir     string
 	authManager *coreauth.Manager
-	mu         sync.RWMutex
+	mu          sync.RWMutex
 }
 
 // NewAuthRepository creates a new AuthRepository
@@ -207,7 +207,7 @@ func (r *AuthRepository) Delete(ctx context.Context, id string) error {
 	defer r.mu.Unlock()
 
 	fullPath := filepath.Join(r.authDir, id)
-	
+
 	if !strings.HasSuffix(fullPath, ".json") {
 		fullPath += ".json"
 	}
@@ -260,7 +260,7 @@ func (r *AuthRepository) DeleteAll(ctx context.Context) (int, error) {
 		fullPath := filepath.Join(r.authDir, name)
 		if err := os.Remove(fullPath); err == nil {
 			deleted++
-			
+
 			// Disable in auth manager
 			if r.authManager != nil {
 				if auth, ok := r.authManager.GetByID(name); ok {
@@ -407,17 +407,17 @@ func (r *AuthRepository) mapFileToAuth(file *ports.AuthFile) *coreauth.Auth {
 	}
 
 	return &coreauth.Auth{
-		ID:         file.ID,
-		Provider:   file.Provider,
-		FileName:   file.FileName,
-		Label:      file.Label,
-		Status:     coreauth.Status(file.Status),
-		Disabled:   file.Disabled,
+		ID:          file.ID,
+		Provider:    file.Provider,
+		FileName:    file.FileName,
+		Label:       file.Label,
+		Status:      coreauth.Status(file.Status),
+		Disabled:    file.Disabled,
 		Unavailable: file.Unavailable,
-		Metadata:   file.Metadata,
-		Attributes: file.Attributes,
-		CreatedAt:  file.CreatedAt,
-		UpdatedAt:  file.UpdatedAt,
+		Metadata:    file.Metadata,
+		Attributes:  file.Attributes,
+		CreatedAt:   file.CreatedAt,
+		UpdatedAt:   file.UpdatedAt,
 	}
 }
 
@@ -445,4 +445,4 @@ func (r *AuthRepository) SetAuthManager(manager *coreauth.Manager) {
 }
 
 // Ensure AuthRepository implements the interface
-var _ ports.AuthRepository = (*AuthRepository)(nil)
+var _ ports.AuthRepository = (*AuthRepository)(nil)

internal/infrastructure/persistence/config_repository.go

@@ -100,7 +100,7 @@ func (r *ConfigRepository) Validate(ctx context.Context, cfg *config.Config) err
 		return errors.Wrap(errors.InternalError, "failed to create temp file for validation", err)
 	}
 	tmpPath := tmpFile.Name()
-	
+
 	// Cleanup
 	_ = tmpFile.Close()
 	defer os.Remove(tmpPath)
@@ -129,4 +129,4 @@ func (r *ConfigRepository) SetConfigPath(path string) {
 }
 
 // Ensure ConfigRepository implements the interface
-var _ ports.ConfigRepository = (*ConfigRepository)(nil)
+var _ ports.ConfigRepository = (*ConfigRepository)(nil)

internal/infrastructure/persistence/log_index.go

@@ -21,15 +21,15 @@ import (
 
 // LogIndexEntry represents a single entry in the log index
 type LogIndexEntry struct {
-	RequestID    string            `json:"request_id"`
-	Filename     string            `json:"filename"`
-	Timestamp    time.Time         `json:"timestamp"`
-	Method       string            `json:"method"`
-	URL          string            `json:"url"`
-	StatusCode   int               `json:"status_code"`
-	Size         int64             `json:"size"`
-	Offset       int64             `json:"offset"`       // Byte offset in file for O(1) access
-	Tags         map[string]string `json:"tags"`         // Optional tags for filtering
+	RequestID  string            `json:"request_id"`
+	Filename   string            `json:"filename"`
+	Timestamp  time.Time         `json:"timestamp"`
+	Method     string            `json:"method"`
+	URL        string            `json:"url"`
+	StatusCode int               `json:"status_code"`
+	Size       int64             `json:"size"`
+	Offset     int64             `json:"offset"` // Byte offset in file for O(1) access
+	Tags       map[string]string `json:"tags"`   // Optional tags for filtering
 }
 
 // LogIndex provides O(1) lookup for log entries by various criteria
@@ -557,10 +557,10 @@ func (r *IndexedLogRepository) GetIndexStats() map[string]interface{} {
 	defer r.mu.RUnlock()
 
 	return map[string]interface{}{
-		"total_entries":    r.index.Size(),
-		"is_dirty":         r.index.IsDirty(),
-		"index_path":       r.indexPath,
-		"last_persisted":   r.index.lastPersisted,
+		"total_entries":  r.index.Size(),
+		"is_dirty":       r.index.IsDirty(),
+		"index_path":     r.indexPath,
+		"last_persisted": r.index.lastPersisted,
 	}
 }
 

internal/infrastructure/persistence/log_repository.go

@@ -377,15 +377,15 @@ func (r *LogRepository) DownloadRequestErrorLog(ctx context.Context, filename st
 func (r *LogRepository) GetLogDirectory() string {
 	r.mu.RLock()
 	defer r.mu.RUnlock()
-	
+
 	if r.logDir != "" {
 		return r.logDir
 	}
-	
+
 	if r.cfg != nil {
 		return logging.ResolveLogDirectory(r.cfg)
 	}
-	
+
 	return ""
 }
 
@@ -393,7 +393,7 @@ func (r *LogRepository) GetLogDirectory() string {
 func (r *LogRepository) IsLoggingEnabled() bool {
 	r.mu.RLock()
 	defer r.mu.RUnlock()
-	
+
 	if r.cfg == nil {
 		return false
 	}
@@ -631,4 +631,4 @@ func parseTimestamp(line string) int64 {
 }
 
 // Ensure LogRepository implements the interface
-var _ ports.LogRepository = (*LogRepository)(nil)
+var _ ports.LogRepository = (*LogRepository)(nil)