bingocode 1.0.38 → 1.0.41

package/package.json

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

package/src/manager/CliMenuManager.tsx

@@ -980,7 +980,7 @@ export const CliMenuManager: React.FC = () => {
             </Box>
 
             {/* ── 消息区 ── */}
-            <Box height={MSGS_H} flexDirection="column" overflow="hidden">
+            <Box height={MSGS_H} flexDirection="column">
               {loadingMsgs && <Text color="yellow">加载消息中...</Text>}
               {msgsErr && <Text color="red">错误: {msgsErr}</Text>}
               {!loadingMsgs && !msgsErr && displayMsgs.length === 0 && (
@@ -1024,11 +1024,16 @@ export const CliMenuManager: React.FC = () => {
                 setHistoryMenuStage('window');
               }
             }}
-            itemComponent={({ isSelected, label, color, isGroup }) => (
-              <Text color={isGroup ? 'gray' : (color ? color : (isSelected ? 'cyan' : undefined))}>
-                {label}
-              </Text>
-            )}
+            itemComponent={({ isSelected, label }) => {
+              const it = groupedHistoryItems.find(i => i.label === label);
+              const isGroup = it?.isGroup;
+              const color = it?.color;
+              return (
+                <Text color={isGroup ? 'gray' : (color ? color : (isSelected ? 'cyan' : undefined))}>
+                  {label}
+                </Text>
+              )
+            }}
           />
           <Hint>{i18nMap[lang].historyHint}</Hint>
         </Box>

package/src/server/proxy/handler.ts

@@ -21,9 +21,28 @@ import { openaiChatStreamToAnthropic } from './streaming/openaiChatStreamToAnthr
 import { openaiResponsesStreamToAnthropic } from './streaming/openaiResponsesStreamToAnthropic.js'
 import type { AnthropicRequest } from './transform/types.js'
 import type { SlotName } from '../types/provider.js'
+import { logForDebugging } from '../../utils/debug.js'
+import { appendFile, mkdir } from 'node:fs/promises'
+import { join } from 'node:path'
+import { homedir } from 'node:os'
 
 const providerService = new ProviderService()
 
+async function logToFile(message: string) {
+  // Disabled log output for production
+}
+
+function sendAnthropicError(message: string, _model: string | undefined, status = 502): Response {
+  const fullMessage = `[Bingo Proxy] ${message}`
+  void logToFile(`ERROR: ${fullMessage} (status: ${status})`)
+
+  // 统一返回纯文本以规避 CLI 的 JSON 字符串打印行为，确保报错清晰且不带 JSON 外壳
+  return new Response(fullMessage, {
+    status: status,
+    headers: { 'Content-Type': 'text/plain' }
+  })
+}
+
 function buildUpstreamHeaders(apiKey: string): Record<string, string> {
   const headers: Record<string, string> = {
     'Content-Type': 'application/json',
@@ -43,23 +62,41 @@ function buildUpstreamHeaders(apiKey: string): Record<string, string> {
 
 /**
  * Identify which slot a model name belongs to.
- * Claude Code sends model names like "claude-3-5-haiku-20241022".
+ * Checks for exact matches in provider models first, then falls back to keyword matching.
  */
-function identifySlot(modelName: string): SlotName {
+async function identifySlot(modelName: string): Promise<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'
+  void logToFile(`Identifying slot. Input: "${modelName}"`)
+
+  try {
+    const { providers } = await providerService.listProviders()
+    for (const config of providers) {
+      if (config.models) {
+        for (const [slot, id] of Object.entries(config.models)) {
+          if (id && id.toLowerCase() === m) {
+            void logToFile(`Match found in config! Slot: ${slot} (ID: ${id})`)
+            return slot as SlotName
+          }
+        }
+      }
+    }
+  } catch (e) {
+    void logToFile(`Error reading providers for identification: ${e}`)
+  }
+
+  let result: SlotName = 'main'
+  if (m.includes('opus')) result = 'opus'
+  else if (m.includes('sonnet')) result = 'sonnet'
+  else if (m.includes('haiku')) result = 'haiku'
+
+  void logToFile(`Fallback identification result: ${result}`)
+  return result
 }
 
 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 },
-    )
+    return sendAnthropicError('Not Found: Proxy only handles POST /proxy/v1/messages', undefined, 404)
   }
 
   // Parse request body
@@ -67,20 +104,19 @@ export async function handleProxyRequest(req: Request, url: URL): Promise<Respon
   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 },
-    )
+    return sendAnthropicError('Invalid JSON in request body', undefined, 400)
   }
 
   const isStream = body.stream === true
 
   // --- Slot-based routing ---
-  const slot = identifySlot(body.model ?? '')
+  const slot = await identifySlot(body.model ?? '')
+  const reqId = Math.random().toString(36).substring(7)
+  void logToFile(`[${reqId}] Body Model: "${body.model}". Decided Slot: "${slot}"`)
+
   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
@@ -94,40 +130,20 @@ export async function handleProxyRequest(req: Request, url: URL): Promise<Respon
         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 },
-      )
+      logForDebugging(`[HANDLER][${reqId}] Slot "${slot}" upstream connection failed: ${err}`, { level: 'error' })
+      return sendAnthropicError(`API Connection Failed: Ensure baseUrl is correct. Error: ${err instanceof Error ? err.message : String(err)}`, body.model, 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 },
-    )
+    logForDebugging(`[HANDLER][${reqId}] No provider configured for slot "${slot}"`, { level: 'warn' })
+    return sendAnthropicError(`No provider configured for slot "${slot}". Please configure slots in the Provider panel.`, body.model)
   }
 
   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 },
-    )
+    return sendAnthropicError('Active provider uses anthropic format — proxy not needed', body.model)
   }
 
   const baseUrl = config.baseUrl.replace(/\/+$/, '')
