Upload 10 files

Dockerfile

@@ -1,34 +1,54 @@
-# Use an official Python runtime as a parent image
-# Using slim variant for smaller image size
-FROM python:3.10-slim
+# Stage 1: Build the Go application
+FROM golang:1.21-alpine AS builder
 
-# Set environment variables to prevent Python from writing pyc files and buffering stdout/stderr
-ENV PYTHONDONTWRITEBYTECODE 1
-ENV PYTHONUNBUFFERED 1
-# --- Change default port to 7860 ---
-ENV PORT=7860
+# Set necessary environment variables
+ENV CGO_ENABLED=0 GOOS=linux GOARCH=amd64
 
-# Set the working directory in the container
-WORKDIR /app
+WORKDIR /build
 
-# Install system dependencies if needed
-# RUN apt-get update && apt-get install -y --no-install-recommends ... && rm -rf /var/lib/apt/lists/*
+# Copy only the module definition file first
+COPY go.mod ./
+# DO NOT copy go.sum here initially.
 
-# Install Python dependencies
-RUN pip install --no-cache-dir --upgrade pip
-COPY requirements.txt requirements.txt
-RUN pip install --no-cache-dir -r requirements.txt
+# Download dependencies and ensure go.sum is consistent
+# 'go mod tidy' synchronizes the go.mod and go.sum files with the source code imports.
+# It should be run after copying the source code.
+RUN go mod download
 
-# Copy the rest of the application code
+# Copy the rest of the source code AFTER initial download
 COPY . .
 
-# Create a non-root user and switch to it
-RUN useradd --create-home --uid 1001 appuser
-USER appuser
+# Now run tidy to ensure go.mod and go.sum match the code
+RUN go mod tidy
+
+# Verify dependencies (optional but good practice)
+RUN go mod verify
+
+
+# Build the Go application statically linked
+# -ldflags="-w -s" reduces binary size by removing debug info
+RUN go build -ldflags="-w -s" -o /app/proxy-server .
+
+# Stage 2: Create the final minimal image
+FROM alpine:latest
+
+# Install ca-certificates for HTTPS calls and tzdata for timezone info
+RUN apk update && apk add --no-cache ca-certificates tzdata
+
+# Set the working directory
+WORKDIR /app
+
+# Copy the built binary from the builder stage
+COPY --from=builder /app/proxy-server /app/proxy-server
+
+# Expose the port the app runs on (using the default from config or ENV)
+# Defaulting to 7860 if not overridden by ENV PORT in runtime environment
+EXPOSE 7860
 
-# Expose the port the app runs on
-EXPOSE ${PORT}
+# Set the entrypoint command to run the binary
+# The application will read environment variables at runtime
+ENTRYPOINT ["/app/proxy-server"]
 
-# Define the command to run the application using Uvicorn
-# Use shell form to allow ${PORT} substitution
-CMD uvicorn proxy_server:app --host 0.0.0.0 --port ${PORT}
+# Optional: Add a non-root user for security (Uncomment if needed)
+# RUN addgroup -S appgroup && adduser -S appuser -G appgroup
+# USER appuser

auth.go

@@ -0,0 +1,45 @@
+package main
+
+import (
+	"log"
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+)
+
+const APIKeyHeaderName = "X-API-Key"
+
+// APIKeyAuthMiddleware creates a Gin middleware for API key authentication
+func APIKeyAuthMiddleware(validKeys map[string]bool) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		apiKey := c.GetHeader(APIKeyHeaderName)
+
+		if apiKey == "" {
+			log.Printf("WARN: [%s] API Key missing in header '%s'", c.ClientIP(), APIKeyHeaderName)
+			c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{
+				"type": "error",
+				"error": gin.H{
+					"type":    "authentication_error",
+					"message": "API Key required in header '" + APIKeyHeaderName + "'",
+				},
+			})
+			return
+		}
+
+		if _, isValid := validKeys[apiKey]; !isValid {
+			log.Printf("WARN: [%s] Invalid API Key received (length: %d)", c.ClientIP(), len(apiKey))
+			c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{
+				"type": "error",
+				"error": gin.H{
+					"type":    "authentication_error",
+					"message": "Invalid or expired API Key",
+				},
+			})
+			return
+		}
+
+		// Log successful authentication (optional, consider security implications)
+		// log.Printf("INFO: [%s] Valid API key received (length: %d)", c.ClientIP(), len(apiKey))
+		c.Next() // Proceed to the next handler
+	}
+}

config.go

