bingocode 1.0.19 → 1.0.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bingocode",
-  "version": "1.0.19",
+  "version": "1.0.21",
   "type": "module",
   "bin": {
     "claude": "bin/claude-win.cjs",

package/src/manager/CliMenuManager.tsx

@@ -818,7 +818,7 @@ export const CliMenuManager: React.FC = () => {
         <Box flexDirection="column" width={VIEW_W} height={MID_H}>
           {creating && <Text color="yellow">新建中...</Text>}
           {createErr && <Text color="red">新建失败: {createErr}</Text>}
-          {newSessionId && <Text color="green">新建会话（本地Id，仅演示）: {newSessionId}</Text>}
+          {newSessionId && <Text color="green">新建会话: {newSessionId}</Text>}
           {!creating && !createErr && !newSessionId && <Text dimColor>已进入新建会话页，等待创建结果...</Text>}
         </Box>
       );

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)
+}

package/src/server/services/providerService.ts

@@ -409,8 +409,8 @@ export class ProviderService {
     }
 
     try {
-      const fetchOpts = getProxyFetchOptions()
-      const res = await fetch(url, { headers, signal: AbortSignal.timeout(10000), ...fetchOpts })
+      const directOpts = getDirectFetchOptions()
+      const res = await fetch(url, { headers, signal: AbortSignal.timeout(10000), ...directOpts })
       if (!res.ok) {
         console.error(`[ProviderService] Failed to fetch models from ${url}: ${res.status}`)
         return []
@@ -438,11 +438,26 @@ export class ProviderService {
 
     // If no modelId provided, try to fetch from provider or use preset default
     let modelId = overrides?.modelId || provider.models.main
-    if (!modelId || modelId === 'auto' || modelId.startsWith('claude-')) {
-       const fetched = await this.fetchProviderModels(id).catch(() => [])
-       if (fetched.length > 0) {
-         modelId = fetched[0] // Use first available model for testing
-       }
+    const needsAutoDetect =
+      !modelId ||
+      modelId === 'auto' ||
+      (apiFormat !== 'anthropic' && modelId.startsWith('claude-'))
+    if (needsAutoDetect) {
+      const fetched = await this.fetchProviderModels(id).catch(() => [])
+      if (fetched.length > 0) {
+        modelId = fetched[0] // Use first available model for testing
+      }
+    }
+
+    // 兜底：如果仍然没有有效的 modelId，直接返回有意义的错误
+    if (!modelId) {
+      return {
+        connectivity: {
+          success: false,
+          latencyMs: 0,
+          error: '无法确定测试用模型：models.main 为空且自动拉取模型列表失败。请先在槽位配置中选择模型，或检查 API Key 和网络连接。',
+        },
+      }
     }
 
     if (!baseUrl || !provider.apiKey) {
@@ -491,7 +506,6 @@ export class ProviderService {
     const start = Date.now()
     try {
       const { url, headers, body } = buildDirectTestRequest(base, apiKey, modelId, format)
-      // 使用 getDirectFetchOptions 以绕开系统代理，测试直接连接
       const directOpts = getDirectFetchOptions()
       const response = await fetch(url, {
         method: 'POST',
@@ -556,13 +570,13 @@ export class ProviderService {
       }
 
       // Call upstream with transformed request
-      const fetchOpts = getProxyFetchOptions()
+      const directOpts = getDirectFetchOptions()
       const response = await fetch(upstreamUrl, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${apiKey}` },
         body: JSON.stringify(transformedBody),
         signal: AbortSignal.timeout(30000),
-        ...fetchOpts,
+        ...directOpts,
       })
 
       if (!response.ok) {

package/src/utils/proxy.ts

@@ -334,26 +334,14 @@ export function getDirectFetchOptions(): {
     return { ...base, proxy: undefined, ...getTLSFetchOptions() }
   }
 
-  // Check if system proxy exists
-  const proxyUrl = getProxyUrl()
-  if (!proxyUrl) {
-    // No proxy configured, just return normal fetch options
-    return { ...base, ...getTLSFetchOptions() }
-  }
-
   // In Node.js/undici, a fresh Agent with no proxy settings bypasses system defaults
   // eslint-disable-next-line @typescript-eslint/no-require-imports
   const undiciMod = require('undici') as typeof undici
   const tlsOpts = getTLSFetchOptions()
 
-  // Use the global dispatcher's options if possible, or fresh default options
-  const agentOptions = tlsOpts.dispatcher && 'options' in (tlsOpts.dispatcher as any)
-    ? (tlsOpts.dispatcher as any).options
-    : {}
-
   return {
     ...base,
-    dispatcher: new undiciMod.Agent(agentOptions),
+    dispatcher: new undiciMod.Agent(tlsOpts.dispatcher ? (tlsOpts.dispatcher as any).options : {}),
   }
 }
 

package/src/server/proxy/streaming/anthropicStreamLabeler.ts

@@ -1,56 +0,0 @@
-/**
- * Anthropic-to-Anthropic SSE stream labeler.
- *
- * Intercepts an Anthropic Messages API stream and replaces the 'model' field
- * in the 'message_start' event with a custom label.
- */
-
-export function anthropicStreamLabeler(
-  upstream: ReadableStream<Uint8Array>,
-  label: string,
-): ReadableStream<Uint8Array> {
-  const encoder = new TextEncoder()
-  const decoder = new TextDecoder()
-  let buffer = ''
-
-  return new ReadableStream({
-    async start(controller) {
-      const reader = upstream.getReader()
-      try {
-        while (true) {
-          const { done, value } = await reader.read()
-          if (done) break
-
-          buffer += decoder.decode(value, { stream: true })
-          const lines = buffer.split('\n')
-          buffer = lines.pop() || ''
-
-          for (const line of lines) {
-            const trimmed = line.trim()
-            if (!trimmed || !trimmed.startsWith('data: ')) {
-              controller.enqueue(encoder.encode(line + '\n'))
-              continue
-            }
-
-            const jsonStr = trimmed.slice(6)
-            try {
-              const data = JSON.parse(jsonStr)
-              if (data.type === 'message_start' && data.message) {
-                data.message.model = label
-                controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}\n`))
-              } else {
-                controller.enqueue(encoder.encode(line + '\n'))
-              }
-            } catch {
-              controller.enqueue(encoder.encode(line + '\n'))
-            }
-          }
-        }
-      } catch (err) {
-        controller.error(err)
-      } finally {
-        controller.close()
-      }
-    },
-  })
-}