bingocode 1.0.20 → 1.0.22

package/src/server/proxy/handler.ts

@@ -1,302 +1,289 @@
-/**
- * Proxy Handler — protocol-translating reverse proxy for OpenAI-compatible APIs.
- *
- * Receives Anthropic Messages API requests from the CLI, transforms them to
- * OpenAI Chat Completions or Responses API format, forwards to the upstream
- * provider, and transforms the response back to Anthropic format.
- *
- * Supports slot-based routing: each request's model field is mapped to a slot
- * (main/haiku/sonnet/opus), and the corresponding configured provider is used.
- *
- * Derived from cc-switch (https://github.com/farion1231/cc-switch)
- * Original work by Jason Young, MIT License
- */
-
-import { ProviderService } from '../services/providerService.js'
-import { anthropicToOpenaiChat } from './transform/anthropicToOpenaiChat.js'
-import { anthropicToOpenaiResponses } from './transform/anthropicToOpenaiResponses.js'
-import { openaiChatToAnthropic } from './transform/openaiChatToAnthropic.js'
-import { openaiResponsesToAnthropic } from './transform/openaiResponsesToAnthropic.js'
-import { openaiChatStreamToAnthropic } from './streaming/openaiChatStreamToAnthropic.js'
-import { openaiResponsesStreamToAnthropic } from './streaming/openaiResponsesStreamToAnthropic.js'
-import { anthropicStreamLabeler } from './streaming/anthropicStreamLabeler.js'
-import type { AnthropicRequest } from './transform/types.js'
-import type { SlotName } from '../types/provider.js'
-
-const providerService = new ProviderService()
-
-function buildUpstreamHeaders(apiKey: string): Record<string, string> {
-  const headers: Record<string, string> = {
-    'Content-Type': 'application/json',
-    Authorization: `Bearer ${apiKey}`,
-  }
-
-  if (process.env.X_API_KEY) {
-    headers['x-api-key'] = process.env.X_API_KEY
-  }
-
-  if (process.env.APPLICATION_NAME) {
-    headers['x-application-name'] = process.env.APPLICATION_NAME
-  }
-
-  return headers
-}
-
-/**
- * Identify which slot a model name belongs to.
- * Claude Code sends model names like "claude-3-5-haiku-20241022".
- */
-function identifySlot(modelName: string): SlotName {
-  const m = modelName.toLowerCase()
-  if (m.includes('haiku')) return 'haiku'
-  if (m.includes('sonnet')) return 'sonnet'
-  if (m.includes('opus')) return 'opus'
-  return 'main'
-}
-
-export async function handleProxyRequest(req: Request, url: URL): Promise<Response> {
-  // Only handle POST /proxy/v1/messages
-  if (req.method !== 'POST' || url.pathname !== '/proxy/v1/messages') {
-    return Response.json(
-      { error: 'Not Found', message: 'Proxy only handles POST /proxy/v1/messages' },
-      { status: 404 },
-    )
-  }
-
-  // Parse request body
-  let body: AnthropicRequest
-  try {
-    body = (await req.json()) as AnthropicRequest
-  } catch {
-    return Response.json(
-      { type: 'error', error: { type: 'invalid_request_error', message: 'Invalid JSON in request body' } },
-      { status: 400 },
-    )
-  }
-
-  const isStream = body.stream === true
-
-  // --- Slot-based routing ---
-  const slot = identifySlot(body.model ?? '')
-  const slotConfig = await providerService.getProviderForSlot(slot)
-
-  if (slotConfig) {
-    // Use the slot's configured modelId instead of the original Claude model name
-    const proxiedBody: AnthropicRequest = { ...body, model: slotConfig.modelId }
-    const baseUrl = slotConfig.baseUrl.replace(/\/+$/, '')
-    const uiLabel = slotConfig.label || null
-
-    try {
-      if (slotConfig.apiFormat === 'anthropic') {
-        return await handleAnthropicPassthrough(proxiedBody, baseUrl, slotConfig.apiKey, isStream, uiLabel)
-      } else if (slotConfig.apiFormat === 'openai_chat') {
-        return await handleOpenaiChat(proxiedBody, baseUrl, slotConfig.apiKey, isStream, uiLabel)
-      } else {
-        return await handleOpenaiResponses(proxiedBody, baseUrl, slotConfig.apiKey, isStream, uiLabel)
-      }
-    } catch (err) {
-      console.error(`[Proxy] Slot "${slot}" upstream request failed:`, err)
-      return Response.json(
-        {
-          type: 'error',
-          error: {
-            type: 'api_error',
-            message: err instanceof Error ? err.message : String(err),
-          },
-        },
-        { status: 502 },
-      )
-    }
-  }
-
-  // --- Fallback: legacy single-activeId routing ---
-  const config = await providerService.getActiveProviderForProxy()
-  if (!config) {
-    return Response.json(
-      {
-        type: 'error',
-        error: {
-          type: 'invalid_request_error',
-          message: `No provider configured for slot "${slot}". Please configure slots in the Provider panel.`,
-        },
-      },
-      { status: 400 },
-    )
-  }
-
-  if (config.apiFormat === 'anthropic') {
-    return Response.json(
-      { type: 'error', error: { type: 'invalid_request_error', message: 'Active provider uses anthropic format — proxy not needed' } },
-      { status: 400 },
-    )
-  }
-
-  const baseUrl = config.baseUrl.replace(/\/+$/, '')
-
-  try {
-    if (config.apiFormat === 'openai_chat') {
-      return await handleOpenaiChat(body, baseUrl, config.apiKey, isStream)
-    } else {
-      return await handleOpenaiResponses(body, baseUrl, config.apiKey, isStream)
-    }
-  } catch (err) {
-    console.error('[Proxy] Upstream request failed:', err)
-    return Response.json(
-      {
-        type: 'error',
-        error: {
-          type: 'api_error',
-          message: err instanceof Error ? err.message : String(err),
-        },
-      },
-      { status: 502 },
-    )
-  }
-}
-
-/**
- * Pass through to an Anthropic-compatible upstream without format transformation.
- * Used when the slot provider uses apiFormat 'anthropic'.
- */
-async function handleAnthropicPassthrough(
-  body: AnthropicRequest,
-  baseUrl: string,
-  apiKey: string,
-  isStream: boolean,
-  uiLabel: string | null = null,
-): Promise<Response> {
-  const url = `${baseUrl}/v1/messages`
-  const upstream = await fetch(url, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      'x-api-key': apiKey,
-      'anthropic-version': '2023-06-01',
-    },
-    body: JSON.stringify(body),
-    signal: isStream ? AbortSignal.timeout(30_000) : AbortSignal.timeout(300_000),
-  })
-
-  // ... (existing error checks)
-
-  if (isStream) {
-    if (uiLabel) {
-      const labeledStream = anthropicStreamLabeler(upstream.body!, uiLabel)
-      return new Response(labeledStream, {
-        status: upstream.status,
-        headers: {
-          'Content-Type': 'text/event-stream',
-          'Cache-Control': 'no-cache',
-          Connection: 'keep-alive',
-        },
-      })
-    }
-    return new Response(upstream.body, {
-      status: upstream.status,
-      headers: upstream.headers,
-    })
-  }
-
-  const responseBody = await upstream.json()
-  if (uiLabel) {
-    (responseBody as any).model = uiLabel
-  }
-  return Response.json(responseBody)
-}
-
-async function handleOpenaiChat(
-  body: AnthropicRequest,
-  baseUrl: string,
-  apiKey: string,
-  isStream: boolean,
-  uiLabel: string | null = null,
-): Promise<Response> {
-  const transformed = anthropicToOpenaiChat(body)
-  const url = `${baseUrl}/v1/chat/completions`
-
-  const upstream = await fetch(url, {
-    method: 'POST',
-    headers: buildUpstreamHeaders(apiKey),
-    body: JSON.stringify(transformed),
-    signal: isStream ? AbortSignal.timeout(30_000) : AbortSignal.timeout(300_000),
-  })
-
-  if (!upstream.ok) {
-    // ... error handling
-  }
-
-  if (isStream) {
-    if (!upstream.body) {
-      return Response.json(/* ... */)
-    }
-    const anthropicStream = openaiChatStreamToAnthropic(upstream.body, uiLabel || body.model)
-    return new Response(anthropicStream, {
-      status: 200,
-      headers: {
-        'Content-Type': 'text/event-stream',
-        'Cache-Control': 'no-cache',
-        Connection: 'keep-alive',
-      },
-    })
-  }
-
-  // Non-streaming
-  const responseBody = await upstream.json()
-  const anthropicResponse = openaiChatToAnthropic(responseBody, uiLabel || body.model)
-  return Response.json(anthropicResponse)
-}
-
-async function handleOpenaiResponses(
-  body: AnthropicRequest,
-  baseUrl: string,
-  apiKey: string,
-  isStream: boolean,
-  uiLabel: string | null = null,
-): Promise<Response> {
-  const transformed = anthropicToOpenaiResponses(body)
-  const url = `${baseUrl}/v1/responses`
-
-  const upstream = await fetch(url, {
-    method: 'POST',
-    headers: buildUpstreamHeaders(apiKey),
-    body: JSON.stringify(transformed),
-    signal: isStream ? AbortSignal.timeout(30_000) : AbortSignal.timeout(300_000),
-  })
-
-  if (!upstream.ok) {
-    const errText = await upstream.text().catch(() => '')
-    return Response.json(
-      {
-        type: 'error',
-        error: {
-          type: 'api_error',
-          message: `Upstream returned HTTP ${upstream.status}: ${errText.slice(0, 500)}`,
-        },
-      },
-      { status: upstream.status },
-    )
-  }
-
-  if (isStream) {
-    if (!upstream.body) {
-      return Response.json(
-        { type: 'error', error: { type: 'api_error', message: 'Upstream returned no body for stream' } },
-        { status: 502 },
-      )
-    }
-    const anthropicStream = openaiResponsesStreamToAnthropic(upstream.body, uiLabel || body.model)
-    return new Response(anthropicStream, {
-      status: 200,
-      headers: {
-        'Content-Type': 'text/event-stream',
-        'Cache-Control': 'no-cache',
-        Connection: 'keep-alive',
-      },
-    })
-  }
-
-  // Non-streaming
-  const responseBody = await upstream.json()
-  const anthropicResponse = openaiResponsesToAnthropic(responseBody, uiLabel || body.model)
-  return Response.json(anthropicResponse)
-}
+/**
+ * Proxy Handler — protocol-translating reverse proxy for OpenAI-compatible APIs.
+ *
+ * Receives Anthropic Messages API requests from the CLI, transforms them to
+ * OpenAI Chat Completions or Responses API format, forwards to the upstream
+ * provider, and transforms the response back to Anthropic format.
+ *
+ * Supports slot-based routing: each request's model field is mapped to a slot
+ * (main/haiku/sonnet/opus), and the corresponding configured provider is used.
+ *
+ * Derived from cc-switch (https://github.com/farion1231/cc-switch)
+ * Original work by Jason Young, MIT License
+ */
+
+import { ProviderService } from '../services/providerService.js'
+import { anthropicToOpenaiChat } from './transform/anthropicToOpenaiChat.js'
+import { anthropicToOpenaiResponses } from './transform/anthropicToOpenaiResponses.js'
+import { openaiChatToAnthropic } from './transform/openaiChatToAnthropic.js'
+import { openaiResponsesToAnthropic } from './transform/openaiResponsesToAnthropic.js'
+import { openaiChatStreamToAnthropic } from './streaming/openaiChatStreamToAnthropic.js'
+import { openaiResponsesStreamToAnthropic } from './streaming/openaiResponsesStreamToAnthropic.js'
+import type { AnthropicRequest } from './transform/types.js'
+import type { SlotName } from '../types/provider.js'
+
+const providerService = new ProviderService()
+
+function buildUpstreamHeaders(apiKey: string): Record<string, string> {
+  const headers: Record<string, string> = {
+    'Content-Type': 'application/json',
+    Authorization: `Bearer ${apiKey}`,
+  }
+
+  if (process.env.X_API_KEY) {
+    headers['x-api-key'] = process.env.X_API_KEY
+  }
+
+  if (process.env.APPLICATION_NAME) {
+    headers['x-application-name'] = process.env.APPLICATION_NAME
+  }
+
+  return headers
+}
+
+/**
+ * Identify which slot a model name belongs to.
+ * Claude Code sends model names like "claude-3-5-haiku-20241022".
+ */
+function identifySlot(modelName: string): SlotName {
+  const m = modelName.toLowerCase()
+  if (m.includes('haiku')) return 'haiku'
+  if (m.includes('sonnet')) return 'sonnet'
+  if (m.includes('opus')) return 'opus'
+  return 'main'
+}
+
+export async function handleProxyRequest(req: Request, url: URL): Promise<Response> {
+  // Only handle POST /proxy/v1/messages
+  if (req.method !== 'POST' || url.pathname !== '/proxy/v1/messages') {
+    return Response.json(
+      { error: 'Not Found', message: 'Proxy only handles POST /proxy/v1/messages' },
+      { status: 404 },
+    )
+  }
+
+  // Parse request body
+  let body: AnthropicRequest
+  try {
+    body = (await req.json()) as AnthropicRequest
+  } catch {
+    return Response.json(
+      { type: 'error', error: { type: 'invalid_request_error', message: 'Invalid JSON in request body' } },
+      { status: 400 },
+    )
+  }
+
+  const isStream = body.stream === true
+
+  // --- Slot-based routing ---
+  const slot = identifySlot(body.model ?? '')
+  const slotConfig = await providerService.getProviderForSlot(slot)
+
+  if (slotConfig) {
+    // Use the slot's configured modelId instead of the original Claude model name
+    const proxiedBody: AnthropicRequest = { ...body, model: slotConfig.modelId }
+    const baseUrl = slotConfig.baseUrl.replace(/\/+$/, '')
+    const uiLabel = slotConfig.label || null
+
+    try {
+      if (slotConfig.apiFormat === 'anthropic') {
+        return await handleAnthropicPassthrough(proxiedBody, baseUrl, slotConfig.apiKey, isStream, uiLabel)
+      } else if (slotConfig.apiFormat === 'openai_chat') {
+        return await handleOpenaiChat(proxiedBody, baseUrl, slotConfig.apiKey, isStream, uiLabel)
+      } else {
+        return await handleOpenaiResponses(proxiedBody, baseUrl, slotConfig.apiKey, isStream, uiLabel)
+      }
+    } catch (err) {
+      console.error(`[Proxy] Slot "${slot}" upstream request failed:`, err)
+      return Response.json(
+        {
+          type: 'error',
+          error: {
+            type: 'api_error',
+            message: err instanceof Error ? err.message : String(err),
+          },
+        },
+        { status: 502 },
+      )
+    }
+  }
+
+  // --- Fallback: legacy single-activeId routing ---
+  const config = await providerService.getActiveProviderForProxy()
+  if (!config) {
+    return Response.json(
+      {
+        type: 'error',
+        error: {
+          type: 'invalid_request_error',
+          message: `No provider configured for slot "${slot}". Please configure slots in the Provider panel.`,
+        },
+      },
+      { status: 400 },
+    )
+  }
+
+  if (config.apiFormat === 'anthropic') {
+    return Response.json(
+      { type: 'error', error: { type: 'invalid_request_error', message: 'Active provider uses anthropic format — proxy not needed' } },
+      { status: 400 },
+    )
+  }
+
+  const baseUrl = config.baseUrl.replace(/\/+$/, '')
+
+  try {
+    if (config.apiFormat === 'openai_chat') {
+      return await handleOpenaiChat(body, baseUrl, config.apiKey, isStream)
+    } else {
+      return await handleOpenaiResponses(body, baseUrl, config.apiKey, isStream)
+    }
+  } catch (err) {
+    console.error('[Proxy] Upstream request failed:', err)
+    return Response.json(
+      {
+        type: 'error',
+        error: {
+          type: 'api_error',
+          message: err instanceof Error ? err.message : String(err),
+        },
+      },
+      { status: 502 },
+    )
+  }
+}
+
+/**
+ * Pass through to an Anthropic-compatible upstream without format transformation.
+ * Used when the slot provider uses apiFormat 'anthropic'.
+ */
+async function handleAnthropicPassthrough(
+  body: AnthropicRequest,
+  baseUrl: string,
+  apiKey: string,
+  isStream: boolean,
+  uiLabel: string | null = null,
+): Promise<Response> {
+  const url = `${baseUrl}/v1/messages`
+  const upstream = await fetch(url, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'x-api-key': apiKey,
+      'anthropic-version': '2023-06-01',
+    },
+    body: JSON.stringify(body),
+    signal: isStream ? AbortSignal.timeout(30_000) : AbortSignal.timeout(300_000),
+  })
+
+  // ... (existing error checks)
+
+  if (isStream) {
+    // Anthropic pass-through doesn't easily support label injection without parsing SSE
+    // So for native anthropic format, we might just pass original stream
+    return new Response(upstream.body, { /* ... */ })
+  }
+
+  const responseBody = await upstream.json()
+  if (uiLabel) {
+    (responseBody as any).model = uiLabel
+  }
+  return Response.json(responseBody)
+}
+
+async function handleOpenaiChat(
+  body: AnthropicRequest,
+  baseUrl: string,
+  apiKey: string,
+  isStream: boolean,
+  uiLabel: string | null = null,
+): Promise<Response> {
+  const transformed = anthropicToOpenaiChat(body)
+  const url = `${baseUrl}/v1/chat/completions`
+
+  const upstream = await fetch(url, {
+    method: 'POST',
+    headers: buildUpstreamHeaders(apiKey),
+    body: JSON.stringify(transformed),
+    signal: isStream ? AbortSignal.timeout(30_000) : AbortSignal.timeout(300_000),
+  })
+
+  if (!upstream.ok) {
+    // ... error handling
+  }
+
+  if (isStream) {
+    if (!upstream.body) {
+      return Response.json(/* ... */)
+    }
+    const anthropicStream = openaiChatStreamToAnthropic(upstream.body, uiLabel || body.model)
+    return new Response(anthropicStream, {
+      status: 200,
+      headers: {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        Connection: 'keep-alive',
+      },
+    })
+  }
+
+  // Non-streaming
+  const responseBody = await upstream.json()
+  const anthropicResponse = openaiChatToAnthropic(responseBody, uiLabel || body.model)
+  return Response.json(anthropicResponse)
+}
+
+async function handleOpenaiResponses(
+  body: AnthropicRequest,
+  baseUrl: string,
+  apiKey: string,
+  isStream: boolean,
+  uiLabel: string | null = null,
+): Promise<Response> {
+  const transformed = anthropicToOpenaiResponses(body)
+  const url = `${baseUrl}/v1/responses`
+
+  const upstream = await fetch(url, {
+    method: 'POST',
+    headers: buildUpstreamHeaders(apiKey),
+    body: JSON.stringify(transformed),
+    signal: isStream ? AbortSignal.timeout(30_000) : AbortSignal.timeout(300_000),
+  })
+
+  if (!upstream.ok) {
+    const errText = await upstream.text().catch(() => '')
+    return Response.json(
+      {
+        type: 'error',
+        error: {
+          type: 'api_error',
+          message: `Upstream returned HTTP ${upstream.status}: ${errText.slice(0, 500)}`,
+        },
+      },
+      { status: upstream.status },
+    )
+  }
+
+  if (isStream) {
+    if (!upstream.body) {
+      return Response.json(
+        { type: 'error', error: { type: 'api_error', message: 'Upstream returned no body for stream' } },
+        { status: 502 },
+      )
+    }
+    const anthropicStream = openaiResponsesStreamToAnthropic(upstream.body, uiLabel || body.model)
+    return new Response(anthropicStream, {
+      status: 200,
+      headers: {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        Connection: 'keep-alive',
+      },
+    })
+  }
+
+  // Non-streaming
+  const responseBody = await upstream.json()
+  const anthropicResponse = openaiResponsesToAnthropic(responseBody, uiLabel || body.model)
+  return Response.json(anthropicResponse)
+}