@@ -0,0 +1,120 @@
+package main
+
+import (
+	"log"
+	"net" // <<< Added import
+	"net/http"
+	"net/url"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// Config holds all configuration for the application
+type Config struct {
+	OpenAIAPIEndpoint string
+	OpenAIAPIKey      string
+	ProxyAPIKeys      string // Comma-separated keys
+	ValidAPIKeys      map[string]bool // Set of valid keys for quick lookup
+	ConnectTimeout    time.Duration
+	ReadTimeout       time.Duration
+	WriteTimeout      time.Duration
+	PoolTimeout       time.Duration // Note: Go's default transport manages pooling differently
+	HTTPProxyURL      *url.URL
+	Port              string
+	GinMode           string
+	LogLevel          string // For potential future structured logging integration
+	UpstreamTransport http.RoundTripper // Custom transport for http client
+}
+
+// LoadConfig reads configuration from environment variables
+func LoadConfig() *Config {
+	cfg := &Config{
+		OpenAIAPIEndpoint: getEnv("OPENAI_API_ENDPOINT", "https://api.openai.com/v1/chat/completions"),
+		OpenAIAPIKey:      getEnv("OPENAI_API_KEY", ""),
+		ProxyAPIKeys:      getEnv("PROXY_API_KEYS", ""),
+		ConnectTimeout:    getEnvDuration("CONNECT_TIMEOUT", 5*time.Second),
+		ReadTimeout:       getEnvDuration("READ_TIMEOUT", 180*time.Second),
+		WriteTimeout:      getEnvDuration("WRITE_TIMEOUT", 30*time.Second),
+		PoolTimeout:       getEnvDuration("POOL_TIMEOUT", 5*time.Second), // Less directly applicable in Go's default client
+		Port:              getEnv("PORT", "7860"),
+		GinMode:           getEnv("GIN_MODE", "release"), // "debug" or "release"
+		LogLevel:          getEnv("LOG_LEVEL", "INFO"),
+	}
+
+	// Process API Keys into a map for efficient lookup
+	cfg.ValidAPIKeys = make(map[string]bool)
+	if cfg.ProxyAPIKeys != "" {
+		keys := strings.Split(cfg.ProxyAPIKeys, ",")
+		for _, key := range keys {
+			trimmedKey := strings.TrimSpace(key)
+			if trimmedKey != "" {
+				cfg.ValidAPIKeys[trimmedKey] = true
+			}
+		}
+	}
+
+	// Parse HTTP Proxy URL
+	proxyStr := getEnv("HTTP_PROXY", "")
+	if proxyStr != "" {
+		proxyURL, err := url.Parse(proxyStr)
+		if err != nil {
+			log.Printf("WARN: Invalid HTTP_PROXY URL '%s': %v. Proxy disabled.", proxyStr, err)
+			cfg.HTTPProxyURL = nil
+		} else {
+			cfg.HTTPProxyURL = proxyURL
+			log.Printf("Using outbound proxy: %s", cfg.HTTPProxyURL.String())
+		}
+	}
+
+	// Configure the shared HTTP client transport
+	defaultTransport := http.DefaultTransport.(*http.Transport).Clone()
+	if cfg.HTTPProxyURL != nil { // Set proxy only if URL is valid
+		defaultTransport.Proxy = http.ProxyURL(cfg.HTTPProxyURL)
+	}
+	// Configure timeouts (Connect timeout is part of DialContext)
+	defaultTransport.DialContext = (&net.Dialer{ // <<< Used net.Dialer here
+		Timeout:   cfg.ConnectTimeout, // Connect timeout
+		KeepAlive: 30 * time.Second,   // Keep-alive interval
+	}).DialContext
+	defaultTransport.TLSHandshakeTimeout = 10 * time.Second // TLS handshake timeout
+	defaultTransport.ResponseHeaderTimeout = cfg.ReadTimeout // Timeout waiting for response headers
+	// Go's http client manages connection pooling automatically.
+	// MaxIdleConns, MaxIdleConnsPerHost can be tuned if needed.
+	defaultTransport.MaxIdleConns = 100
+	defaultTransport.MaxIdleConnsPerHost = 10
+	defaultTransport.IdleConnTimeout = 90 * time.Second
+
+	cfg.UpstreamTransport = defaultTransport
+
+	// Log warnings for missing keys
+	if cfg.OpenAIAPIKey == "" {
+		log.Println("WARN: OPENAI_API_KEY is not set.")
+	}
+	if len(cfg.ValidAPIKeys) == 0 {
+		log.Println("WARN: PROXY_API_KEYS is not set. Proxy is open (no authentication).")
+	}
+
+	return cfg
+}
+
+// getEnv reads an environment variable or returns a default value
+func getEnv(key, defaultValue string) string {
+	if value, exists := os.LookupEnv(key); exists {
+		return value
+	}
+	return defaultValue
+}
+
+// getEnvDuration reads an environment variable as seconds and returns a time.Duration
+func getEnvDuration(key string, defaultValue time.Duration) time.Duration {
+	valueStr := getEnv(key, "")
+	if valueStr != "" {
+		if valueFloat, err := strconv.ParseFloat(valueStr, 64); err == nil {
+			return time.Duration(valueFloat * float64(time.Second))
+		}
+		log.Printf("WARN: Invalid duration format for %s: '%s'. Using default: %v", key, valueStr, defaultValue)
+	}
+	return defaultValue
+}

convert.go

@@ -0,0 +1,236 @@
+package main
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"log"
+	"strings"
+)
+
+// Helper function to estimate tokens (same as Python version)
+func estimateTokens(text string) int {
+	if text == "" {
+		return 0
+	}
+	est := len(text) / 3 // Simple heuristic
+	if est == 0 && len(text) > 0 {
+		return 1 // Ensure at least 1 token for non-empty string
+	}
+	return est
+}
+
+// calculateInputTokensFromClaudeRequest estimates input tokens from Claude request
+func calculateInputTokensFromClaudeRequest(claudeReq *ClaudeRequest) int {
+	totalChars := 0
+
+	// Process system prompt
+	if len(claudeReq.System) > 0 {
+		// Try unmarshaling as string first
+		var systemStr string
+		if err := json.Unmarshal(claudeReq.System, &systemStr); err == nil {
+			totalChars += len(systemStr)
+		} else {
+			// Try unmarshaling as list of blocks
+			var systemBlocks []ClaudeContentBlock
+			if err := json.Unmarshal(claudeReq.System, &systemBlocks); err == nil {
+				for _, block := range systemBlocks {
+					if block.Type == "text" {
+						totalChars += len(block.Text)
+					}
+				}
+			} else {
+				log.Printf("WARN: Could not parse system prompt format: %s", string(claudeReq.System))
+			}
+		}
+	}
+
+	// Process messages
+	for _, msg := range claudeReq.Messages {
+		// Try unmarshaling as string first
+		var contentStr string
+		if err := json.Unmarshal(msg.Content, &contentStr); err == nil {
+			totalChars += len(contentStr)
+		} else {
+			// Try unmarshaling as list of blocks
+			var contentBlocks []ClaudeContentBlock
+			if err := json.Unmarshal(msg.Content, &contentBlocks); err == nil {
+				for _, block := range contentBlocks {
+					if block.Type == "text" {
+						totalChars += len(block.Text)
+					}
+				}
+			} else {
+				log.Printf("WARN: Could not parse message content format for role %s: %s", msg.Role, string(msg.Content))
+			}
+		}
+	}
+
+	estimated := estimateTokens(fmt.Sprintf("%d", totalChars)) // Pass total chars as string to estimate
+	log.Printf("DEBUG: Estimated input characters: %d, Estimated input tokens: %d", totalChars, estimated)
+	return estimated
+}
+
+// convertClaudeRequestToOpenAI converts Claude request to OpenAI format
+func convertClaudeRequestToOpenAI(claudeReq *ClaudeRequest) (*OpenAIRequest, error) {
+	openAIMessages := []OpenAIMessage{}
+
+	// --- Handle System Prompt ---
+	if len(claudeReq.System) > 0 {
+		systemContent := ""
+		var systemStr string
+		// Try simple string first
+		if err := json.Unmarshal(claudeReq.System, &systemStr); err == nil {
+			systemContent = systemStr
+		} else {
+			// Try list of blocks
+			var systemBlocks []ClaudeContentBlock
+			if err := json.Unmarshal(claudeReq.System, &systemBlocks); err == nil {
+				var parts []string
+				for _, block := range systemBlocks {
+					if block.Type == "text" {
+						parts = append(parts, block.Text)
+					}
+				}
+				systemContent = strings.Join(parts, "\n")
+			} else {
+				log.Printf("WARN: Could not parse system prompt format for conversion: %s", string(claudeReq.System))
+				// Decide how to handle - skip system prompt or return error? Skipping for now.
+			}
+		}
+		if systemContent != "" {
+			openAIMessages = append(openAIMessages, OpenAIMessage{Role: "system", Content: systemContent})
+		}
+	}
+
+	// --- Handle Messages ---
+	for _, msg := range claudeReq.Messages {
+		if msg.Role != "user" && msg.Role != "assistant" {
+			log.Printf("WARN: Skipping message with unsupported role: %s", msg.Role)
+			continue
+		}
+
+		messageContent := ""
+		var contentStr string
+		// Try simple string first
+		if err := json.Unmarshal(msg.Content, &contentStr); err == nil {
+			messageContent = contentStr
+		} else {
+			// Try list of blocks
+			var contentBlocks []ClaudeContentBlock
+			if err := json.Unmarshal(msg.Content, &contentBlocks); err == nil {
+				var parts []string
+				for _, block := range contentBlocks {
+					if block.Type == "text" {
+						parts = append(parts, block.Text)
+					} else {
+						log.Printf("WARN: Skipping non-text content block type '%s' in message for role %s", block.Type, msg.Role)
+					}
+				}
+				messageContent = strings.Join(parts, "\n")
+			} else {
+				log.Printf("WARN: Could not parse message content format for role %s during conversion: %s", msg.Role, string(msg.Content))
+				// Skip message if content parsing fails
+				continue
+			}
+		}
+
+		if messageContent != "" || msg.Role == "assistant" { // Allow empty assistant messages if needed? Check OpenAI spec. Usually needs content.
+			openAIMessages = append(openAIMessages, OpenAIMessage{Role: msg.Role, Content: messageContent})
+		} else {
+			log.Printf("WARN: Skipping message for role %s with no valid text content after parsing.", msg.Role)
+		}
+	}
+
+	if len(openAIMessages) == 0 {
+		return nil, errors.New("conversion resulted in no valid messages for OpenAI request")
+	}
+
+	// --- Construct OpenAI Request ---
+	openAIReq := &OpenAIRequest{
+		Model:       claudeReq.Model, // Use the model specified in Claude request
+		Messages:    openAIMessages,
+		Stream:      claudeReq.Stream,
+		MaxTokens:   claudeReq.MaxTokens,
+		Temperature: claudeReq.Temperature,
+		TopP:        claudeReq.TopP,
+		// Stop sequences mapping
+		Stop: claudeReq.StopSequences,
+	}
+
+	// Default model if not provided
+	if openAIReq.Model == "" {
+		openAIReq.Model = "gpt-3.5-turbo" // Or get from config
+	}
+
+	return openAIReq, nil
+}
+
+// mapOpenAIFinishReasonToClaude maps OpenAI finish reason to Claude stop reason
+func mapOpenAIFinishReasonToClaude(openAIFinishReason *string) string {
+	if openAIFinishReason == nil {
+		return "end_turn" // Default if nil
+	}
+	reason := *openAIFinishReason
+	switch reason {
+	case "stop":
+		return "end_turn"
+	case "length":
+		return "max_tokens"
+	case "function_call", "tool_calls":
+		return "tool_use"
+	case "content_filter":
+		return "stop_sequence" // Or maybe map to an error type?
+	default:
+		log.Printf("WARN: Unknown OpenAI finish reason '%s', mapping to 'end_turn'", reason)
+		return "end_turn" // Default for unknown reasons
+	}
+}
+
+// convertOpenAIResponseToClaude converts non-streaming OpenAI response to Claude format
+func convertOpenAIResponseToClaude(openAIResp *OpenAIResponse, claudeRequestID string) (*ClaudeResponse, error) {
+	if len(openAIResp.Choices) == 0 {
+		return nil, errors.New("OpenAI response has no choices")
+	}
+
+	choice := openAIResp.Choices[0]
+	claudeStopReason := mapOpenAIFinishReasonToClaude(choice.FinishReason)
+
+	// --- Prepare Usage ---
+	claudeUsage := ClaudeUsage{}
+	if openAIResp.Usage != nil {
+		claudeUsage.InputTokens = openAIResp.Usage.PromptTokens
+		claudeUsage.OutputTokens = openAIResp.Usage.CompletionTokens
+	} else {
+		log.Printf("WARN: [%s] Usage data missing in non-streaming OpenAI response", claudeRequestID)
+		// Potentially estimate usage here if critical, otherwise leave as zero
+	}
+
+	// --- Prepare Content ---
+	claudeContent := []ClaudeContentBlock{
+		{
+			Type: "text",
+			Text: choice.Message.Content, // Assuming message content is always text
+		},
+	}
+
+	// --- Construct Claude Response ---
+	claudeResp := &ClaudeResponse{
+		ID:           openAIResp.ID, // Use OpenAI's response ID
+		Type:         "message",
+		Role:         "assistant", // Assuming OpenAI response role is assistant
+		Content:      claudeContent,
+		Model:        openAIResp.Model, // Use the model OpenAI reported
+		StopReason:   claudeStopReason,
+		StopSequence: nil, // Typically null
+		Usage:        claudeUsage,
+	}
+
+	// Use original request ID if OpenAI ID is missing (shouldn't happen often)
+	if claudeResp.ID == "" {
+		log.Printf("WARN: OpenAI response ID missing, using original request ID: %s", claudeRequestID)
+		claudeResp.ID = claudeRequestID
+	}
+
+	return claudeResp, nil
+}

