bingocode 1.0.0 → 1.0.1

package/src/server/proxy/handler.ts

@@ -1,206 +1,319 @@
-/**
- * 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.
- *
- * 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'
-
-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
-}
-
-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 },
-    )
-  }
-
-  // Read active provider config
-  const config = await providerService.getActiveProviderForProxy()
-  if (!config) {
-    return Response.json(
-      { type: 'error', error: { type: 'invalid_request_error', message: 'No active provider configured for proxy' } },
-      { 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 },
-    )
-  }
-
-  // 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
-  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 },
-    )
-  }
-}
-
-async function handleOpenaiChat(
-  body: AnthropicRequest,
-  baseUrl: string,
-  apiKey: string,
-  isStream: boolean,
-): 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) {
-    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 = openaiChatStreamToAnthropic(upstream.body, 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, body.model)
-  return Response.json(anthropicResponse)
-}
-
-async function handleOpenaiResponses(
-  body: AnthropicRequest,
-  baseUrl: string,
-  apiKey: string,
-  isStream: boolean,
-): 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, 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, 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(/\/+$/, '')
+
+    try {
+      if (slotConfig.apiFormat === 'anthropic') {
+        return await handleAnthropicPassthrough(proxiedBody, baseUrl, slotConfig.apiKey, isStream)
+      } else if (slotConfig.apiFormat === 'openai_chat') {
+        return await handleOpenaiChat(proxiedBody, baseUrl, slotConfig.apiKey, isStream)
+      } else {
+        return await handleOpenaiResponses(proxiedBody, baseUrl, slotConfig.apiKey, isStream)
+      }
+    } 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,
+): 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),
+  })
+
+  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 },
+      )
+    }
+    // Pass through Anthropic SSE stream directly
+    return new Response(upstream.body, {
+      status: 200,
+      headers: {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        Connection: 'keep-alive',
+      },
+    })
+  }
+
+  const responseBody = await upstream.json()
+  return Response.json(responseBody)
+}
+
+async function handleOpenaiChat(
+  body: AnthropicRequest,
+  baseUrl: string,
+  apiKey: string,
+  isStream: boolean,
+): 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) {
+    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 = openaiChatStreamToAnthropic(upstream.body, 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, body.model)
+  return Response.json(anthropicResponse)
+}
+
+async function handleOpenaiResponses(
+  body: AnthropicRequest,
+  baseUrl: string,
+  apiKey: string,
+  isStream: boolean,
+): 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, 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, body.model)
+  return Response.json(anthropicResponse)
+}

package/src/server/services/providerService.ts

@@ -24,7 +24,11 @@ import type {
   ProviderTestResult,
   ProviderTestStepResult,
   ApiFormat,
+  SlotName,
+  SlotEntry,
+  SlotTable,
 } from '../types/provider.ts'
+import { SlotTableSchema } from '../types/provider.ts'
 
 const MANAGED_ENV_KEYS = [
   'ANTHROPIC_BASE_URL',
@@ -63,6 +67,10 @@ export class ProviderService {
     return path.join(this.getCcHahaDir(), 'settings.json')
   }
 
+  private getSlotsPath(): string {
+    return path.join(this.getCcHahaDir(), 'slots.json')
+  }
+
   private async readIndex(): Promise<ProvidersIndex> {
     try {
       const raw = await fs.readFile(this.getIndexPath(), 'utf-8')
@@ -141,6 +149,7 @@ export class ProviderService {
       apiFormat: input.apiFormat ?? 'anthropic',
       models: input.models,
       ...(input.notes !== undefined && { notes: input.notes }),
+      ...(input.extra !== undefined && { extra: input.extra }),
     }
 
     index.providers.push(provider)
@@ -162,6 +171,7 @@ export class ProviderService {
       ...(input.apiFormat !== undefined && { apiFormat: input.apiFormat }),
       ...(input.models !== undefined && { models: input.models }),
       ...(input.notes !== undefined && { notes: input.notes }),
+      ...(input.extra !== undefined && { extra: input.extra }),
     }
 
     index.providers[idx] = updated
@@ -313,6 +323,90 @@ export class ProviderService {
     }
   }
 
+  // --- Slot routing ---
+
+  async readSlots(): Promise<SlotTable> {
+    try {
+      const raw = await fs.readFile(this.getSlotsPath(), 'utf-8')
+      return SlotTableSchema.parse(JSON.parse(raw))
+    } catch (err: unknown) {
+      if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
+        return SlotTableSchema.parse({})
+      }
+      throw ApiError.internal(`Failed to read slots: ${err}`)
+    }
+  }
+
+  async writeSlots(slots: SlotTable): Promise<void> {
+    const filePath = this.getSlotsPath()
+    await fs.mkdir(path.dirname(filePath), { recursive: true })
+    const tmp = `${filePath}.tmp.${Date.now()}`
+    try {
+      await fs.writeFile(tmp, JSON.stringify(slots, null, 2) + '\n', 'utf-8')
+      await fs.rename(tmp, filePath)
+    } catch (err) {
+      await fs.unlink(tmp).catch(() => {})
+      throw ApiError.internal(`Failed to write slots: ${err}`)
+    }
+  }
+
+  async setSlot(slot: SlotName, entry: SlotEntry): Promise<SlotTable> {
+    const slots = await this.readSlots()
+    slots[slot] = entry
+    await this.writeSlots(slots)
+    return slots
+  }
+
+  async getProviderForSlot(slotName: SlotName): Promise<{
+    baseUrl: string
+    apiKey: string
+    apiFormat: ApiFormat
+    modelId: string
+  } | null> {
+    const slots = await this.readSlots()
+    const entry = slots[slotName]
+    if (!entry) return null
+    const index = await this.readIndex()
+    const provider = index.providers.find((p) => p.id === entry.providerId)
+    if (!provider) return null
+    return {
+      baseUrl: provider.baseUrl,
+      apiKey: provider.apiKey,
+      apiFormat: provider.apiFormat ?? 'anthropic',
+      modelId: entry.modelId,
+    }
+  }
+
+  async fetchProviderModels(id: string): Promise<string[]> {
+    const provider = await this.getProvider(id)
+    const base = provider.baseUrl.replace(/\/+$/, '')
+    if (!base) return []
+
+    const url = `${base}/v1/models`
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${provider.apiKey}`,
+    }
+    // anthropic format uses x-api-key header style
+    if (provider.apiFormat === 'anthropic') {
+      headers['x-api-key'] = provider.apiKey
+      delete headers['Authorization']
+      headers['anthropic-version'] = '2023-06-01'
+    }
+
+    try {
+      const res = await fetch(url, { headers, signal: AbortSignal.timeout(10000) })
+      if (!res.ok) {
+        return []
+      }
+      const data = await res.json() as { data?: { id: string }[]; models?: { id: string }[] }
+      const list = data.data ?? data.models ?? []
+      return list.map((m: { id: string }) => m.id).filter(Boolean)
+    } catch {
+      return []
+    }
+  }
+
   // --- Test ---
 
   async testProvider(