free-coding-models 0.2.17 → 0.3.1

package/src/proxy-server.js

@@ -21,6 +21,17 @@ import { classifyError } from './error-classifier.js'
 import { applyThinkingBudget, compressContext } from './request-transformer.js'
 import { TokenStats } from './token-stats.js'
 import { createHash } from 'node:crypto'
+import {
+  translateAnthropicToOpenAI,
+  translateOpenAIToAnthropic,
+  createAnthropicSSETransformer,
+  estimateAnthropicTokens,
+} from './anthropic-translator.js'
+import {
+  translateResponsesToOpenAI,
+  translateOpenAIToResponses,
+  createResponsesSSETransformer,
+} from './responses-translator.js'
 
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 
@@ -51,16 +62,31 @@ function stripRateLimitHeaders(headers) {
   return result
 }
 
+// 📖 Max body size limit to prevent memory exhaustion attacks (10 MB)
+const MAX_BODY_SIZE = 10 * 1024 * 1024
+
 /**
  * Buffer all chunks from an http.IncomingMessage and return the body as a string.
+ * Enforces a size limit to prevent memory exhaustion from oversized payloads.
  *
  * @param {http.IncomingMessage} req
  * @returns {Promise<string>}
+ * @throws {Error} with statusCode 413 if body exceeds MAX_BODY_SIZE
  */
 function readBody(req) {
   return new Promise((resolve, reject) => {
     const chunks = []
-    req.on('data', chunk => chunks.push(chunk))
+    let totalSize = 0
+    req.on('data', chunk => {
+      totalSize += chunk.length
+      if (totalSize > MAX_BODY_SIZE) {
+        req.destroy()
+        const err = new Error('Request body too large')
+        err.statusCode = 413
+        return reject(err)
+      }
+      chunks.push(chunk)
+    })
     req.on('end', () => resolve(Buffer.concat(chunks).toString()))
     req.on('error', reject)
   })
@@ -114,8 +140,13 @@ export class ProxyServer {
     this._proxyApiKey = proxyApiKey
     this._accounts = accounts
     this._upstreamTimeoutMs = upstreamTimeoutMs
+    // 📖 Progressive backoff delays (ms) for retries — first attempt is immediate,
+    // subsequent ones add increasing delay + random jitter (0-100ms) to avoid
+    // re-hitting the same rate-limit window on 429s from providers
+    this._retryDelays = [0, 300, 800]
     this._accountManager = new AccountManager(accounts, accountManagerOpts)
     this._tokenStats = new TokenStats(tokenStatsOpts)
+    this._startTime = Date.now()
     this._running = false
     this._listeningPort = null
     this._server = http.createServer((req, res) => this._handleRequest(req, res))
@@ -173,17 +204,50 @@ export class ProxyServer {
   // ── Request routing ────────────────────────────────────────────────────────
 
   _handleRequest(req, res) {
+    // 📖 Health endpoint is unauthenticated so external monitors can probe it
+    if (req.method === 'GET' && req.url === '/v1/health') {
+      return this._handleHealth(res)
+    }
+
     if (!this._isAuthorized(req)) {
       return sendJson(res, 401, { error: 'Unauthorized' })
     }
 
     if (req.method === 'GET' && req.url === '/v1/models') {
       this._handleModels(res)
+    } else if (req.method === 'GET' && req.url === '/v1/stats') {
+      this._handleStats(res)
     } else if (req.method === 'POST' && req.url === '/v1/chat/completions') {
       this._handleChatCompletions(req, res).catch(err => {
-        sendJson(res, 500, { error: 'Internal server error', message: err.message })
+        console.error('[proxy] Internal error:', err)
+        // 📖 Return 413 for body-too-large, generic 500 for everything else — never leak stack traces
+        const status = err.statusCode === 413 ? 413 : 500
+        const msg = err.statusCode === 413 ? 'Request body too large' : 'Internal server error'
+        sendJson(res, status, { error: msg })
+      })
+    } else if (req.method === 'POST' && req.url === '/v1/messages') {
+      // 📖 Anthropic Messages API translation — enables Claude Code compatibility
+      this._handleAnthropicMessages(req, res).catch(err => {
+        console.error('[proxy] Internal error:', err)
+        const status = err.statusCode === 413 ? 413 : 500
+        const msg = err.statusCode === 413 ? 'Request body too large' : 'Internal server error'
+        sendJson(res, status, { error: msg })
       })
-    } else if (req.method === 'POST' && (req.url === '/v1/completions' || req.url === '/v1/responses')) {
+    } else if (req.method === 'POST' && req.url === '/v1/messages/count_tokens') {
+      this._handleAnthropicCountTokens(req, res).catch(err => {
+        console.error('[proxy] Internal error:', err)
+        const status = err.statusCode === 413 ? 413 : 500
+        const msg = err.statusCode === 413 ? 'Request body too large' : 'Internal server error'
+        sendJson(res, status, { error: msg })
+      })
+    } else if (req.method === 'POST' && req.url === '/v1/responses') {
+      this._handleResponses(req, res).catch(err => {
+        console.error('[proxy] Internal error:', err)
+        const status = err.statusCode === 413 ? 413 : 500
+        const msg = err.statusCode === 413 ? 'Request body too large' : 'Internal server error'
+        sendJson(res, status, { error: msg })
+      })
+    } else if (req.method === 'POST' && req.url === '/v1/completions') {
       // These legacy/alternative OpenAI endpoints are not supported by the proxy.
       // Return 501 (not 404) so callers get a clear signal instead of silently failing.
       sendJson(res, 501, {
@@ -200,19 +264,24 @@ export class ProxyServer {
   _handleModels(res) {
     const seen = new Set()
     const data = []
+    const models = []
     for (const acct of this._accounts) {
       const publicModelId = acct.proxyModelId || acct.modelId
       if (!seen.has(publicModelId)) {
         seen.add(publicModelId)
-        data.push({
+        const modelEntry = {
           id: publicModelId,
+          slug: publicModelId,
+          name: publicModelId,
           object: 'model',
           created: Math.floor(Date.now() / 1000),
           owned_by: 'proxy',
-        })
+        }
+        data.push(modelEntry)
+        models.push(modelEntry)
       }
     }
-    sendJson(res, 200, { object: 'list', data })
+    sendJson(res, 200, { object: 'list', data, models })
   }
 
   // ── POST /v1/chat/completions ──────────────────────────────────────────────
@@ -273,10 +342,14 @@ export class ProxyServer {
       }
     }
 
-    // 5. Retry loop
+    // 5. Retry loop with progressive backoff
     let pendingSwitchReason = null
     let previousAccount = null
     for (let attempt = 0; attempt < this._retries; attempt++) {
+      // 📖 Apply backoff delay before retries (first attempt is immediate)
+      const delay = this._retryDelays[Math.min(attempt, this._retryDelays.length - 1)]
+      if (delay > 0) await new Promise(r => setTimeout(r, delay + Math.random() * 100))
+
       // First attempt: respect sticky session.
       // Subsequent retries: fresh P2C (don't hammer the same failed account).
       const selectOpts = attempt === 0
@@ -354,7 +427,13 @@ export class ProxyServer {
 
       // Build the full upstream URL from the account's base URL
       const baseUrl = account.url.replace(/\/$/, '')
-      const upstreamUrl = new URL(baseUrl + '/chat/completions')
+      let upstreamUrl
+      try {
+        upstreamUrl = new URL(baseUrl + '/chat/completions')
+      } catch {
+        // 📖 Malformed upstream URL — resolve as network error so retry loop can continue
+        return resolve({ done: false, statusCode: 0, responseBody: 'Invalid upstream URL', networkError: true })
+      }
 
       // Choose http or https module BEFORE creating the request
       const client = selectClient(account.url)
@@ -390,10 +469,14 @@ export class ProxyServer {
 
             // Tap the data stream to capture usage from the last data line.
             // Register BEFORE pipe() so both listeners share the same event queue.
+            // 📖 sseLineBuffer persists between chunks to handle lines split across boundaries
             let lastChunkData = ''
+            let sseLineBuffer = ''
             upstreamRes.on('data', chunk => {
-              const text = chunk.toString()
-              const lines = text.split('\n')
+              sseLineBuffer += chunk.toString()
+              const lines = sseLineBuffer.split('\n')
+              // 📖 Last element may be an incomplete line — keep it for next chunk
+              sseLineBuffer = lines.pop() || ''
               for (const line of lines) {
                 if (line.startsWith('data: ') && !line.includes('[DONE]')) {
                   lastChunkData = line.slice(6).trim()
@@ -433,6 +516,10 @@ export class ProxyServer {
               this._persistQuotaSnapshot(account, quotaUpdated)
             })
 
+            // 📖 Error handlers on both sides of the pipe to prevent uncaught errors
+            upstreamRes.on('error', err => { if (!clientRes.destroyed) clientRes.destroy(err) })
+            clientRes.on('error', () => { if (!upstreamRes.destroyed) upstreamRes.destroy() })
+
             // Pipe after listeners are registered; upstream → client, no buffering
             upstreamRes.pipe(clientRes)
 
@@ -590,4 +677,653 @@ export class ProxyServer {
       ...(account.modelId !== undefined && { modelId: account.modelId }),
     })
   }
+
+  // ── GET /v1/health ──────────────────────────────────────────────────────────
+
+  /**
+   * 📖 Health endpoint for daemon liveness checks. Unauthenticated so external
+   * monitors (TUI, launchctl, systemd) can probe without needing the token.
+   */
+  _handleHealth(res) {
+    const status = this.getStatus()
+    sendJson(res, 200, {
+      status: 'ok',
+      uptime: process.uptime(),
+      port: status.port,
+      accountCount: status.accountCount,
+      running: status.running,
+    })
+  }
+
+  // ── GET /v1/stats ──────────────────────────────────────────────────────────
+
+  /**
+   * 📖 Authenticated stats endpoint — returns per-account health, token stats summary,
+   * and proxy uptime. Useful for monitoring and debugging.
+   */
+  _handleStats(res) {
+    const healthByAccount = this._accountManager.getAllHealth()
+    const summary = this._tokenStats.getSummary()
+
+    // 📖 Compute totals from the summary data
+    const dailyEntries = Object.values(summary.daily || {})
+    const totalRequests = dailyEntries.reduce((sum, d) => sum + (d.requests || 0), 0)
+    const totalTokens = dailyEntries.reduce((sum, d) => sum + (d.tokens || 0), 0)
+
+    sendJson(res, 200, {
+      accounts: healthByAccount,
+      tokenStats: {
+        byModel: summary.byModel || {},
+        recentRequests: summary.recentRequests || [],
+      },
+      totals: {
+        requests: totalRequests,
+        tokens: totalTokens,
+      },
+      uptime: Math.floor((Date.now() - this._startTime) / 1000),
+    })
+  }
+
+  // ── POST /v1/messages (Anthropic translation) ──────────────────────────────
+
+  /**
+   * 📖 Handle Anthropic Messages API requests by translating to OpenAI format,
+   * forwarding through the existing chat completions handler, then translating
+   * the response back to Anthropic format.
+   *
+   * 📖 This makes Claude Code work natively through the FCM proxy.
+   */
+  async _handleAnthropicMessages(clientReq, clientRes) {
+    const rawBody = await readBody(clientReq)
+    let anthropicBody
+    try {
+      anthropicBody = JSON.parse(rawBody)
+    } catch {
+      return sendJson(clientRes, 400, { error: { type: 'invalid_request_error', message: 'Invalid JSON body' } })
+    }
+
+    // 📖 Translate Anthropic → OpenAI
+    const openaiBody = translateAnthropicToOpenAI(anthropicBody)
+    const isStreaming = openaiBody.stream === true
+
+    if (isStreaming) {
+      // 📖 Streaming mode: pipe through SSE transformer
+      await this._handleAnthropicMessagesStreaming(openaiBody, anthropicBody.model, clientRes)
+    } else {
+      // 📖 JSON mode: forward, translate response, return
+      await this._handleAnthropicMessagesJson(openaiBody, anthropicBody.model, clientRes)
+    }
+  }
+
+  /**
+   * 📖 Count tokens for Anthropic Messages requests without calling upstream.
+   * 📖 Claude Code uses this endpoint for budgeting / UI hints, so a fast local
+   * 📖 estimate is enough to keep the flow working through the proxy.
+   */
+  async _handleAnthropicCountTokens(clientReq, clientRes) {
+    const rawBody = await readBody(clientReq)
+    let anthropicBody
+    try {
+      anthropicBody = JSON.parse(rawBody)
+    } catch {
+      return sendJson(clientRes, 400, { error: { type: 'invalid_request_error', message: 'Invalid JSON body' } })
+    }
+
+    sendJson(clientRes, 200, {
+      input_tokens: estimateAnthropicTokens(anthropicBody),
+    })
+  }
+
+  /**
+   * 📖 Handle OpenAI Responses API requests by translating them to chat
+   * 📖 completions, forwarding through the existing proxy path, then converting
+   * 📖 the result back to the Responses wire format.
+   */
+  async _handleResponses(clientReq, clientRes) {
+    const rawBody = await readBody(clientReq)
+    let responsesBody
+    try {
+      responsesBody = JSON.parse(rawBody)
+    } catch {
+      return sendJson(clientRes, 400, { error: 'Invalid JSON body' })
+    }
+
+    const isStreaming = responsesBody.stream === true || String(clientReq.headers.accept || '').includes('text/event-stream')
+    const openaiBody = translateResponsesToOpenAI({ ...responsesBody, stream: isStreaming })
+
+    if (isStreaming) {
+      await this._handleResponsesStreaming(openaiBody, responsesBody.model, clientRes)
+    } else {
+      await this._handleResponsesJson(openaiBody, responsesBody.model, clientRes)
+    }
+  }
+
+  async _handleResponsesJson(openaiBody, requestModel, clientRes) {
+    const capturedChunks = []
+    let capturedStatusCode = 200
+    let capturedHeaders = {}
+
+    const fakeRes = {
+      headersSent: false,
+      destroyed: false,
+      socket: null,
+      writeHead(statusCode, headers) {
+        capturedStatusCode = statusCode
+        capturedHeaders = headers || {}
+        this.headersSent = true
+      },
+      write(chunk) { capturedChunks.push(chunk) },
+      end(data) {
+        if (data) capturedChunks.push(data)
+      },
+      on() { return this },
+      once() { return this },
+      emit() { return false },
+      destroy() { this.destroyed = true },
+      removeListener() { return this },
+    }
+
+    await this._handleChatCompletionsInternal(openaiBody, fakeRes)
+
+    const responseBody = capturedChunks.join('')
+    if (capturedStatusCode >= 200 && capturedStatusCode < 300) {
+      try {
+        const openaiResponse = JSON.parse(responseBody)
+        const responsesResponse = translateOpenAIToResponses(openaiResponse, requestModel)
+        sendJson(clientRes, 200, responsesResponse)
+      } catch {
+        sendJson(clientRes, capturedStatusCode, responseBody)
+      }
+      return
+    }
+
+    // 📖 Forward upstream-style JSON errors unchanged for OpenAI-compatible clients.
+    sendJson(clientRes, capturedStatusCode, responseBody)
+  }
+
+  async _handleResponsesStreaming(openaiBody, requestModel, clientRes) {
+    const { transform } = createResponsesSSETransformer(requestModel)
+    await this._handleResponsesStreamDirect(openaiBody, clientRes, transform)
+  }
+
+  async _handleResponsesStreamDirect(openaiBody, clientRes, sseTransform) {
+    const fingerprint = createHash('sha256')
+      .update(JSON.stringify(openaiBody.messages?.slice(-1) ?? []))
+      .digest('hex')
+      .slice(0, 16)
+
+    const requestedModel = typeof openaiBody.model === 'string'
+      ? openaiBody.model.replace(/^fcm-proxy\//, '')
+      : undefined
+
+    if (requestedModel && !this._accountManager.hasAccountsForModel(requestedModel)) {
+      return sendJson(clientRes, 404, {
+        error: 'Model not found',
+        message: `Model '${requestedModel}' is not available.`,
+      })
+    }
+
+    sseTransform.pipe(clientRes)
+
+    for (let attempt = 0; attempt < this._retries; attempt++) {
+      const delay = this._retryDelays[Math.min(attempt, this._retryDelays.length - 1)]
+      if (delay > 0) await new Promise(r => setTimeout(r, delay + Math.random() * 100))
+
+      const selectOpts = attempt === 0
+        ? { sessionFingerprint: fingerprint, requestedModel }
+        : { requestedModel }
+      const account = this._accountManager.selectAccount(selectOpts)
+      if (!account) break
+
+      const result = await this._forwardRequestForResponsesStream(account, openaiBody, sseTransform, clientRes)
+      if (result.done) return
+
+      const { statusCode, responseBody, responseHeaders, networkError } = result
+      const classified = classifyError(
+        networkError ? 0 : statusCode,
+        responseBody || '',
+        responseHeaders || {}
+      )
+      this._accountManager.recordFailure(account.id, classified, { providerKey: account.providerKey })
+      if (!classified.shouldRetry) {
+        sseTransform.end()
+        return sendJson(clientRes, statusCode || 500, responseBody || JSON.stringify({ error: 'Upstream error' }))
+      }
+    }
+
+    sseTransform.end()
+    sendJson(clientRes, 503, { error: 'All accounts exhausted or unavailable' })
+  }
+
+  /**
+   * 📖 Handle non-streaming Anthropic Messages by internally dispatching to
+   * chat completions logic and translating the JSON response back.
+   */
+  async _handleAnthropicMessagesJson(openaiBody, requestModel, clientRes) {
+    // 📖 Create a fake request/response pair to capture the OpenAI response
+    const capturedChunks = []
+    let capturedStatusCode = 200
+    let capturedHeaders = {}
+
+    const fakeRes = {
+      headersSent: false,
+      destroyed: false,
+      socket: null,
+      writeHead(statusCode, headers) {
+        capturedStatusCode = statusCode
+        capturedHeaders = headers || {}
+        this.headersSent = true
+      },
+      write(chunk) { capturedChunks.push(chunk) },
+      end(data) {
+        if (data) capturedChunks.push(data)
+      },
+      on() { return this },
+      once() { return this },
+      emit() { return false },
+      destroy() { this.destroyed = true },
+      removeListener() { return this },
+    }
+
+    // 📖 Build a fake IncomingMessage-like with pre-parsed body
+    const fakeReq = {
+      method: 'POST',
+      url: '/v1/chat/completions',
+      headers: { 'content-type': 'application/json' },
+      on(event, cb) {
+        if (event === 'data') cb(Buffer.from(JSON.stringify(openaiBody)))
+        if (event === 'end') cb()
+        return this
+      },
+      removeListener() { return this },
+    }
+
+    // 📖 Use internal handler directly instead of fake request
+    await this._handleChatCompletionsInternal(openaiBody, fakeRes)
+
+    const responseBody = capturedChunks.join('')
+
+    if (capturedStatusCode >= 200 && capturedStatusCode < 300) {
+      try {
+        const openaiResponse = JSON.parse(responseBody)
+        const anthropicResponse = translateOpenAIToAnthropic(openaiResponse, requestModel)
+        sendJson(clientRes, 200, anthropicResponse)
+      } catch {
+        // 📖 Couldn't parse — forward raw
+        sendJson(clientRes, capturedStatusCode, responseBody)
+      }
+    } else {
+      // 📖 Error — wrap in Anthropic error format
+      sendJson(clientRes, capturedStatusCode, {
+        type: 'error',
+        error: { type: 'api_error', message: responseBody },
+      })
+    }
+  }
+
+  /**
+   * 📖 Handle streaming Anthropic Messages by forwarding as streaming OpenAI
+   * chat completions and piping through the SSE translator.
+   */
+  async _handleAnthropicMessagesStreaming(openaiBody, requestModel, clientRes) {
+    // 📖 We need to intercept the SSE response and translate it
+    const { transform, getUsage } = createAnthropicSSETransformer(requestModel)
+
+    let resolveForward
+    const forwardPromise = new Promise(r => { resolveForward = r })
+
+    const fakeRes = {
+      headersSent: false,
+      destroyed: false,
+      socket: null,
+      writeHead(statusCode, headers) {
+        this.headersSent = true
+        if (statusCode >= 200 && statusCode < 300) {
+          // 📖 Write Anthropic SSE headers
+          clientRes.writeHead(200, {
+            'content-type': 'text/event-stream',
+            'cache-control': 'no-cache',
+            'connection': 'keep-alive',
+          })
+        } else {
+          clientRes.writeHead(statusCode, headers)
+        }
+      },
+      write(chunk) { /* SSE data handled via pipe */ },
+      end(data) {
+        if (data && !this.headersSent) {
+          // 📖 Non-streaming error response
+          clientRes.end(data)
+        }
+        resolveForward()
+      },
+      on() { return this },
+      once() { return this },
+      emit() { return false },
+      destroy() { this.destroyed = true },
+      removeListener() { return this },
+    }
+
+    // 📖 Actually we need to pipe the upstream SSE through our transformer.
+    // 📖 The simplest approach: use _handleChatCompletionsInternal with stream=true
+    // 📖 and capture the piped response through our transformer.
+
+    // 📖 For streaming, we go lower level — use the retry loop directly
+    await this._handleAnthropicStreamDirect(openaiBody, requestModel, clientRes, transform)
+  }
+
+  /**
+   * 📖 Direct streaming handler for Anthropic messages.
+   * 📖 Runs the retry loop, pipes upstream SSE through the Anthropic transformer.
+   */
+  async _handleAnthropicStreamDirect(openaiBody, requestModel, clientRes, sseTransform) {
+    const { createHash: _createHash } = await import('node:crypto')
+    const fingerprint = _createHash('sha256')
+      .update(JSON.stringify(openaiBody.messages?.slice(-1) ?? []))
+      .digest('hex')
+      .slice(0, 16)
+
+    const requestedModel = typeof openaiBody.model === 'string'
+      ? openaiBody.model.replace(/^fcm-proxy\//, '')
+      : undefined
+
+    if (requestedModel && !this._accountManager.hasAccountsForModel(requestedModel)) {
+      return sendJson(clientRes, 404, {
+        type: 'error',
+        error: { type: 'not_found_error', message: `Model '${requestedModel}' is not available.` },
+      })
+    }
+
+    // 📖 Pipe the transform to client
+    sseTransform.pipe(clientRes)
+
+    for (let attempt = 0; attempt < this._retries; attempt++) {
+      // 📖 Progressive backoff for retries (same as chat completions)
+      const delay = this._retryDelays[Math.min(attempt, this._retryDelays.length - 1)]
+      if (delay > 0) await new Promise(r => setTimeout(r, delay + Math.random() * 100))
+
+      const selectOpts = attempt === 0
+        ? { sessionFingerprint: fingerprint, requestedModel }
+        : { requestedModel }
+      const account = this._accountManager.selectAccount(selectOpts)
+      if (!account) break
+
+      const result = await this._forwardRequestForAnthropicStream(account, openaiBody, sseTransform, clientRes)
+
+      if (result.done) return
+
+      const { statusCode, responseBody, responseHeaders, networkError } = result
+      const classified = classifyError(
+        networkError ? 0 : statusCode,
+        responseBody || '',
+        responseHeaders || {}
+      )
+      this._accountManager.recordFailure(account.id, classified, { providerKey: account.providerKey })
+      if (!classified.shouldRetry) {
+        sseTransform.end()
+        return sendJson(clientRes, statusCode || 500, {
+          type: 'error',
+          error: { type: 'api_error', message: responseBody || 'Upstream error' },
+        })
+      }
+    }
+
+    sseTransform.end()
+    sendJson(clientRes, 503, {
+      type: 'error',
+      error: { type: 'overloaded_error', message: 'All accounts exhausted or unavailable' },
+    })
+  }
+
+  /**
+   * 📖 Forward a streaming request to upstream and pipe SSE through transform.
+   */
+  _forwardRequestForAnthropicStream(account, body, sseTransform, clientRes) {
+    return new Promise(resolve => {
+      const newBody = { ...body, model: account.modelId, stream: true }
+      const bodyStr = JSON.stringify(newBody)
+      const baseUrl = account.url.replace(/\/$/, '')
+      let upstreamUrl
+      try {
+        upstreamUrl = new URL(baseUrl + '/chat/completions')
+      } catch {
+        return resolve({ done: false, statusCode: 0, responseBody: 'Invalid upstream URL', networkError: true })
+      }
+      const client = selectClient(account.url)
+      const startTime = Date.now()
+
+      const requestOptions = {
+        hostname: upstreamUrl.hostname,
+        port: upstreamUrl.port || (upstreamUrl.protocol === 'https:' ? 443 : 80),
+        path: upstreamUrl.pathname + (upstreamUrl.search || ''),
+        method: 'POST',
+        headers: {
+          'authorization': `Bearer ${account.apiKey}`,
+          'content-type': 'application/json',
+          'content-length': Buffer.byteLength(bodyStr),
+        },
+      }
+
+      const upstreamReq = client.request(requestOptions, upstreamRes => {
+        const { statusCode } = upstreamRes
+
+        if (statusCode >= 200 && statusCode < 300) {
+          // 📖 Write Anthropic SSE headers if not already sent
+          if (!clientRes.headersSent) {
+            clientRes.writeHead(200, {
+              'content-type': 'text/event-stream',
+              'cache-control': 'no-cache',
+            })
+          }
+
+          // 📖 Error handlers on both sides of the pipe to prevent uncaught errors
+          upstreamRes.on('error', err => { if (!clientRes.destroyed) clientRes.destroy(err) })
+          clientRes.on('error', () => { if (!upstreamRes.destroyed) upstreamRes.destroy() })
+
+          // 📖 Pipe upstream SSE through Anthropic translator
+          upstreamRes.pipe(sseTransform, { end: true })
+
+          upstreamRes.on('end', () => {
+            this._accountManager.recordSuccess(account.id, Date.now() - startTime)
+          })
+
+          clientRes.on('close', () => {
+            if (!upstreamRes.destroyed) upstreamRes.destroy()
+            if (!upstreamReq.destroyed) upstreamReq.destroy()
+          })
+
+          resolve({ done: true })
+        } else {
+          const chunks = []
+          upstreamRes.on('data', chunk => chunks.push(chunk))
+          upstreamRes.on('end', () => {
+            resolve({
+              done: false,
+              statusCode,
+              responseBody: Buffer.concat(chunks).toString(),
+              responseHeaders: upstreamRes.headers,
+              networkError: false,
+            })
+          })
+        }
+      })
+
+      upstreamReq.on('error', err => {
+        resolve({
+          done: false,
+          statusCode: 0,
+          responseBody: err.message,
+          responseHeaders: {},
+          networkError: true,
+        })
+      })
+
+      upstreamReq.setTimeout(this._upstreamTimeoutMs, () => {
+        upstreamReq.destroy(new Error(`Upstream request timed out after ${this._upstreamTimeoutMs}ms`))
+      })
+
+      upstreamReq.write(bodyStr)
+      upstreamReq.end()
+    })
+  }
+
+  /**
+   * 📖 Forward a streaming chat-completions request and translate the upstream
+   * 📖 SSE stream into Responses API events on the fly.
+   */
+  _forwardRequestForResponsesStream(account, body, sseTransform, clientRes) {
+    return new Promise(resolve => {
+      const newBody = { ...body, model: account.modelId, stream: true }
+      const bodyStr = JSON.stringify(newBody)
+      const baseUrl = account.url.replace(/\/$/, '')
+      let upstreamUrl
+      try {
+        upstreamUrl = new URL(baseUrl + '/chat/completions')
+      } catch {
+        return resolve({ done: false, statusCode: 0, responseBody: 'Invalid upstream URL', networkError: true })
+      }
+
+      const client = selectClient(account.url)
+      const startTime = Date.now()
+      const requestOptions = {
+        hostname: upstreamUrl.hostname,
+        port: upstreamUrl.port || (upstreamUrl.protocol === 'https:' ? 443 : 80),
+        path: upstreamUrl.pathname + (upstreamUrl.search || ''),
+        method: 'POST',
+        headers: {
+          'authorization': `Bearer ${account.apiKey}`,
+          'content-type': 'application/json',
+          'content-length': Buffer.byteLength(bodyStr),
+        },
+      }
+
+      const upstreamReq = client.request(requestOptions, upstreamRes => {
+        const { statusCode } = upstreamRes
+
+        if (statusCode >= 200 && statusCode < 300) {
+          if (!clientRes.headersSent) {
+            clientRes.writeHead(200, {
+              'content-type': 'text/event-stream',
+              'cache-control': 'no-cache',
+            })
+          }
+
+          upstreamRes.on('error', err => { if (!clientRes.destroyed) clientRes.destroy(err) })
+          clientRes.on('error', () => { if (!upstreamRes.destroyed) upstreamRes.destroy() })
+
+          upstreamRes.pipe(sseTransform, { end: true })
+          upstreamRes.on('end', () => {
+            this._accountManager.recordSuccess(account.id, Date.now() - startTime)
+          })
+
+          clientRes.on('close', () => {
+            if (!upstreamRes.destroyed) upstreamRes.destroy()
+            if (!upstreamReq.destroyed) upstreamReq.destroy()
+          })
+
+          resolve({ done: true })
+        } else {
+          const chunks = []
+          upstreamRes.on('data', chunk => chunks.push(chunk))
+          upstreamRes.on('end', () => {
+            resolve({
+              done: false,
+              statusCode,
+              responseBody: Buffer.concat(chunks).toString(),
+              responseHeaders: upstreamRes.headers,
+              networkError: false,
+            })
+          })
+        }
+      })
+
+      upstreamReq.on('error', err => {
+        resolve({
+          done: false,
+          statusCode: 0,
+          responseBody: err.message,
+          responseHeaders: {},
+          networkError: true,
+        })
+      })
+
+      upstreamReq.setTimeout(this._upstreamTimeoutMs, () => {
+        upstreamReq.destroy(new Error(`Upstream request timed out after ${this._upstreamTimeoutMs}ms`))
+      })
+
+      upstreamReq.write(bodyStr)
+      upstreamReq.end()
+    })
+  }
+
+  /**
+   * 📖 Internal version of chat completions handler that takes a pre-parsed body.
+   * 📖 Used by the Anthropic JSON translation path to avoid re-parsing.
+   */
+  async _handleChatCompletionsInternal(body, clientRes) {
+    // 📖 Reuse the exact same logic as _handleChatCompletions but with pre-parsed body
+    if (this._compressionOpts && Array.isArray(body.messages)) {
+      body = { ...body, messages: compressContext(body.messages, this._compressionOpts) }
+    }
+    if (this._thinkingConfig) {
+      body = applyThinkingBudget(body, this._thinkingConfig)
+    }
+
+    const fingerprint = createHash('sha256')
+      .update(JSON.stringify(body.messages?.slice(-1) ?? []))
+      .digest('hex')
+      .slice(0, 16)
+
+    const requestedModel = typeof body.model === 'string'
+      ? body.model.replace(/^fcm-proxy\//, '')
+      : undefined
+
+    if (requestedModel && !this._accountManager.hasAccountsForModel(requestedModel)) {
+      return sendJson(clientRes, 404, {
+        error: 'Model not found',
+        message: `Model '${requestedModel}' is not available.`,
+      })
+    }
+
+    for (let attempt = 0; attempt < this._retries; attempt++) {
+      const delay = this._retryDelays[Math.min(attempt, this._retryDelays.length - 1)]
+      if (delay > 0) await new Promise(r => setTimeout(r, delay + Math.random() * 100))
+
+      const selectOpts = attempt === 0
+        ? { sessionFingerprint: fingerprint, requestedModel }
+        : { requestedModel }
+      const account = this._accountManager.selectAccount(selectOpts)
+      if (!account) break
+
+      const result = await this._forwardRequest(account, body, clientRes, { requestedModel })
+      if (result.done) return
+
+      const { statusCode, responseBody, responseHeaders, networkError } = result
+      const classified = classifyError(
+        networkError ? 0 : statusCode,
+        responseBody || '',
+        responseHeaders || {}
+      )
+      this._accountManager.recordFailure(account.id, classified, { providerKey: account.providerKey })
+      if (!classified.shouldRetry) {
+        return sendJson(clientRes, statusCode || 500, responseBody || JSON.stringify({ error: 'Upstream error' }))
+      }
+    }
+
+    sendJson(clientRes, 503, { error: 'All accounts exhausted or unavailable' })
+  }
+
+  // ── Hot-reload accounts ─────────────────────────────────────────────────────
+
+  /**
+   * 📖 Atomically swap the account list and rebuild the AccountManager.
+   * 📖 Used by the daemon when config changes (new API keys, providers toggled).
+   * 📖 In-flight requests on old accounts will finish naturally.
+   *
+   * @param {Array} accounts — new account list
+   */
+  updateAccounts(accounts) {
+    this._accounts = accounts
+    this._accountManager = new AccountManager(accounts, {})
+  }
 }