go.mod

@@ -0,0 +1,39 @@
+    module claude-proxy-go // Bạn có thể thay đổi "claude-proxy-go" thành tên module mong muốn
+
+    go 1.21 // Hoặc phiên bản Go bạn muốn sử dụng (phù hợp với Dockerfile)
+
+    require (
+    	github.com/gin-contrib/cors v1.7.2
+    	github.com/gin-gonic/gin v1.10.0
+    	github.com/google/uuid v1.6.0
+    	github.com/joho/godotenv v1.5.1 // Optional: for local .env loading
+    )
+
+    require (
+    	github.com/bytedance/sonic v1.11.6 // indirect
+    	github.com/bytedance/sonic/loader v0.1.1 // indirect
+    	github.com/cloudwego/base64x v0.1.4 // indirect
+    	github.com/cloudwego/iasm v0.2.0 // indirect
+    	github.com/gabriel-vasile/mimetype v1.4.3 // indirect
+    	github.com/gin-contrib/sse v0.1.0 // indirect
+    	github.com/go-playground/locales v0.14.1 // indirect
+    	github.com/go-playground/universal-translator v0.18.1 // indirect
+    	github.com/go-playground/validator/v10 v10.20.0 // indirect
+    	github.com/goccy/go-json v0.10.2 // indirect
+    	github.com/json-iterator/go v1.1.12 // indirect
+    	github.com/klauspost/cpuid/v2 v2.2.7 // indirect
+    	github.com/leodido/go-urn v1.4.0 // indirect
+    	github.com/mattn/go-isatty v0.0.20 // indirect
+    	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
+    	github.com/modern-go/reflect2 v1.0.2 // indirect
+    	github.com/pelletier/go-toml/v2 v2.2.2 // indirect
+    	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
+    	github.com/ugorji/go/codec v1.2.12 // indirect
+    	golang.org/x/arch v0.8.0 // indirect
+    	golang.org/x/crypto v0.23.0 // indirect
+    	golang.org/x/net v0.25.0 // indirect
+    	golang.org/x/sys v0.20.0 // indirect
+    	golang.org/x/text v0.15.0 // indirect
+    	google.golang.org/protobuf v1.34.1 // indirect
+    	gopkg.in/yaml.v3 v3.0.1 // indirect
+    )

handlers.go