@@ -139,17 +155,8 @@ export async function handleProxyRequest(req: Request, url: URL): Promise<Respon
       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 },
-    )
+    logForDebugging(`[HANDLER][${reqId}] Upstream connection failed: ${err}`, { level: 'error' })
+    return sendAnthropicError(`API Connection Failed: Ensure baseUrl is correct. Error: ${err instanceof Error ? err.message : String(err)}`, body.model, 502)
   }
 }
 
@@ -176,12 +183,22 @@ async function handleAnthropicPassthrough(
     signal: isStream ? AbortSignal.timeout(30_000) : AbortSignal.timeout(300_000),
   })
 
-  // ... (existing error checks)
+  if (!upstream.ok) {
+    const errText = await upstream.text().catch(() => '')
+    const errorMessage = `Upstream returned HTTP ${upstream.status}: ${errText.slice(0, 500)}`
+    return sendAnthropicError(errorMessage, body.model, 502)
+  }
 
   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, { /* ... */ })
+    if (!upstream.body) {
+      return sendAnthropicError('Upstream returned no body for stream', body.model)
+    }
+    return new Response(upstream.body, {
+      status: 200,
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    })
   }
 
   const responseBody = await upstream.json()
@@ -209,12 +226,21 @@ async function handleOpenaiChat(
   })
 
   if (!upstream.ok) {
-    // ... error handling
+    const errText = await upstream.text().catch(() => '')
+    let errorMessage = `Upstream returned HTTP ${upstream.status}: ${errText.slice(0, 500)}`
+    let status = upstream.status
+
+    if (upstream.status === 404) {
+      status = 502
+      errorMessage = `API Connection Failed: The baseUrl path might be incorrect (404 Not Found). Detail: ${errText}`
+    }
+
+    return sendAnthropicError(errorMessage, body.model, status)
   }
 
   if (isStream) {
     if (!upstream.body) {
-      return Response.json(/* ... */)
+      return sendAnthropicError('Upstream returned no body for stream', body.model)
     }
     const anthropicStream = openaiChatStreamToAnthropic(upstream.body, uiLabel || body.model)
     return new Response(anthropicStream, {
@@ -252,24 +278,20 @@ async function handleOpenaiResponses(
 
   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 },
-    )
+    let errorMessage = `Upstream returned HTTP ${upstream.status}: ${errText.slice(0, 500)}`
+    let status = upstream.status
+
+    if (upstream.status === 404) {
+      status = 502
+      errorMessage = `API Connection Failed: The baseUrl path might be incorrect (404 Not Found). Detail: ${errText}`
+    }
+
+    return sendAnthropicError(errorMessage, body.model, status)
   }
 
   if (isStream) {
     if (!upstream.body) {
-      return Response.json(
-        { type: 'error', error: { type: 'api_error', message: 'Upstream returned no body for stream' } },
-        { status: 502 },
-      )
+      return sendAnthropicError('Upstream returned no body for stream', body.model)
     }
     const anthropicStream = openaiResponsesStreamToAnthropic(upstream.body, uiLabel || body.model)
     return new Response(anthropicStream, {

package/src/server/proxy/transform/anthropicToOpenaiChat.ts

@@ -33,7 +33,7 @@ export function anthropicToOpenaiChat(body: AnthropicRequest): OpenAIChatRequest
 
   // Convert messages
   for (const msg of body.messages) {
-    convertMessage(msg, messages)
+    convertMessage(msg, messages, body.model)
   }
 
   // Build request
@@ -90,7 +90,7 @@ export function anthropicToOpenaiChat(body: AnthropicRequest): OpenAIChatRequest
   return result
 }
 
-function convertMessage(msg: AnthropicMessage, output: OpenAIChatMessage[]): void {
+function convertMessage(msg: AnthropicMessage, output: OpenAIChatMessage[], model: string = ''): void {
   const content = msg.content
 
   // Simple string content
@@ -108,7 +108,7 @@ function convertMessage(msg: AnthropicMessage, output: OpenAIChatMessage[]): voi
   if (msg.role === 'user') {
     convertUserMessage(content, output)
   } else {
-    convertAssistantMessage(content, output)
+    convertAssistantMessage(content, output, model)
   }
 }
 
@@ -147,13 +147,16 @@ function convertUserMessage(blocks: AnthropicContentBlock[], output: OpenAIChatM
   }
 }
 
-function convertAssistantMessage(blocks: AnthropicContentBlock[], output: OpenAIChatMessage[]): void {
+function convertAssistantMessage(blocks: AnthropicContentBlock[], output: OpenAIChatMessage[], model: string = ''): void {
   let textContent = ''
+  let reasoningContent = ''
   const toolCalls: OpenAIToolCall[] = []
 
   for (const block of blocks) {
     if (block.type === 'text') {
       textContent += block.text
+    } else if (block.type === 'thinking') {
+      reasoningContent += block.thinking
     } else if (block.type === 'tool_use') {
       toolCalls.push({
         id: block.id,
@@ -164,7 +167,6 @@ function convertAssistantMessage(blocks: AnthropicContentBlock[], output: OpenAI
         },
       })
     }
-    // Skip thinking blocks — no OpenAI equivalent
   }
 
   const msg: OpenAIChatMessage = {
@@ -172,6 +174,11 @@ function convertAssistantMessage(blocks: AnthropicContentBlock[], output: OpenAI
     content: textContent || null,
   }
 
+  // Only pass reasoning_content back for DeepSeek models to satisfy their mandatory back-transmission rule
+  if (reasoningContent && model.toLowerCase().includes('deepseek')) {
+    (msg as any).reasoning_content = reasoningContent
+  }
+
   if (toolCalls.length > 0) {
     msg.tool_calls = toolCalls
   }