diff --git a/claude-proxy.sh b/claude-proxy.sh
index aa81404..536777b 100755
--- a/claude-proxy.sh
+++ b/claude-proxy.sh
@@ -53,20 +53,39 @@ while [[ $# -gt 0 ]]; do
   esac
 done
 
-# Build settings JSON that overrides the global settings.json env block.
-# --settings MERGES with the global config, so we must explicitly override
-# every env var that interferes:
-#   - ANTHROPIC_AUTH_TOKEN: global sets "dummy"; interactive (cli) mode uses
-#     this for auth, so it must be the real proxy token.
-#   - ANTHROPIC_CUSTOM_HEADERS: global injects Cloudflare gateway headers;
-#     cleared so they don't leak to the local proxy.
-#   - ANTHROPIC_BASE_URL: global points at Cloudflare gateway.
-SETTINGS=$(cat <<EOF
+# Build settings JSON safely using python3 to avoid JSON injection if the
+# token contains quotes or backslashes. Falls back to heredoc if python3
+# is unavailable.
+if command -v python3 &>/dev/null; then
+  SETTINGS=$(python3 -c '
+import json, sys
+token = sys.argv[1]
+model = sys.argv[2]
+haiku = sys.argv[3]
+print(json.dumps({
+  "env": {
+    "ANTHROPIC_BASE_URL": "http://127.0.0.1:3050",
+    "ANTHROPIC_API_KEY": token,
+    "ANTHROPIC_AUTH_TOKEN": token,
+    "ANTHROPIC_CUSTOM_HEADERS": "",
+    "ANTHROPIC_MODEL": model,
+    "ANTHROPIC_DEFAULT_HAIKU_MODEL": haiku,
+    "ANTHROPIC_DEFAULT_SONNET_MODEL": model,
+    "ANTHROPIC_DEFAULT_OPUS_MODEL": model
+  },
+  "model": model
+}))
+' "$PROXY_TOKEN" "$MODEL" "$HAIKU")
+else
+  # Fallback: escape token for JSON (handles " and \)
+  ESCAPED_TOKEN="${PROXY_TOKEN//\\/\\\\}"
+  ESCAPED_TOKEN="${ESCAPED_TOKEN//\"/\\\"}"
+  SETTINGS=$(cat <<EOF
 {
   "env": {
     "ANTHROPIC_BASE_URL": "http://127.0.0.1:3050",
-    "ANTHROPIC_API_KEY": "${PROXY_TOKEN}",
-    "ANTHROPIC_AUTH_TOKEN": "${PROXY_TOKEN}",
+    "ANTHROPIC_API_KEY": "${ESCAPED_TOKEN}",
+    "ANTHROPIC_AUTH_TOKEN": "${ESCAPED_TOKEN}",
     "ANTHROPIC_CUSTOM_HEADERS": "",
     "ANTHROPIC_MODEL": "${MODEL}",
     "ANTHROPIC_DEFAULT_HAIKU_MODEL": "${HAIKU}",
@@ -76,6 +95,7 @@ SETTINGS=$(cat <<EOF
   "model": "${MODEL}"
 }
 EOF
-)
+  )
+fi
 
 exec claude --settings "$SETTINGS" "${PASSTHROUGH[@]+"${PASSTHROUGH[@]}"}"
diff --git a/internal/client/client.go b/internal/client/client.go
index e413ecf..d0f4f8f 100644
--- a/internal/client/client.go
+++ b/internal/client/client.go
@@ -28,9 +28,18 @@ type Client struct {
 
 // New creates a new CommandCode API client
 func New(apiBase string, projectSlug string, logger *logging.Logger) *Client {
+	// Use a custom transport with connection pooling tuned for both
+	// short API calls and long-running streaming responses. The overall
+	// timeout is handled per-request via context, not the http.Client,
+	// so streaming responses are not killed prematurely.
+	transport := &http.Transport{
+		MaxIdleConns:        20,
+		MaxIdleConnsPerHost: 10,
+		IdleConnTimeout:     90 * time.Second,
+	}
 	return &Client{
 		httpClient: &http.Client{
-			Timeout: 90 * time.Second,
+			Transport: transport,
 		},
 		apiBase:     apiBase,
 		projectSlug: projectSlug,
@@ -39,7 +48,7 @@ func New(apiBase string, projectSlug string, logger *logging.Logger) *Client {
 }
 
 // Forward forwards a request to the CommandCode API
-func (c *Client) Forward(ctx context.Context, body []byte, cc_apiKey string, headers http.Header, sessionID string, fp *config.Fingerprint) (*http.Response, error) {
+func (c *Client) Forward(ctx context.Context, body []byte, ccAPIKey string, headers http.Header, sessionID string, fp *config.Fingerprint) (*http.Response, error) {
 	url := fmt.Sprintf("%s/alpha/generate", c.apiBase)
 
 	req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewReader(body))
@@ -51,7 +60,7 @@ func (c *Client) Forward(ctx context.Context, body []byte, cc_apiKey string, hea
 	}
 
 	// Set headers
-	req.Header.Set("Authorization", "Bearer "+cc_apiKey)
+	req.Header.Set("Authorization", "Bearer "+ccAPIKey)
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("x-cli-environment", "production")
 	req.Header.Set("x-command-code-version", version.GetCommandCodeVersion())
@@ -80,9 +89,10 @@ func (c *Client) Forward(ctx context.Context, body []byte, cc_apiKey string, hea
 		req.Header.Set("x-collector-version", fmt.Sprintf("%d", fp.Components.CollectorVersion))
 	}
 
-	// Copy safe custom headers without leaking local proxy credentials upstream.
+	// Copy only safe client headers upstream — use an allowlist rather than a
+	// blocklist to prevent accidental credential leakage.
 	for key, values := range headers {
-		if isForwardBlockedHeader(key) {
+		if !isForwardAllowedHeader(key) {
 			continue
 		}
 		for _, value := range values {
@@ -110,7 +120,7 @@ func (c *Client) Forward(ctx context.Context, body []byte, cc_apiKey string, hea
 }
 
 // ForwardAnthropicCountTokens forwards an Anthropic token count request to the upstream API.
-func (c *Client) ForwardAnthropicCountTokens(ctx context.Context, body []byte, cc_apiKey string, headers http.Header, sessionID string, fp *config.Fingerprint, rawQuery string) (*http.Response, error) {
+func (c *Client) ForwardAnthropicCountTokens(ctx context.Context, body []byte, ccAPIKey string, headers http.Header, sessionID string, fp *config.Fingerprint, rawQuery string) (*http.Response, error) {
 	url := fmt.Sprintf("%s/v1/messages/count_tokens", c.apiBase)
 	if rawQuery != "" {
 		url += "?" + rawQuery
@@ -124,7 +134,7 @@ func (c *Client) ForwardAnthropicCountTokens(ctx context.Context, body []byte, c
 		return nil, fmt.Errorf("failed to create request: %w", err)
 	}
 
-	req.Header.Set("Authorization", "Bearer "+cc_apiKey)
+	req.Header.Set("Authorization", "Bearer "+ccAPIKey)
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("x-cli-environment", "production")
 	req.Header.Set("x-command-code-version", version.GetCommandCodeVersion())
@@ -153,7 +163,7 @@ func (c *Client) ForwardAnthropicCountTokens(ctx context.Context, body []byte, c
 	}
 
 	for key, values := range headers {
-		if isForwardBlockedHeader(key) {
+		if !isForwardAllowedHeader(key) {
 			continue
 		}
 		for _, value := range values {
@@ -193,10 +203,17 @@ func (c *Client) projectSlugForSession(sessionID string) string {
 	return ProjectSlug(c.projectSlug, sessionID)
 }
 
-// isForwardBlockedHeader reports whether an inbound header must stay local to the proxy.
-func isForwardBlockedHeader(key string) bool {
-	switch strings.ToLower(key) {
-	case "authorization", "x-proxy-token", "x-cli-environment", "x-command-code-version", "x-project-slug", "x-session-id", "x-co-flag", "x-taste-learning", "traceparent", "connection", "keep-alive", "proxy-authenticate", "proxy-authorization", "te", "trailer", "transfer-encoding", "upgrade", "host", "content-length":
+// isForwardAllowedHeader reports whether an inbound header is safe to forward
+// upstream. Uses an allowlist of anthropic/SDK headers — everything else
+// (including Authorization, proxy tokens, hop-by-hop headers) is blocked.
+func isForwardAllowedHeader(key string) bool {
+	lk := strings.ToLower(key)
+	// Allow Anthropic SDK headers that the upstream API expects.
+	if strings.HasPrefix(lk, "anthropic-") {
+		return true
+	}
+	switch lk {
+	case "accept", "accept-encoding", "user-agent":
 		return true
 	default:
 		return false
@@ -217,7 +234,7 @@ func generateTraceparent() string {
 }
 
 // FetchModels fetches the list of available models from the Provider API
-func (c *Client) FetchModels(ctx context.Context, cc_apiKey string) ([]Model, error) {
+func (c *Client) FetchModels(ctx context.Context, ccAPIKey string) ([]Model, error) {
 	url := fmt.Sprintf("%s/v1/models", c.apiBase)
 
 	req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
@@ -228,7 +245,7 @@ func (c *Client) FetchModels(ctx context.Context, cc_apiKey string) ([]Model, er
 		return nil, fmt.Errorf("failed to create request: %w", err)
 	}
 
-	req.Header.Set("Authorization", "Bearer "+cc_apiKey)
+	req.Header.Set("Authorization", "Bearer "+ccAPIKey)
 	req.Header.Set("Content-Type", "application/json")
 
 	resp, err := c.httpClient.Do(req)
@@ -264,7 +281,7 @@ func (c *Client) FetchModels(ctx context.Context, cc_apiKey string) ([]Model, er
 }
 
 // SendFingerprint sends a fingerprint to the CommandCode API
-func (c *Client) SendFingerprint(ctx context.Context, fp *fingerprint.Fingerprint, cc_apiKey string) error {
+func (c *Client) SendFingerprint(ctx context.Context, fp *fingerprint.Fingerprint, ccAPIKey string) error {
 	url := fmt.Sprintf("%s/v1/fingerprint", c.apiBase)
 
 	body, err := json.Marshal(fp)
@@ -283,7 +300,7 @@ func (c *Client) SendFingerprint(ctx context.Context, fp *fingerprint.Fingerprin
 		return fmt.Errorf("failed to create request: %w", err)
 	}
 
-	req.Header.Set("Authorization", "Bearer "+cc_apiKey)
+	req.Header.Set("Authorization", "Bearer "+ccAPIKey)
 	req.Header.Set("Content-Type", "application/json")
 
 	resp, err := c.httpClient.Do(req)
@@ -307,7 +324,7 @@ func (c *Client) SendFingerprint(ctx context.Context, fp *fingerprint.Fingerprin
 }
 
 // SendLifecycleEvent sends a lifecycle event to the CommandCode API
-func (c *Client) SendLifecycleEvent(ctx context.Context, cc_apiKey string, eventType string) error {
+func (c *Client) SendLifecycleEvent(ctx context.Context, ccAPIKey string, eventType string) error {
 	url := fmt.Sprintf("%s/v1/lifecycle", c.apiBase)
 
 	event := map[string]string{
@@ -330,7 +347,7 @@ func (c *Client) SendLifecycleEvent(ctx context.Context, cc_apiKey string, event
 		return fmt.Errorf("failed to create request: %w", err)
 	}
 
-	req.Header.Set("Authorization", "Bearer "+cc_apiKey)
+	req.Header.Set("Authorization", "Bearer "+ccAPIKey)
 	req.Header.Set("Content-Type", "application/json")
 
 	resp, err := c.httpClient.Do(req)
diff --git a/internal/client/init.go b/internal/client/init.go
index d26d5e3..12d794d 100644
--- a/internal/client/init.go
+++ b/internal/client/init.go
@@ -43,7 +43,7 @@ func NewInitManager(apiBase string, projectSlug string, logger *logging.Logger)
 }
 
 // EnsureInitialized ensures initialization requests are sent if needed
-func (m *InitManager) EnsureInitialized(ctx context.Context, cc_apiKey string, fp *config.Fingerprint) error {
+func (m *InitManager) EnsureInitialized(ctx context.Context, ccAPIKey string, fp *config.Fingerprint) error {
 	m.mu.Lock()
 	now := time.Now()
 	if now.Before(m.nextInitAt) {
@@ -55,7 +55,7 @@ func (m *InitManager) EnsureInitialized(ctx context.Context, cc_apiKey string, f
 	headers := map[string]string{
 		"Content-Type":           "application/json",
 		"x-cli-environment":      "production",
-		"Authorization":          "Bearer " + cc_apiKey,
+		"Authorization":          "Bearer " + ccAPIKey,
 		"x-command-code-version": version.GetCommandCodeVersion(),
 	}
 
diff --git a/internal/config/config.go b/internal/config/config.go
index c4229b6..2495a4c 100644
--- a/internal/config/config.go
+++ b/internal/config/config.go
@@ -20,7 +20,7 @@ type Config struct {
 	LogFile              string        `json:"logFile"`
 	LogLevel             string        `json:"logLevel"`
 	UseProviderModels    bool          `json:"useProviderModels"`
-	ModelRefreshInterval time.Duration `json:"modelRefreshIntervalMs"`
+	ModelRefreshInterval time.Duration `json:"modelRefreshInterval,omitempty"`
 	Fingerprint          *Fingerprint  `json:"fingerprint,omitempty"`
 }
 
diff --git a/internal/config/config_test.go b/internal/config/config_test.go
new file mode 100644
index 0000000..ba831e5
--- /dev/null
+++ b/internal/config/config_test.go
@@ -0,0 +1,129 @@
+package config
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+)
+
+func TestLoadFallsBackToDefaultsWhenFileMissing(t *testing.T) {
+	cfg, err := Load(filepath.Join(t.TempDir(), "nonexistent-config-test.json"))
+	if err != nil {
+		t.Fatalf("Load() error = %v, want nil for missing file", err)
+	}
+	if cfg.Port != 3000 {
+		t.Fatalf("Port = %d, want default 3000", cfg.Port)
+	}
+	if cfg.APIBase != "https://api.commandcode.ai" {
+		t.Fatalf("APIBase = %q, want default", cfg.APIBase)
+	}
+	if cfg.UseProviderModels != true {
+		t.Fatalf("UseProviderModels = %v, want true", cfg.UseProviderModels)
+	}
+}
+
+func TestLoadFailsOnPermissionDenied(t *testing.T) {
+	dir := t.TempDir()
+	path := filepath.Join(dir, "config.json")
+	if err := os.WriteFile(path, []byte(`{"port":3050}`), 0644); err != nil {
+		t.Fatalf("setup: %v", err)
+	}
+	if err := os.Chmod(path, 0000); err != nil {
+		t.Fatalf("chmod: %v", err)
+	}
+	t.Cleanup(func() { os.Chmod(path, 0644) })
+
+	// Skip if running as root (root bypasses file permissions).
+	if os.Getuid() == 0 {
+		t.Skip("running as root, permission test not applicable")
+	}
+
+	_, err := Load(path)
+	if err == nil {
+		t.Fatal("Load() error = nil, want error for unreadable file")
+	}
+}
+
+func TestLoadParsesValidJSON(t *testing.T) {
+	dir := t.TempDir()
+	path := filepath.Join(dir, "config.json")
+	data := `{"port":8080,"host":"127.0.0.1","apiBase":"https://custom.api","cc_apiKey":"user_abc123","proxy_token":"tok"}`
+	if err := os.WriteFile(path, []byte(data), 0644); err != nil {
+		t.Fatalf("setup: %v", err)
+	}
+
+	cfg, err := Load(path)
+	if err != nil {
+		t.Fatalf("Load() error = %v", err)
+	}
+	if cfg.Port != 8080 {
+		t.Fatalf("Port = %d, want 8080", cfg.Port)
+	}
+	if cfg.Host != "127.0.0.1" {
+		t.Fatalf("Host = %q, want 127.0.0.1", cfg.Host)
+	}
+	if cfg.APIBase != "https://custom.api" {
+		t.Fatalf("APIBase = %q, want https://custom.api", cfg.APIBase)
+	}
+	if cfg.CCAPIKey != "user_abc123" {
+		t.Fatalf("CCAPIKey = %q, want user_abc123", cfg.CCAPIKey)
+	}
+	if cfg.ProxyToken != "tok" {
+		t.Fatalf("ProxyToken = %q, want tok", cfg.ProxyToken)
+	}
+}
+
+func TestLoadFailsOnInvalidJSON(t *testing.T) {
+	dir := t.TempDir()
+	path := filepath.Join(dir, "config.json")
+	if err := os.WriteFile(path, []byte(`{invalid json`), 0644); err != nil {
+		t.Fatalf("setup: %v", err)
+	}
+
+	_, err := Load(path)
+	if err == nil {
+		t.Fatal("Load() error = nil, want error for invalid JSON")
+	}
+}
+
+func TestLoadEnvOverrides(t *testing.T) {
+	t.Setenv("PORT", "9999")
+	t.Setenv("HOST", "0.0.0.0")
+	t.Setenv("COMMANDCODE_PROXY_TOKEN", "envtoken")
+	t.Setenv("LOG_LEVEL", "debug")
+
+	cfg, err := Load(filepath.Join(t.TempDir(), "nonexistent-config-test.json"))
+	if err != nil {
+		t.Fatalf("Load() error = %v", err)
+	}
+	if cfg.Port != 9999 {
+		t.Fatalf("Port = %d, want 9999 from env", cfg.Port)
+	}
+	if cfg.ProxyToken != "envtoken" {
+		t.Fatalf("ProxyToken = %q, want envtoken from env", cfg.ProxyToken)
+	}
+	if cfg.LogLevel != "debug" {
+		t.Fatalf("LogLevel = %q, want debug from env", cfg.LogLevel)
+	}
+}
+
+func TestValidateRejectsInvalidPort(t *testing.T) {
+	cfg := &Config{Port: 0, Host: "0.0.0.0", APIBase: "https://api.test"}
+	if err := cfg.Validate(); err == nil {
+		t.Fatal("Validate() error = nil, want error for port 0")
+	}
+}
+
+func TestValidateRejectsEmptyHost(t *testing.T) {
+	cfg := &Config{Port: 3050, Host: "", APIBase: "https://api.test"}
+	if err := cfg.Validate(); err == nil {
+		t.Fatal("Validate() error = nil, want error for empty host")
+	}
+}
+
+func TestDefaultModelRefreshInterval(t *testing.T) {
+	if defaults.ModelRefreshInterval != 5*time.Minute {
+		t.Fatalf("default ModelRefreshInterval = %v, want 5m", defaults.ModelRefreshInterval)
+	}
+}
diff --git a/internal/http/handlers.go b/internal/http/handlers.go
index 9e2e804..63f0b0b 100644
--- a/internal/http/handlers.go
+++ b/internal/http/handlers.go
@@ -9,6 +9,7 @@ import (
 	"io"
 	"net/http"
 	"strings"
+	"sync"
 	"sync/atomic"
 	"time"
 
@@ -30,7 +31,30 @@ const (
 	timeoutRetryAfterSeconds       = 5
 )
 
-var consecutiveTimeouts atomic.Int64
+// sessionTimeouts tracks consecutive idle timeouts per session to provide
+// context-reduction hints without leaking state across different users.
+var sessionTimeouts sync.Map
+
+// incrementTimeout returns the new consecutive count for a session.
+func incrementTimeout(sessionID string) int64 {
+	var count int64
+	v, _ := sessionTimeouts.LoadOrStore(sessionID, &atomic.Int64{})
+	count = v.(*atomic.Int64).Add(1)
+	return count
+}
+
+// resetTimeout clears the consecutive timeout counter for a session.
+func resetTimeout(sessionID string) {
+	sessionTimeouts.Delete(sessionID)
+}
+
+// ccAPIKeyFromContext safely extracts the API key from request context.
+func ccAPIKeyFromContext(ctx context.Context) string {
+	if v, ok := ctx.Value("ccAPIKey").(string); ok {
+		return v
+	}
+	return ""
+}
 
 // HandlerDependencies contains dependencies for HTTP handlers
 type HandlerDependencies struct {
@@ -46,7 +70,7 @@ type HandlerDependencies struct {
 // HandleChatCompletions handles OpenAI chat completions endpoint
 func HandleChatCompletions(deps *HandlerDependencies) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		ccAPIKey := r.Context().Value("ccAPIKey").(string)
+		ccAPIKey := ccAPIKeyFromContext(r.Context())
 
 		// Ensure initialization (fingerprint/lifecycle events)
 		if err := deps.InitManager.EnsureInitialized(r.Context(), ccAPIKey, deps.Config.Fingerprint); err != nil {
@@ -121,10 +145,10 @@ func HandleChatCompletions(deps *HandlerDependencies) http.HandlerFunc {
 			translator := streaming.NewOpenAITranslator(openaiReq.Model, generateCompletionID(), time.Now().Unix())
 			streamWriter := newDelayedSSEWriter(w)
 			if err := translator.TranslateStreamWithIdleTimeout(resp.Body, streamWriter, streamIdleTimeout); err != nil {
-				handleStreamingError(w, streamWriter, deps.Logger, err)
+				handleStreamingError(w, streamWriter, deps.Logger, err, sessionID)
 				return
 			}
-			consecutiveTimeouts.Store(0)
+			resetTimeout(sessionID)
 			inputTokens, outputTokens, cachedTokens := translator.GetUsage()
 			if outputTokens == 0 {
 				cancel()
@@ -162,7 +186,7 @@ func HandleChatCompletions(deps *HandlerDependencies) http.HandlerFunc {
 			return
 		}
 
-		openaiResp, err := commandCodeStreamToOpenAIWithIdleTimeout(resp.Body, openaiReq.Model, generateCompletionID(), time.Now().Unix(), deps.Logger, nonStreamIdleTimeout)
+		openaiResp, err := commandCodeStreamToOpenAIWithIdleTimeout(resp.Body, openaiReq.Model, generateCompletionID(), time.Now().Unix(), deps.Logger, nonStreamIdleTimeout, sessionID)
 		if err != nil {
 			if apiErr, ok := err.(*apierror.APIError); ok {
 				sendError(w, apiErr)
@@ -193,7 +217,7 @@ func HandleChatCompletions(deps *HandlerDependencies) http.HandlerFunc {
 // HandleResponses handles OpenAI Responses endpoint.
 func HandleResponses(deps *HandlerDependencies) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		ccAPIKey := r.Context().Value("ccAPIKey").(string)
+		ccAPIKey := ccAPIKeyFromContext(r.Context())
 		if err := deps.InitManager.EnsureInitialized(r.Context(), ccAPIKey, deps.Config.Fingerprint); err != nil {
 			deps.Logger.Warn("Initialization failed", map[string]any{"error": err.Error()})
 		}
@@ -228,7 +252,7 @@ func HandleResponses(deps *HandlerDependencies) http.HandlerFunc {
 // HandleResponsesCompact handles OpenAI Responses compaction endpoint.
 func HandleResponsesCompact(deps *HandlerDependencies) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		ccAPIKey := r.Context().Value("ccAPIKey").(string)
+		ccAPIKey := ccAPIKeyFromContext(r.Context())
 		if err := deps.InitManager.EnsureInitialized(r.Context(), ccAPIKey, deps.Config.Fingerprint); err != nil {
 			deps.Logger.Warn("Initialization failed", map[string]any{"error": err.Error()})
 		}
@@ -280,10 +304,10 @@ func handleCommandCodeResponsesRequest(w http.ResponseWriter, r *http.Request, d
 		streamWriter := newDelayedSSEWriter(w)
 		responseID := protocol.ResponseID("resp")
 		if err := commandCodeStreamToOpenAIResponsesSSE(resp.Body, streamWriter, responseID, model, time.Now().Unix(), deps.Logger, streamIdleTimeout); err != nil {
-			handleStreamingError(w, streamWriter, deps.Logger, err)
+			handleStreamingError(w, streamWriter, deps.Logger, err, sessionID)
 			return
 		}
-		consecutiveTimeouts.Store(0)
+		resetTimeout(sessionID)
 		streamWriter.WriteDone()
 		return
 	}
@@ -300,7 +324,7 @@ func handleCommandCodeResponsesRequest(w http.ResponseWriter, r *http.Request, d
 		return
 	}
 
-	openaiResp, err := commandCodeStreamToOpenAIWithIdleTimeout(resp.Body, model, generateCompletionID(), time.Now().Unix(), deps.Logger, nonStreamIdleTimeout)
+	openaiResp, err := commandCodeStreamToOpenAIWithIdleTimeout(resp.Body, model, generateCompletionID(), time.Now().Unix(), deps.Logger, nonStreamIdleTimeout, sessionID)
 	if err != nil {
 		if apiErr, ok := err.(*apierror.APIError); ok {
 			sendError(w, apiErr)
@@ -312,30 +336,35 @@ func handleCommandCodeResponsesRequest(w http.ResponseWriter, r *http.Request, d
 	}
 
 	var responseObject *protocol.OpenAIResponseObject
+	if len(openaiResp.Choices) == 0 {
+		deps.Logger.Warn("Upstream returned zero choices", map[string]any{"model": model})
+		sendError(w, apierror.NewAPIError(apierror.ErrorTypeUpstream, "Upstream returned empty response").WithCode(http.StatusBadGateway))
+		return
+	}
 	message := openaiResp.Choices[0].Message
 	if compact {
 		responseObject = protocol.BuildOpenAICompactionObject(protocol.ResponseID("resp"), time.Now().Unix(), fmt.Sprint(message.Content), openaiResp.Usage)
 	} else {
 		responseObject = protocol.BuildOpenAIResponseObject(protocol.ResponseID("resp"), model, time.Now().Unix(), fmt.Sprint(message.Content), message.ToolCalls, openaiResp.Usage)
 	}
-		if openaiResp.Usage != nil {
-			deps.Logger.Info("Token usage", map[string]any{
-				"endpoint":      "openai/responses",
-				"stream":        false,
-				"model":         model,
-				"input_tokens":  openaiResp.Usage.InputTokens,
-				"output_tokens": openaiResp.Usage.OutputTokens,
-				"cached_tokens": openaiResp.Usage.CachedInputTokens,
-			})
-		}
-		w.Header().Set("Content-Type", "application/json")
-		json.NewEncoder(w).Encode(responseObject)
+	if openaiResp.Usage != nil {
+		deps.Logger.Info("Token usage", map[string]any{
+			"endpoint":      "openai/responses",
+			"stream":        false,
+			"model":         model,
+			"input_tokens":  openaiResp.Usage.InputTokens,
+			"output_tokens": openaiResp.Usage.OutputTokens,
+			"cached_tokens": openaiResp.Usage.CachedInputTokens,
+		})
+	}
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(responseObject)
 }
 
 // HandleMessages handles Anthropic messages endpoint
 func HandleMessages(deps *HandlerDependencies) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		ccAPIKey := r.Context().Value("ccAPIKey").(string)
+		ccAPIKey := ccAPIKeyFromContext(r.Context())
 
 		// Ensure initialization (fingerprint/lifecycle events)
 		if err := deps.InitManager.EnsureInitialized(r.Context(), ccAPIKey, deps.Config.Fingerprint); err != nil {
@@ -424,10 +453,10 @@ func HandleMessages(deps *HandlerDependencies) http.HandlerFunc {
 			translator := streaming.NewAnthropicTranslator(anthropicReq.Model, generateMessageID())
 			streamWriter := newDelayedSSEWriter(w)
 			if err := translator.TranslateWithIdleTimeout(resp.Body, streamWriter, streamIdleTimeout); err != nil {
-				handleStreamingError(w, streamWriter, deps.Logger, err)
+				handleStreamingError(w, streamWriter, deps.Logger, err, sessionID)
 				return
 			}
-			consecutiveTimeouts.Store(0)
+			resetTimeout(sessionID)
 			inputTokens, outputTokens, cachedTokens := translator.GetUsage()
 			if outputTokens == 0 {
 				cancel()
@@ -465,7 +494,7 @@ func HandleMessages(deps *HandlerDependencies) http.HandlerFunc {
 			return
 		}
 
-		anthropicResp, err := commandCodeStreamToAnthropicMessagesWithIdleTimeout(resp.Body, anthropicReq.Model, generateMessageID(), deps.Logger, nonStreamIdleTimeout)
+		anthropicResp, err := commandCodeStreamToAnthropicMessagesWithIdleTimeout(resp.Body, anthropicReq.Model, generateMessageID(), deps.Logger, nonStreamIdleTimeout, sessionID)
 		if err != nil {
 			if apiErr, ok := err.(*apierror.APIError); ok {
 				sendError(w, apiErr)
@@ -496,7 +525,7 @@ func HandleMessages(deps *HandlerDependencies) http.HandlerFunc {
 // HandleMessagesCountTokens handles Anthropic token counting requests.
 func HandleMessagesCountTokens(deps *HandlerDependencies) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		ccAPIKey := r.Context().Value("ccAPIKey").(string)
+		ccAPIKey := ccAPIKeyFromContext(r.Context())
 		body, err := io.ReadAll(r.Body)
 		if err != nil {
 			deps.Logger.Warn("Failed to read Anthropic token count request body", map[string]any{
@@ -678,12 +707,12 @@ func timeoutMessage(count int64) string {
 	return "Response timeout - request timed out"
 }
 
-func handleStreamingError(w http.ResponseWriter, streamWriter *delayedSSEWriter, logger *logging.Logger, err error) {
+func handleStreamingError(w http.ResponseWriter, streamWriter *delayedSSEWriter, logger *logging.Logger, err error, sessionID string) {
 	logger.Error("Streaming error", map[string]any{
 		"error": err.Error(),
 	})
 	if errors.Is(err, streaming.ErrStreamIdleTimeout) {
-		count := consecutiveTimeouts.Add(1)
+		count := incrementTimeout(sessionID)
 		logger.Warn("Stream idle timeout", map[string]any{
 			"consecutive": count,
 		})
@@ -723,7 +752,7 @@ func decodeRequestBody(body io.Reader, target any) *apierror.APIError {
 }
 
 func commandCodeStreamToOpenAI(reader io.Reader, model string, completionID string, created int64, logger *logging.Logger) (*protocol.OpenAIResponse, error) {
-	return commandCodeStreamToOpenAIWithIdleTimeout(reader, model, completionID, created, logger, 0)
+	return commandCodeStreamToOpenAIWithIdleTimeout(reader, model, completionID, created, logger, 0, "")
 }
 
 func commandCodeStreamToOpenAIResponsesSSE(reader io.Reader, writer io.Writer, responseID string, model string, created int64, logger *logging.Logger, idleTimeout time.Duration) error {
@@ -890,18 +919,18 @@ func writeResponseSSEEvent(writer io.Writer, event string, data any) error {
 	return err
 }
 
-func commandCodeStreamToAnthropicMessagesWithIdleTimeout(reader io.Reader, model string, messageID string, logger *logging.Logger, idleTimeout time.Duration) (*protocol.AnthropicResponse, error) {
+func commandCodeStreamToAnthropicMessagesWithIdleTimeout(reader io.Reader, model string, messageID string, logger *logging.Logger, idleTimeout time.Duration, sessionID string) (*protocol.AnthropicResponse, error) {
 	done := make(chan struct{})
 	defer close(done)
 	lines := streaming.ScanLines(reader, done)
-	content, finishReason, usage, err := collectCommandCodeAnthropicContent(lines, logger, idleTimeout)
+	content, finishReason, usage, err := collectCommandCodeAnthropicContent(lines, logger, idleTimeout, sessionID)
 	if err != nil {
 		return nil, err
 	}
 	return protocol.CommandCodeToAnthropicMessages(messageID, model, content, finishReason, usage), nil
 }
 
-func collectCommandCodeAnthropicContent(lines <-chan streaming.StreamLine, logger *logging.Logger, idleTimeout time.Duration) ([]protocol.AnthropicContent, string, *protocol.Usage, error) {
+func collectCommandCodeAnthropicContent(lines <-chan streaming.StreamLine, logger *logging.Logger, idleTimeout time.Duration, sessionID string) ([]protocol.AnthropicContent, string, *protocol.Usage, error) {
 	var textContent strings.Builder
 	var reasoningContent strings.Builder
 	finishReason := "stop"
@@ -925,7 +954,7 @@ func collectCommandCodeAnthropicContent(lines <-chan streaming.StreamLine, logge
 		line, err := streaming.NextLine(lines, idleTimeout)
 		if err != nil {
 			if errors.Is(err, streaming.ErrStreamIdleTimeout) {
-				count := consecutiveTimeouts.Add(1)
+				count := incrementTimeout(sessionID)
 				message := timeoutMessage(count)
 				return nil, "", nil, apierror.NewAPIError(apierror.ErrorTypeRateLimit, message).WithCode(http.StatusTooManyRequests)
 			}
@@ -1001,7 +1030,7 @@ func collectCommandCodeAnthropicContent(lines <-chan streaming.StreamLine, logge
 	return content, finishReason, usage, nil
 }
 
-func commandCodeStreamToOpenAIWithIdleTimeout(reader io.Reader, model string, completionID string, created int64, logger *logging.Logger, idleTimeout time.Duration) (*protocol.OpenAIResponse, error) {
+func commandCodeStreamToOpenAIWithIdleTimeout(reader io.Reader, model string, completionID string, created int64, logger *logging.Logger, idleTimeout time.Duration, sessionID string) (*protocol.OpenAIResponse, error) {
 	done := make(chan struct{})
 	defer close(done)
 	lines := streaming.ScanLines(reader, done)
@@ -1015,7 +1044,7 @@ func commandCodeStreamToOpenAIWithIdleTimeout(reader io.Reader, model string, co
 		line, err := streaming.NextLine(lines, idleTimeout)
 		if err != nil {
 			if errors.Is(err, streaming.ErrStreamIdleTimeout) {
-				count := consecutiveTimeouts.Add(1)
+				count := incrementTimeout(sessionID)
 				message := timeoutMessage(count)
 				return nil, apierror.NewAPIError(apierror.ErrorTypeRateLimit, message).WithCode(http.StatusTooManyRequests)
 			}
diff --git a/internal/http/handlers_test.go b/internal/http/handlers_test.go
index 4340dfc..f302ea1 100644
--- a/internal/http/handlers_test.go
+++ b/internal/http/handlers_test.go
@@ -36,7 +36,7 @@ func TestCommandCodeStreamToAnthropicMessagesHandlesReasoningAndToolCalls(t *tes
 		`{"type":"finish","finishReason":"tool_calls","totalUsage":{"inputTokens":3,"outputTokens":4}}`,
 	}, "\n"))
 
-	resp, err := commandCodeStreamToAnthropicMessagesWithIdleTimeout(stream, "model", "msg-test", nil, 0)
+	resp, err := commandCodeStreamToAnthropicMessagesWithIdleTimeout(stream, "model", "msg-test", nil, 0, "")
 	if err != nil {
 		t.Fatalf("commandCodeStreamToAnthropicMessagesWithIdleTimeout() error = %v", err)
 	}
diff --git a/internal/http/middleware.go b/internal/http/middleware.go
index 5e7efff..bd0f6e4 100644
--- a/internal/http/middleware.go
+++ b/internal/http/middleware.go
@@ -13,20 +13,28 @@ import (
 	"github.com/kilimcininkoroglu/commandcode-bridge/internal/logging"
 )
 
-// CORS middleware adds CORS headers to all responses
-func CORS(next http.Handler) http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Access-Control-Allow-Origin", "*")
-		w.Header().Set("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
-		w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization, X-Proxy-Token, x-api-key, anthropic-version, anthropic-beta")
-
-		if r.Method == "OPTIONS" {
-			w.WriteHeader(http.StatusOK)
-			return
-		}
+// CORS middleware adds CORS headers to all responses. When allowedOrigin is
+// empty, defaults to "*" (safe for localhost-only deployments). For network
+// deployments, set a specific origin to prevent cross-site request abuse.
+func CORS(allowedOrigin string) func(http.Handler) http.Handler {
+	origin := allowedOrigin
+	if origin == "" {
+		origin = "*"
+	}
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.Header().Set("Access-Control-Allow-Origin", origin)
+			w.Header().Set("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
+			w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization, X-Proxy-Token, x-api-key, anthropic-version, anthropic-beta")
+
+			if r.Method == "OPTIONS" {
+				w.WriteHeader(http.StatusOK)
+				return
+			}
 
-		next.ServeHTTP(w, r)
-	})
+			next.ServeHTTP(w, r)
+		})
+	}
 }
 
 var ccAPIKeyPattern = regexp.MustCompile(`user_[a-zA-Z0-9_-]+`)
diff --git a/internal/http/server.go b/internal/http/server.go
index 5196583..c11bead 100644
--- a/internal/http/server.go
+++ b/internal/http/server.go
@@ -34,7 +34,7 @@ func (s *Server) Start() error {
 	r := chi.NewRouter()
 
 	// Apply middleware
-	r.Use(CORS)
+	r.Use(CORS(""))                           // empty = allow all origins (localhost-only default)
 	r.Use(RequestSizeLimit(10 * 1024 * 1024)) // 10MB limit
 	r.Use(RequestTimeout(90 * time.Second))
 	r.Use(LoggingMiddleware(s.logger))
diff --git a/internal/protocol/converter.go b/internal/protocol/converter.go
index ece82b1..9813232 100644
--- a/internal/protocol/converter.go
+++ b/internal/protocol/converter.go
@@ -7,6 +7,7 @@ import (
 	"errors"
 	"fmt"
 	"strings"
+	"time"
 
 	"github.com/kilimcininkoroglu/commandcode-bridge/internal/config"
 )
@@ -17,11 +18,15 @@ func OpenAIToCommandCode(req *OpenAIRequest) (*CommandCodeRequest, error) {
 		return nil, errors.New("nil request")
 	}
 
-	// Convert messages
+	// Convert messages and extract system parts in a single pass
 	toolNameByID := buildOpenAIToolNameMap(req.Messages)
 	ccMessages := make([]CommandCodeMessage, 0, len(req.Messages))
+	systemParts := []string{}
 	for _, msg := range req.Messages {
 		if msg.Role == "system" {
+			if str, ok := msg.Content.(string); ok && str != "" {
+				systemParts = append(systemParts, str)
+			}
 			continue
 		}
 		ccMsg, err := openaiMessageToCommandCode(msg, toolNameByID)
@@ -33,6 +38,7 @@ func OpenAIToCommandCode(req *OpenAIRequest) (*CommandCodeRequest, error) {
 		}
 		ccMessages = append(ccMessages, ccMsg)
 	}
+	system := strings.Join(systemParts, "\n\n")
 
 	// Convert tools
 	ccTools := make([]CommandCodeTool, 0, len(req.Tools))
@@ -44,35 +50,9 @@ func OpenAIToCommandCode(req *OpenAIRequest) (*CommandCodeRequest, error) {
 		ccTools = append(ccTools, ccTool)
 	}
 
-	// Build system message from OpenAI messages if present
-	systemParts := []string{}
-	for _, msg := range req.Messages {
-		if msg.Role == "system" {
-			if str, ok := msg.Content.(string); ok && str != "" {
-				systemParts = append(systemParts, str)
-			}
-		}
-	}
-	system := strings.Join(systemParts, "\n\n")
-
-	// Get environment info
-	workingDir, _ := config.GetWorkingDir()
-	dateStr := config.GetDateStr()
-	env := config.GetEnvironment()
-	isGitRepo, currentBranch, mainBranch, gitStatus, recentCommits := config.GetGitInfo()
-
+	// Get environment info and build request
 	ccReq := &CommandCodeRequest{
-		Config: CommandCodeConfig{
-			WorkingDir:    workingDir,
-			Date:          dateStr,
-			Environment:   env,
-			Structure:     []string{},
-			IsGitRepo:     isGitRepo,
-			CurrentBranch: currentBranch,
-			MainBranch:    mainBranch,
-			GitStatus:     gitStatus,
-			RecentCommits: recentCommits,
-		},
+		Config:         buildCommandCodeConfig(),
 		Memory:         nil,
 		Taste:          nil,
 		Skills:         "",
@@ -100,6 +80,24 @@ func OpenAIToCommandCode(req *OpenAIRequest) (*CommandCodeRequest, error) {
 	return ccReq, nil
 }
 
+// buildCommandCodeConfig gathers environment metadata for the upstream request.
+// Both OpenAI and Anthropic converters share this identical config block.
+func buildCommandCodeConfig() CommandCodeConfig {
+	workingDir, _ := config.GetWorkingDir()
+	isGitRepo, currentBranch, mainBranch, gitStatus, recentCommits := config.GetGitInfo()
+	return CommandCodeConfig{
+		WorkingDir:    workingDir,
+		Date:          config.GetDateStr(),
+		Environment:   config.GetEnvironment(),
+		Structure:     []string{},
+		IsGitRepo:     isGitRepo,
+		CurrentBranch: currentBranch,
+		MainBranch:    mainBranch,
+		GitStatus:     gitStatus,
+		RecentCommits: recentCommits,
+	}
+}
+
 // defaultMaxTokens returns the upstream default when the OpenAI request omits max_tokens.
 func defaultMaxTokens(maxTokens int) int {
 	if maxTokens <= 0 {
@@ -207,23 +205,8 @@ func AnthropicMessagesToCommandCode(req *AnthropicRequest) (*CommandCodeRequest,
 		ccThinking = req.Thinking
 	}
 
-	workingDir, _ := config.GetWorkingDir()
-	dateStr := config.GetDateStr()
-	env := config.GetEnvironment()
-	isGitRepo, currentBranch, mainBranch, gitStatus, recentCommits := config.GetGitInfo()
-
 	return &CommandCodeRequest{
-		Config: CommandCodeConfig{
-			WorkingDir:    workingDir,
-			Date:          dateStr,
-			Environment:   env,
-			Structure:     []string{},
-			IsGitRepo:     isGitRepo,
-			CurrentBranch: currentBranch,
-			MainBranch:    mainBranch,
-			GitStatus:     gitStatus,
-			RecentCommits: recentCommits,
-		},
+		Config:         buildCommandCodeConfig(),
 		Memory:         nil,
 		Taste:          nil,
 		Skills:         "",
@@ -375,6 +358,8 @@ func BuildAnthropicResponse(model string, fullText string, toolCalls []ToolCall,
 // randomHex generates random hex string
 func randomHex(n int) string {
 	b := make([]byte, n)
-	rand.Read(b)
+	if _, err := rand.Read(b); err != nil {
+		return fmt.Sprintf("%x", time.Now().UnixNano())
+	}
 	return hex.EncodeToString(b)
 }