@@ -0,0 +1,218 @@
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"net" // <<< Added import
+	"net/http"
+	"strings" // <<< Added import
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/google/uuid"
+)
+
+// HealthCheckHandler handles the /health endpoint
+func HealthCheckHandler(c *gin.Context) {
+	c.JSON(http.StatusOK, gin.H{"status": "healthy"})
+}
+
+// MessagesHandler handles the /v1/messages endpoint
+func MessagesHandler(c *gin.Context) {
+	requestID := fmt.Sprintf("msg_%s", uuid.NewString()[:24]) // Generate unique request ID
+	cfg := LoadConfig() // Load config (consider passing it down instead of reloading)
+
+	// --- 1. Read and Parse Incoming Request ---
+	var claudeReq ClaudeRequest
+	bodyBytes, err := io.ReadAll(c.Request.Body)
+	if err != nil {
+		log.Printf("ERROR: [%s] Failed to read request body: %v", requestID, err)
+		sendClaudeError(c, http.StatusBadRequest, "invalid_request_error", "Could not read request body.")
+		return
+	}
+	// Restore body for potential re-reads (though we don't re-read here)
+	c.Request.Body = io.NopCloser(bytes.NewBuffer(bodyBytes))
+
+	if err := json.Unmarshal(bodyBytes, &claudeReq); err != nil {
+		log.Printf("ERROR: [%s] Failed to decode request JSON: %v. Body: %s", requestID, err, string(bodyBytes))
+		sendClaudeError(c, http.StatusBadRequest, "invalid_request_error", "Invalid JSON format in request body.")
+		return
+	}
+
+	isStreaming := claudeReq.Stream
+	modelRequested := claudeReq.Model
+	if modelRequested == "" {
+		modelRequested = "unknown_model"
+	} // Handle empty model case
+	log.Printf("INFO: [%s] Received request. Stream: %t. Model: %s", requestID, isStreaming, modelRequested)
+	// Optional: Log full payload at debug level
+	// log.Printf("DEBUG: [%s] Received Payload: %s", requestID, string(bodyBytes))
+
+	// --- 2. Convert Request Format ---
+	openAIReq, err := convertClaudeRequestToOpenAI(&claudeReq)
+	if err != nil {
+		log.Printf("ERROR: [%s] Failed to convert Claude request to OpenAI format: %v", requestID, err)
+		sendClaudeError(c, http.StatusBadRequest, "invalid_request_error", fmt.Sprintf("Error converting request data: %v", err))
+		return
+	}
+	// Ensure stream flag is correctly set in the converted request
+	openAIReq.Stream = isStreaming
+
+	// --- 3. Prepare and Send Upstream Request ---
+	// Marshal the OpenAI request body
+	openaiReqBytes, err := json.Marshal(openAIReq)
+	if err != nil {
+		log.Printf("ERROR: [%s] Failed to marshal OpenAI request JSON: %v", requestID, err)
+		sendClaudeError(c, http.StatusInternalServerError, "internal_server_error", "Failed to prepare upstream request.")
+		return
+	}
+
+	// Create the HTTP request to the upstream endpoint
+	upstreamURL := cfg.OpenAIAPIEndpoint
+	req, err := http.NewRequestWithContext(c.Request.Context(), "POST", upstreamURL, bytes.NewBuffer(openaiReqBytes))
+	if err != nil {
+		log.Printf("ERROR: [%s] Failed to create upstream HTTP request: %v", requestID, err)
+		sendClaudeError(c, http.StatusInternalServerError, "internal_server_error", "Failed to create upstream request.")
+		return
+	}
+
+	// Set headers for upstream request
+	req.Header.Set("Content-Type", "application/json")
+	if isStreaming {
+		req.Header.Set("Accept", "text/event-stream")
+	} else {
+		req.Header.Set("Accept", "application/json")
+	}
+	if cfg.OpenAIAPIKey != "" {
+		req.Header.Set("Authorization", "Bearer "+cfg.OpenAIAPIKey)
+	}
+	// Copy potentially relevant headers from original request? (e.g., User-Agent) - Be cautious about security.
+	// req.Header.Set("User-Agent", c.GetHeader("User-Agent"))
+
+	// Log upstream request details (optional, redact sensitive info)
+	// log.Printf("DEBUG: [%s] Sending upstream request to %s. Headers: %v", requestID, upstreamURL, req.Header)
+	// log.Printf("DEBUG: [%s] Upstream Payload: %s", requestID, string(openaiReqBytes))
+	log.Printf("INFO: [%s] Sending upstream request (Stream=%t) to %s...", requestID, isStreaming, upstreamURL)
+
+	// --- Execute Upstream Request ---
+	// Use a client with the configured transport (timeouts, proxy)
+	httpClient := &http.Client{
+		Transport: cfg.UpstreamTransport,
+		Timeout:   0, // Timeout is handled by the transport's ResponseHeaderTimeout and DialContext Timeout
+	}
+	startTime := time.Now()
+	upstreamResp, err := httpClient.Do(req)
+	if err != nil {
+		// Handle client-side errors (network, DNS, timeout before connection, etc.)
+		log.Printf("ERROR: [%s] Upstream request failed: %v", requestID, err)
+		// Check for timeout specifically
+		if netErr, ok := err.(net.Error); ok && netErr.Timeout() { // <<< Used net.Error here
+			sendClaudeError(c, http.StatusGatewayTimeout, "api_error", fmt.Sprintf("Gateway Timeout connecting to upstream (%v).", cfg.ConnectTimeout))
+		} else {
+			sendClaudeError(c, http.StatusBadGateway, "api_error", fmt.Sprintf("Bad Gateway: Could not connect to upstream. Error: %v", err))
+		}
+		return
+	}
+	// Note: We don't close upstreamResp.Body here yet, it's needed for streaming or reading non-streaming body.
+	// It will be closed by the streaming handler or after reading the body in non-streaming case.
+	log.Printf("INFO: [%s] Received upstream status: %d (%s)", requestID, upstreamResp.StatusCode, http.StatusText(upstreamResp.StatusCode))
+
+	// --- 4. Process Upstream Response ---
+
+	// Handle non-OK status codes
+	if upstreamResp.StatusCode != http.StatusOK {
+		// Read error body from upstream
+		errorBodyBytes, readErr := io.ReadAll(upstreamResp.Body)
+		if readErr != nil {
+			log.Printf("WARN: [%s] Failed to read upstream error body (Status %d): %v", requestID, upstreamResp.StatusCode, readErr)
+		}
+		_ = upstreamResp.Body.Close() // Ensure body is closed after reading or error
+
+		errorBodyStr := string(errorBodyBytes)
+		log.Printf("ERROR: [%s] Upstream returned error status %d. Body: %s", requestID, upstreamResp.StatusCode, errorBodyStr)
+
+		// Try to map the error to Claude format
+		// Basic mapping, can be improved by parsing OpenAI error structure if available
+		var errorType string
+		switch upstreamResp.StatusCode {
+		case http.StatusBadRequest:
+			errorType = "invalid_request_error"
+		case http.StatusUnauthorized:
+			errorType = "authentication_error"
+		case http.StatusForbidden:
+			errorType = "permission_error"
+		case http.StatusTooManyRequests:
+			errorType = "rate_limit_error"
+		case http.StatusInternalServerError, http.StatusBadGateway, http.StatusServiceUnavailable, http.StatusGatewayTimeout:
+			errorType = "api_error"
+		default:
+			errorType = "api_error" // Default for other errors
+		}
+		errMsg := fmt.Sprintf("Upstream API error (%d). Details: %s", upstreamResp.StatusCode, strings.TrimSpace(errorBodyStr)) // <<< Used strings.TrimSpace here
+		// Truncate long error messages if necessary
+		if len(errMsg) > 300 {
+			errMsg = errMsg[:300] + "..."
+		}
+		sendClaudeError(c, upstreamResp.StatusCode, errorType, errMsg)
+		return
+	}
+
+	// --- Handle OK response based on streaming ---
+	if isStreaming {
+		log.Printf("INFO: [%s] Upstream stream received. Starting SSE conversion (Go v1.9.0 - Priority Delta).", requestID)
+		// Delegate to the SSE streaming function
+		// This function will handle reading upstreamResp.Body and closing it
+		streamOpenAIResponseToClaudeSSE(c, upstreamResp, requestID, openAIReq.Model, &claudeReq)
+	} else {
+		// --- Non-Streaming ---
+		log.Printf("INFO: [%s] Upstream non-stream response received. Converting.", requestID)
+		defer upstreamResp.Body.Close() // Ensure body is closed after reading
+
+		// Read and parse upstream JSON response
+		var openAIResp OpenAIResponse
+		bodyBytes, err := io.ReadAll(upstreamResp.Body)
+		if err != nil {
+			log.Printf("ERROR: [%s] Failed to read non-streaming upstream response body: %v", requestID, err)
+			sendClaudeError(c, http.StatusBadGateway, "api_error", "Failed to read upstream response.")
+			return
+		}
+		if err := json.Unmarshal(bodyBytes, &openAIResp); err != nil {
+			log.Printf("ERROR: [%s] Failed to decode non-streaming upstream JSON: %v. Body: %s", requestID, err, string(bodyBytes))
+			sendClaudeError(c, http.StatusBadGateway, "api_error", "Upstream API returned invalid JSON.")
+			return
+		}
+
+		// Convert OpenAI response to Claude format
+		claudeResp, err := convertOpenAIResponseToClaude(&openAIResp, requestID)
+		if err != nil {
+			log.Printf("ERROR: [%s] Failed to convert non-streaming OpenAI response: %v", requestID, err)
+			sendClaudeError(c, http.StatusInternalServerError, "internal_server_error", fmt.Sprintf("Error processing upstream response: %v", err))
+			return
+		}
+
+		// Send the converted Claude response
+		c.JSON(http.StatusOK, claudeResp)
+		log.Printf("INFO: [%s] Successfully processed non-streaming request in %v", requestID, time.Since(startTime))
+	}
+}
+
+// sendClaudeError is a helper to send standardized Claude error responses
+func sendClaudeError(c *gin.Context, statusCode int, errorType string, message string) {
+	errResp := ClaudeErrorResponse{
+		Type: "error",
+		Error: ClaudeError{
+			Type:    errorType,
+			Message: message,
+		},
+	}
+	// Ensure status code is in valid range, default to 500 if not
+	if statusCode < 400 || statusCode > 599 {
+		log.Printf("WARN: Invalid status code %d provided for error, defaulting to 500.", statusCode)
+		statusCode = http.StatusInternalServerError
+	}
+	c.AbortWithStatusJSON(statusCode, errResp)
+}
+

main.go

@@ -0,0 +1,103 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+
+	"github.com/gin-contrib/cors"
+	"github.com/gin-gonic/gin"
+	"github.com/joho/godotenv" // Optional: for loading .env file
+)
+
+func main() {
+	// Load .env file if present (optional, good for local dev)
+	_ = godotenv.Load()
+
+	// Load configuration
+	cfg := LoadConfig()
+
+	// Set Gin mode (release or debug)
+	if cfg.GinMode == "release" {
+		gin.SetMode(gin.ReleaseMode)
+	} else {
+		gin.SetMode(gin.DebugMode)
+	}
+	log.Printf("Starting Go Proxy Server in %s mode...", gin.Mode())
+
+	// Initialize Gin router
+	router := gin.New()
+
+	// Middleware
+	router.Use(gin.Logger()) // Standard Gin logger
+	router.Use(gin.Recovery()) // Recover from panics
+	// CORS middleware (allow all for simplicity, adjust as needed)
+	router.Use(cors.New(cors.Config{
+		AllowOrigins:     []string{"*"},
+		AllowMethods:     []string{"GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"},
+		AllowHeaders:     []string{"Origin", "Content-Length", "Content-Type", "Authorization", "X-API-Key"}, // Include X-API-Key
+		ExposeHeaders:    []string{"Content-Length"},
+		AllowCredentials: true,
+		MaxAge:           12 * time.Hour,
+	}))
+
+	// --- Routes ---
+	// Health check
+	router.GET("/health", HealthCheckHandler)
+
+	// Main proxy endpoint group
+	v1 := router.Group("/v1")
+	{
+		// Apply API Key Authentication middleware if keys are configured
+		if len(cfg.ValidAPIKeys) > 0 {
+			log.Printf("API Key authentication enabled (%d keys configured).", len(cfg.ValidAPIKeys))
+			v1.Use(APIKeyAuthMiddleware(cfg.ValidAPIKeys))
+		} else {
+			log.Println("WARN: No PROXY_API_KEYS configured. Proxy is open (no authentication).")
+		}
+		v1.POST("/messages", MessagesHandler)
+	}
+
+	// --- Server Setup ---
+	server := &http.Server{
+		Addr:    fmt.Sprintf(":%s", cfg.Port),
+		Handler: router,
+		// Add timeouts for production hardening
+		ReadTimeout:  10 * time.Second,
+		WriteTimeout: cfg.ReadTimeout + 30*time.Second, // Ensure write timeout is longer than read timeout for streaming
+		IdleTimeout:  120 * time.Second,
+	}
+
+	// --- Graceful Shutdown ---
+	// Run server in a goroutine so it doesn't block
+	go func() {
+		log.Printf("Server listening on port %s", cfg.Port)
+		if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+			log.Fatalf("listen: %s\n", err)
+		}
+	}()
+
+	// Wait for interrupt signal to gracefully shut down the server
+	quit := make(chan os.Signal, 1)
+	// kill (no param) default send syscall.SIGTERM
+	// kill -2 is syscall.SIGINT
+	// kill -9 is syscall.SIGKILL but can't be caught, so don't need to add it
+	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
+	<-quit
+	log.Println("Shutting down server...")
+
+	// The context is used to inform the server it has 5 seconds to finish
+	// the requests it is currently handling
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	if err := server.Shutdown(ctx); err != nil {
+		log.Fatal("Server forced to shutdown:", err)
+	}
+
+	log.Println("Server exiting")
+}

sse.go

@@ -0,0 +1,320 @@
+package main
+
+import (
+	"bufio"
+	"encoding/json"
+	"fmt"
+	"log"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/gin-gonic/gin"
+)
+
+// streamOpenAIResponseToClaudeSSE handles the SSE streaming conversion
+// v1.10.0: Sends message_delta with accumulated usage after each content delta.
+func streamOpenAIResponseToClaudeSSE(
+	c *gin.Context,
+	upstreamResp *http.Response,
+	claudeRequestID string,
+	requestedModel string,
+	originalClaudeRequest *ClaudeRequest, // Pass original request for token calculation
+) {
+	// Ensure correct headers for SSE are set
+	c.Writer.Header().Set("Content-Type", "text/event-stream")
+	c.Writer.Header().Set("Cache-Control", "no-cache")
+	c.Writer.Header().Set("Connection", "keep-alive")
+	c.Writer.Header().Set("X-Content-Type-Options", "nosniff")
+	c.Writer.Flush() // Ensure headers are sent immediately
+
+	// --- State Variables ---
+	messageID := claudeRequestID
+	accumulatedContent := ""
+	var openAIFinishReason *string // Store the pointer
+	streamErrorOccurred := false
+	var errorDetails *ClaudeError // Store potential error details for final event
+
+	// Pre-calculate input tokens
+	calculatedInputTokens := calculateInputTokensFromClaudeRequest(originalClaudeRequest)
+	log.Printf("INFO: [%s] SSE AggressiveDelta: Calculated input tokens: %d", messageID, calculatedInputTokens)
+	inputTokens := calculatedInputTokens
+	outputTokens := 0 // Initialize output tokens (will be updated frequently)
+	finalUsageReceivedFromStream := false
+	lastPingTime := time.Now()
+	eventIndex := 0 // For logging clarity
+
+	log.Printf("DEBUG: [%s] Starting SSE AggressiveDelta conversion (Go v1.10.0).", messageID)
+
+	// Use a channel to signal completion or error from the reading goroutine
+	doneChan := make(chan struct{})
+	errChan := make(chan error, 1) // Buffered channel for error
+
+	// Goroutine to read from the upstream response
+	go func() {
+		defer close(doneChan) // Signal completion when done
+		defer upstreamResp.Body.Close() // Ensure body is closed
+
+		scanner := bufio.NewScanner(upstreamResp.Body)
+		for scanner.Scan() {
+			// Check for client disconnect *before* processing line
+			select {
+			case <-c.Request.Context().Done():
+				log.Printf("INFO: [%s] SSE AggressiveDelta: Client disconnected detected in read loop.", messageID)
+				return // Exit goroutine if client disconnected
+			default:
+				// Continue processing
+			}
+
+			line := scanner.Text()
+			if line == "" {
+				continue // Skip empty lines
+			}
+
+			if strings.HasPrefix(line, "data:") {
+				dataStr := strings.TrimSpace(strings.TrimPrefix(line, "data:"))
+				if dataStr == "[DONE]" {
+					log.Printf("DEBUG: [%s] SSE AggressiveDelta: Received [DONE] marker.", messageID)
+					return // Normal stream completion
+				}
+
+				var chunk OpenAIStreamChunk
+				if err := json.Unmarshal([]byte(dataStr), &chunk); err != nil {
+					log.Printf("WARN: [%s] SSE AggressiveDelta: Could not decode JSON chunk: %v. Data: %s", messageID, err, dataStr)
+					continue // Skip malformed chunks
+				}
+
+				// Process choices
+				if len(chunk.Choices) > 0 {
+					choice := chunk.Choices[0]
+					if choice.FinishReason != nil {
+						openAIFinishReason = choice.FinishReason // Store the pointer
+						log.Printf("DEBUG: [%s] SSE AggressiveDelta: Received OpenAI finish_reason: %s", messageID, *openAIFinishReason)
+					}
+					if choice.Delta.Content != nil {
+						contentChunk := *choice.Delta.Content
+						accumulatedContent += contentChunk
+						currentOutputTokens := estimateTokens(accumulatedContent) // Estimate based on current content
+
+						// --- Yield content_block_delta ---
+						deltaPayload := ClaudeSSEEvent{
+							Type:  "content_block_delta",
+							Index: func() *int { i := 0; return &i }(), // Pointer to 0
+							Delta: &ClaudeSSEDelta{
+								Type: "text_delta",
+								Text: &contentChunk, // Pointer to the chunk
+							},
+						}
+						if !sendSSEEvent(c, "content_block_delta", deltaPayload, messageID, eventIndex) {
+							return // Stop if client disconnected
+						}
+						eventIndex++
+
+						// --- AGGRESSIVE DELTA: Yield message_delta with current usage ---
+						// Only send if output tokens have potentially changed
+						if currentOutputTokens != outputTokens {
+							outputTokens = currentOutputTokens // Update state
+							intermediateUsage := ClaudeSSEUsage{OutputTokens: outputTokens}
+							intermediateDeltaPayload := ClaudeSSEEvent{
+								Type:  "message_delta",
+								Delta: &ClaudeSSEDelta{}, // Delta part is empty here, only usage matters
+								Usage: &intermediateUsage,
+							}
+							log.Printf("TRACE: [%s] SSE AggressiveDelta: Yielding Event %d (INTERMEDIATE message_delta with usage): %+v", messageID, eventIndex, intermediateDeltaPayload)
+							if !sendSSEEvent(c, "message_delta", intermediateDeltaPayload, messageID, eventIndex) {
+								return // Stop if client disconnected
+							}
+							eventIndex++
+						}
+						// -----------------------------------------------------------------
+					}
+				}
+
+				// Check for OpenAI usage block (still useful for final confirmation)
+				if chunk.Usage != nil {
+					log.Printf("INFO: [%s] SSE AggressiveDelta: Received usage block in OpenAI stream: %+v", messageID, *chunk.Usage)
+					if chunk.Usage.CompletionTokens > 0 {
+						// If OpenAI provides a final count, trust it more than estimation
+						outputTokens = chunk.Usage.CompletionTokens
+						finalUsageReceivedFromStream = true
+						log.Printf("INFO: [%s] SSE AggressiveDelta: Using final completion_tokens from stream: %d", messageID, outputTokens)
+					}
+					if chunk.Usage.PromptTokens != inputTokens && chunk.Usage.PromptTokens > 0 {
+						log.Printf("INFO: [%s] SSE AggressiveDelta: Updating input tokens based on stream usage block: %d -> %d", messageID, inputTokens, chunk.Usage.PromptTokens)
+						inputTokens = chunk.Usage.PromptTokens
+					}
+				}
+			} else {
+				log.Printf("TRACE: [%s] SSE AggressiveDelta: Received non-data line: %s", messageID, line)
+			}
+
+			// Send periodic pings
+			if time.Since(lastPingTime) >= 10*time.Second {
+				pingPayload := ClaudeSSEEvent{Type: "ping"}
+				if !sendSSEEvent(c, "ping", pingPayload, messageID, eventIndex) {
+					return // Stop if client disconnected
+				}
+				eventIndex++
+				lastPingTime = time.Now()
+			}
+		}
+
+		if err := scanner.Err(); err != nil {
+			// Check if the error is due to context cancellation (client disconnect)
+			select {
+			case <-c.Request.Context().Done():
+				log.Printf("INFO: [%s] SSE AggressiveDelta: Upstream read interrupted by client disconnect: %v", messageID, c.Request.Context().Err())
+			default:
+				log.Printf("ERROR: [%s] SSE AggressiveDelta: Error reading upstream response body: %v", messageID, err)
+				errChan <- fmt.Errorf("upstream read error: %w", err)
+			}
+		}
+	}()
+
+	// --- Initial Events ---
+	// Send message_start
+	startUsage := ClaudeUsage{InputTokens: calculatedInputTokens, OutputTokens: 0}
+	startMessage := ClaudeSSEMessage{ ID: messageID, Type: "message", Role: "assistant", Content: []ClaudeContentBlock{}, Model: requestedModel, StopReason: nil, StopSequence: nil, Usage: startUsage }
+	startEvent := ClaudeSSEEvent{Type: "message_start", Message: &startMessage}
+	if !sendSSEEvent(c, "message_start", startEvent, messageID, eventIndex) { return }
+	eventIndex++
+
+	// Send content_block_start
+	contentStartBlock := ClaudeSSEContentBlock{Type: "text", Text: ""}
+	contentStartEvent := ClaudeSSEEvent{ Type: "content_block_start", Index: func() *int { i := 0; return &i }(), ContentBlock: &contentStartBlock }
+	if !sendSSEEvent(c, "content_block_start", contentStartEvent, messageID, eventIndex) { return }
+	eventIndex++
+
+	// Send initial ping
+	pingPayload := ClaudeSSEEvent{Type: "ping"}
+	if !sendSSEEvent(c, "ping", pingPayload, messageID, eventIndex) { return }
+	eventIndex++
+	lastPingTime = time.Now()
+
+	// --- Wait for completion or error or client disconnect ---
+	select {
+	case <-doneChan:
+		log.Printf("DEBUG: [%s] SSE AggressiveDelta: Upstream reading finished.", messageID)
+	case err := <-errChan:
+		log.Printf("ERROR: [%s] SSE AggressiveDelta: Received error from reading goroutine: %v", messageID, err)
+		streamErrorOccurred = true
+		errorDetails = &ClaudeError{Type: "api_error", Message: fmt.Sprintf("Error reading upstream response: %v", err)}
+	case <-c.Request.Context().Done():
+		log.Printf("INFO: [%s] SSE AggressiveDelta: Client disconnected during stream processing: %v", messageID, c.Request.Context().Err())
+		streamErrorOccurred = true // Treat disconnect as a type of error for cleanup
+		errorDetails = &ClaudeError{Type: "client_disconnect", Message: "Client disconnected during stream"}
+	}
+
+	// --- Finally Block Logic ---
+	log.Printf("DEBUG: [%s] SSE AggressiveDelta: Entering finally block logic. Finish_reason: %v, Error: %t", messageID, openAIFinishReason, streamErrorOccurred)
+
+	// Determine final Claude stop reason
+	var claudeStopReason string
+	if streamErrorOccurred && errorDetails != nil && errorDetails.Type == "client_disconnect" {
+		claudeStopReason = "client_disconnect"
+	} else if streamErrorOccurred {
+		claudeStopReason = "error"
+	} else {
+		claudeStopReason = mapOpenAIFinishReasonToClaude(openAIFinishReason)
+	}
+
+	// Finalize token counts (use last known value, potentially from stream or final estimation)
+	finalInputTokens := inputTokens
+	finalOutputTokens := outputTokens // Use the value updated during the stream or from OpenAI's usage block
+
+	// If no explicit usage received, do a final estimation/forcing
+	if !finalUsageReceivedFromStream {
+		log.Printf("WARN: [%s] SSE AggressiveDelta: Final usage not explicitly received. Doing final estimate.", messageID)
+		estimatedOutput := estimateTokens(accumulatedContent)
+		finalOutputTokens = max(1, estimatedOutput)
+		if accumulatedContent == "" { finalOutputTokens = 0 }
+		log.Printf("WARN: [%s] SSE AggressiveDelta: Final Estimated/Forced output tokens: %d", messageID, finalOutputTokens)
+	} else {
+        // If usage *was* received, still force minimum 1 if non-zero
+		finalOutputTokens = max(1, outputTokens)
+		if outputTokens == 0 { finalOutputTokens = 0 }
+		log.Printf("INFO: [%s] SSE AggressiveDelta: Using/Forced final usage from stream: output=%d", messageID, finalOutputTokens)
+	}
+	finalInputTokens = max(0, finalInputTokens)
+	finalOutputTokens = max(0, finalOutputTokens)
+
+	// Prepare usage data structures
+	// The *last* message_delta sent needs the final output tokens for chat-api billing hack
+	finalHackUsageData := ClaudeSSEUsage{OutputTokens: finalOutputTokens}
+	finalStopUsageData := ClaudeSSEUsage{ InputTokens: &finalInputTokens, OutputTokens: finalOutputTokens }
+
+	log.Printf("INFO: [%s] SSE AggressiveDelta: Stream finished. Stop Reason: %s. Final Usage: Input=%d Output=%d", messageID, claudeStopReason, finalInputTokens, finalOutputTokens)
+
+	// --- Yield Closing Events (Priority Final Delta First) ---
+
+	// *** Send FINAL message_delta WITH FINAL usage FIRST ***
+	// This ensures the most accurate count is sent last, potentially overwriting intermediate ones in chat-api
+	finalDeltaStopReason := claudeStopReason
+	priorityFinalDeltaPayload := ClaudeSSEEvent{
+		Type: "message_delta",
+		Delta: &ClaudeSSEDelta{
+			StopReason:   &finalDeltaStopReason,
+			StopSequence: nil,
+		},
+		Usage: &finalHackUsageData, // Use the final calculated/forced output tokens
+	}
+	log.Printf("WARN: [%s] SSE AggressiveDelta: Yielding Event %d (PRIORITY FINAL message_delta WITH HACKED USAGE): %+v", messageID, eventIndex, priorityFinalDeltaPayload)
+	_ = sendSSEEvent(c, "message_delta", priorityFinalDeltaPayload, messageID, eventIndex) // Try to send even if disconnected
+	eventIndex++
+
+	// Send content_block_stop
+	contentStopPayload := ClaudeSSEEvent{ Type: "content_block_stop", Index: func() *int { i := 0; return &i }()}
+	log.Printf("TRACE: [%s] SSE AggressiveDelta: Yielding Event %d (content_block_stop)", messageID, eventIndex)
+	_ = sendSSEEvent(c, "content_block_stop", contentStopPayload, messageID, eventIndex)
+	eventIndex++
+
+	// Send message_stop
+	messageStopPayload := ClaudeSSEEvent{ Type: "message_stop", Usage: &finalStopUsageData }
+	log.Printf("TRACE: [%s] SSE AggressiveDelta: Yielding Event %d (message_stop)", messageID, eventIndex)
+	_ = sendSSEEvent(c, "message_stop", messageStopPayload, messageID, eventIndex)
+	eventIndex++
+
+	// Send error event if needed
+	if streamErrorOccurred && errorDetails != nil && errorDetails.Type != "client_disconnect" {
+		errorPayload := ClaudeSSEEvent{ Type: "error", Error: errorDetails }
+		log.Printf("TRACE: [%s] SSE AggressiveDelta: Yielding Event %d (error)", messageID, eventIndex)
+		_ = sendSSEEvent(c, "error", errorPayload, messageID, eventIndex)
+		eventIndex++
+	}
+
+	log.Printf("INFO: [%s] Completed sending SSE AggressiveDelta stream.", messageID)
+}
+
+// sendSSEEvent sends a single SSE event and checks for client disconnect
+func sendSSEEvent(c *gin.Context, eventName string, data interface{}, requestID string, eventIndex int) bool {
+	select {
+	case <-c.Request.Context().Done():
+		// Client disconnected
+		log.Printf("INFO: [%s] Client disconnected before sending SSE event %d (%s).", requestID, eventIndex, eventName)
+		return false
+	default:
+		// Client still connected, try sending
+		jsonData, err := json.Marshal(data)
+		if err != nil {
+			log.Printf("ERROR: [%s] Failed to marshal SSE event %d (%s): %v", requestID, eventIndex, eventName, err)
+			return true // Continue trying other events even if one fails marshaling?
+		}
+		// Use fmt.Fprintf for potentially better handling with Gin's writer interface
+		_, err = fmt.Fprintf(c.Writer, "event: %s\ndata: %s\n\n", eventName, string(jsonData))
+		if err != nil {
+			// This error often indicates the client disconnected during the write
+			log.Printf("WARN: [%s] Failed to write SSE event %d (%s) to client: %v. Client likely disconnected.", requestID, eventIndex, eventName, err)
+			return false // Stop processing if write fails
+		}
+		c.Writer.Flush() // Ensure data is sent immediately
+		return true
+	}
+}
+
+// Helper for max function
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}

structs.go

@@ -0,0 +1,183 @@
+package main
+
+import "encoding/json"
+
+// --- Claude API Structs (Anthropic Format) ---
+
+// ClaudeRequest represents the incoming request structure from the client
+type ClaudeRequest struct {
+	Model         string             `json:"model"`
+	Messages      []ClaudeMessage    `json:"messages"`
+	System        json.RawMessage    `json:"system,omitempty"` // Can be string or list of blocks
+	MaxTokens     *int               `json:"max_tokens,omitempty"` // Use pointer for optional fields
+	StopSequences []string           `json:"stop_sequences,omitempty"`
+	Stream        bool               `json:"stream,omitempty"`
+	Temperature   *float64           `json:"temperature,omitempty"`
+	TopP          *float64           `json:"top_p,omitempty"`
+	// TopK          *int               `json:"top_k,omitempty"` // OpenAI doesn't support TopK directly
+}
+
+// ClaudeMessage represents a message in the Claude request
+type ClaudeMessage struct {
+	Role    string            `json:"role"` // "user" or "assistant"
+	Content json.RawMessage   `json:"content"` // Can be string or list of blocks
+}
+
+// ClaudeContentBlock represents a block within the content array
+type ClaudeContentBlock struct {
+	Type string `json:"type"`
+	Text string `json:"text,omitempty"`
+	// Add other block types if needed (e.g., image)
+}
+
+// ClaudeResponse represents the non-streaming response structure sent to the client
+type ClaudeResponse struct {
+	ID           string               `json:"id"`
+	Type         string               `json:"type"` // e.g., "message"
+	Role         string               `json:"role"` // e.g., "assistant"
+	Content      []ClaudeContentBlock `json:"content"`
+	Model        string               `json:"model"`
+	StopReason   string               `json:"stop_reason"` // e.g., "end_turn", "max_tokens"
+	StopSequence *string              `json:"stop_sequence"` // Usually null
+	Usage        ClaudeUsage          `json:"usage"`
+}
+
+// ClaudeUsage represents the token usage information
+type ClaudeUsage struct {
+	InputTokens  int `json:"input_tokens"`
+	OutputTokens int `json:"output_tokens"`
+}
+
+// ClaudeErrorResponse represents the error structure sent to the client
+type ClaudeErrorResponse struct {
+	Type  string        `json:"type"` // Always "error"
+	Error ClaudeError `json:"error"`
+}
+
+// ClaudeError represents the detailed error information
+type ClaudeError struct {
+	Type    string `json:"type"`    // e.g., "invalid_request_error", "api_error"
+	Message string `json:"message"`
+}
+
+
+// --- OpenAI API Structs ---
+
+// OpenAIRequest represents the request structure sent to the upstream OpenAI API
+type OpenAIRequest struct {
+	Model       string          `json:"model"`
+	Messages    []OpenAIMessage `json:"messages"`
+	MaxTokens   *int            `json:"max_tokens,omitempty"`
+	Temperature *float64        `json:"temperature,omitempty"`
+	TopP        *float64        `json:"top_p,omitempty"`
+	Stop        []string        `json:"stop,omitempty"`
+	Stream      bool            `json:"stream,omitempty"`
+	// N           *int            `json:"n,omitempty"` // Not typically used with Claude proxy
+	// PresencePenalty *float64 `json:"presence_penalty,omitempty"` // Not mapped
+	// FrequencyPenalty *float64 `json:"frequency_penalty,omitempty"` // Not mapped
+}
+
+// OpenAIMessage represents a message in the OpenAI request
+type OpenAIMessage struct {
+	Role    string `json:"role"` // "system", "user", or "assistant"
+	Content string `json:"content"`
+}
+
+// OpenAIResponse represents the non-streaming response from the upstream OpenAI API
+type OpenAIResponse struct {
+	ID      string             `json:"id"`
+	Object  string             `json:"object"` // e.g., "chat.completion"
+	Created int64              `json:"created"`
+	Model   string             `json:"model"`
+	Choices []OpenAIChoice     `json:"choices"`
+	Usage   *OpenAIUsage       `json:"usage,omitempty"` // Pointer as it might be missing in errors
+	// SystemFingerprint string `json:"system_fingerprint"` // Optional
+}
+
+// OpenAIChoice represents a choice in the OpenAI response
+type OpenAIChoice struct {
+	Index        int             `json:"index"`
+	Message      OpenAIMessage   `json:"message"`
+	FinishReason *string         `json:"finish_reason"` // Pointer as it can be null
+	// Logprobs     interface{}     `json:"logprobs"` // Not typically used here
+}
+
+// OpenAIUsage represents the token usage information from OpenAI
+type OpenAIUsage struct {
+	PromptTokens     int `json:"prompt_tokens"`
+	CompletionTokens int `json:"completion_tokens"`
+	TotalTokens      int `json:"total_tokens"`
+}
+
+// OpenAIStreamChoice represents a choice within an OpenAI SSE chunk
+type OpenAIStreamChoice struct {
+	Index        int                  `json:"index"`
+	Delta        OpenAIStreamDelta    `json:"delta"`
+	FinishReason *string              `json:"finish_reason"` // Pointer as it can be null
+	// Logprobs     interface{}          `json:"logprobs"` // Not typically used here
+}
+
+// OpenAIStreamDelta represents the delta content within an OpenAI SSE chunk
+type OpenAIStreamDelta struct {
+	Role    *string `json:"role,omitempty"` // Usually only in the first delta
+	Content *string `json:"content,omitempty"` // Pointer as it can be null or empty
+}
+
+// OpenAIStreamChunk represents the structure of a data chunk in the OpenAI SSE stream
+type OpenAIStreamChunk struct {
+	ID      string               `json:"id"`
+	Object  string               `json:"object"` // e.g., "chat.completion.chunk"
+	Created int64                `json:"created"`
+	Model   string               `json:"model"`
+	Choices []OpenAIStreamChoice `json:"choices"`
+	Usage   *OpenAIUsage         `json:"usage,omitempty"` // Usually null except maybe in Azure's final chunk?
+	// SystemFingerprint string `json:"system_fingerprint"` // Optional
+}
+
+
+// --- Claude SSE Structs (for sending back to client) ---
+
+// ClaudeSSEEvent represents a generic Claude SSE event structure for easy marshaling
+type ClaudeSSEEvent struct {
+	Type         string                `json:"type"`
+	Index        *int                  `json:"index,omitempty"` // Used in content_block_*
+	Message      *ClaudeSSEMessage     `json:"message,omitempty"` // Used in message_start
+	ContentBlock *ClaudeSSEContentBlock `json:"content_block,omitempty"` // Used in content_block_start
+	Delta        *ClaudeSSEDelta       `json:"delta,omitempty"` // Used in content_block_delta, message_delta
+	Usage        *ClaudeSSEUsage       `json:"usage,omitempty"` // Used in message_delta (HACK), message_stop
+	Error        *ClaudeError          `json:"error,omitempty"` // Used in error event
+}
+
+// ClaudeSSEMessage is nested within message_start
+type ClaudeSSEMessage struct {
+	ID           string               `json:"id"`
+	Type         string               `json:"type"` // "message"
+	Role         string               `json:"role"` // "assistant"
+	Content      []ClaudeContentBlock `json:"content"` // Initially empty
+	Model        string               `json:"model"`
+	StopReason   *string              `json:"stop_reason"` // Initially null
+	StopSequence *string              `json:"stop_sequence"` // Initially null
+	Usage        ClaudeUsage          `json:"usage"` // Initial usage (input tokens)
+}
+
+// ClaudeSSEContentBlock is nested within content_block_start
+type ClaudeSSEContentBlock struct {
+	Type string `json:"type"` // "text"
+	Text string `json:"text"` // Initially empty
+}
+
+// ClaudeSSEDelta is nested within content_block_delta and message_delta
+type ClaudeSSEDelta struct {
+	Type         string  `json:"type,omitempty"` // "text_delta" in content_block_delta
+	Text         *string `json:"text,omitempty"` // Pointer for content_block_delta
+	StopReason   *string `json:"stop_reason,omitempty"` // Pointer for message_delta
+	StopSequence *string `json:"stop_sequence,omitempty"` // Pointer for message_delta (usually null)
+}
+
+// ClaudeSSEUsage is nested within message_delta (HACK) and message_stop
+type ClaudeSSEUsage struct {
+	// Note: message_delta only needs output_tokens for the hack
+	// message_stop should have both
+	InputTokens  *int `json:"input_tokens,omitempty"` // Only in message_stop
+	OutputTokens int  `json:"output_tokens"` // In both (but value differs)
+}