bingocode 1.0.20 → 1.0.21

package/package.json

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

package/src/entrypoints/init.ts

@@ -1,4 +1,3 @@
-import { mkdirSync } from 'node:fs'
 import { profileCheckpoint } from '../utils/startupProfiler.js'
 import '../bootstrap/state.js'
 import '../utils/config.js'
@@ -26,7 +25,7 @@ import { logForDebugging } from '../utils/debug.js'
 import { detectCurrentRepository } from '../utils/detectRepository.js'
 import { logForDiagnosticsNoPII } from '../utils/diagLogs.js'
 import { initJetBrainsDetection } from '../utils/envDynamic.js'
-import { getClaudeConfigHomeDir, isEnvTruthy } from '../utils/envUtils.js'
+import { isEnvTruthy } from '../utils/envUtils.js'
 import { ConfigParseError, errorMessage } from '../utils/errors.js'
 // showInvalidConfigDialog is dynamically imported in the error path to avoid loading React at init
 import {
@@ -56,13 +55,6 @@ import { setShellIfWindows } from '../utils/windowsPaths.js'
 let telemetryInitialized = false
 
 export const init = memoize(async (): Promise<void> => {
-  // Ensure config directory exists for first-time use
-  try {
-    mkdirSync(getClaudeConfigHomeDir(), { recursive: true });
-  } catch (e) {
-    // Ignore error if it already exists
-  }
-
   const initStartTime = Date.now()
   logForDiagnosticsNoPII('info', 'init_started')
   profileCheckpoint('init_function_start')

package/src/server/cli/providerManager.ts

@@ -121,13 +121,14 @@ export class ProviderManager {
     }
   }
 
-  // 预设列表
+  // 预设列表（可选，providerPresets 不存在则返回空）
   static async listPresets(): Promise<any[]> {
     try {
-      const { loadProviderPresets } = await import('../config/providerPresets.ts');
-      return await loadProviderPresets();
-    } catch (e) {
-      console.error('Failed to load presets:', e);
+      // 相对 src/server/cli 到 config 的路径
+      const mod = await import('../config/providerPresets.ts');
+      const presets = (mod as any).presets || (mod as any).providerPresets || [];
+      return presets;
+    } catch {
       return [];
     }
   }
@@ -144,83 +145,33 @@ export class ProviderManager {
       baseUrl: overrides?.baseUrl ?? p.baseUrl ?? '',
       apiFormat: overrides?.apiFormat ?? p.apiFormat ?? 'openai_chat',
       models: overrides?.models ?? { main: p.defaultModel || '', haiku: '', sonnet: '', opus: '' },
-      notes: overrides?.notes ?? p.notes ?? '',
-      extra: { ...p, ...overrides?.extra }
+      notes: overrides?.notes ?? p.notes ?? ''
     };
   }
 
-  // 获取模型列表
-  static async fetchModels(target: SavedProvider | any, apiKeyOverride?: string): Promise<string[]> {
-    const p = target;
-    const apiKey = apiKeyOverride || p.apiKey;
-    const baseUrl = (p.baseUrl || '').replace(/\/+$/, '');
-    const modelsUrl = p.modelsUrl || p.extra?.modelsUrl;
-    const modelsDataPath = p.modelsDataPath || p.extra?.modelsDataPath || 'data';
-    const authStyle = p.modelsAuthStyle || p.extra?.modelsAuthStyle || 'bearer';
-
-    if (!modelsUrl) return [];
-
-    const url = modelsUrl.startsWith('http') ? modelsUrl : (baseUrl + modelsUrl);
-
-    try {
-      const headers: any = {};
-      if (apiKey) {
-        if (authStyle === 'bearer') {
-          headers['Authorization'] = `Bearer ${apiKey}`;
-        } else if (authStyle === 'x-api-key') {
-          headers['x-api-key'] = apiKey;
-          headers['anthropic-version'] = '2023-06-01';
-        }
-      }
-
-      const res = await axios.get(url, { headers, timeout: 5000 });
-      const data = res.data;
-      const list = modelsDataPath.split('.').reduce((acc: any, part: string) => acc && acc[part], data);
-
-      if (Array.isArray(list)) {
-        return list.map((m: any) => typeof m === 'string' ? m : (m.id || m.name)).filter(Boolean);
-      }
-      return [];
-    } catch (e) {
-      console.error('Failed to fetch models:', e);
-      return [];
-    }
-  }
-
-  // 连通性测试：优先使用配置的 modelsUrl
+  // 连通性测试：按 apiFormat 选择探测路径
   static async testProvider(target: SavedProvider | string): Promise<{ ok: boolean; latencyMs?: number; message?: string }> {
     const p = typeof target === 'string' ? await this.getProvider(target) : target;
     if (!p) return { ok: false, message: 'Provider not found' };
-
-    const baseUrl = (p.baseUrl || '').replace(/\/+$/, '');
-    const modelsUrl = p.modelsUrl || p.extra?.modelsUrl || (p.apiFormat?.includes('openai') ? '/v1/models' : '/v1/models');
-    const authStyle = p.modelsAuthStyle || p.extra?.modelsAuthStyle || 'bearer';
-    const apiKey = p.apiKey;
-
-    const url = modelsUrl.startsWith('http') ? modelsUrl : (baseUrl + modelsUrl);
+    const base = (p.baseUrl || '').replace(/\/+$/,'');
     const start = Date.now();
-
+    // 简单路径推断
+    let url = base;
+    if ((p.apiFormat || '').includes('openai')) url = base + '/v1/models';
+    else if ((p.apiFormat || '').includes('anthropic')) url = base + '/v1/models';
     try {
-      const headers: any = {};
-      if (apiKey) {
-        if (authStyle === 'bearer') {
-          headers['Authorization'] = `Bearer ${apiKey}`;
-        } else if (authStyle === 'x-api-key') {
-          headers['x-api-key'] = apiKey;
-          headers['anthropic-version'] = '2023-06-01';
-        }
-      }
-
       const res = await axios.get(url, {
         timeout: 8000,
-        headers,
+        headers: {
+          ...(p.apiKey ? { Authorization: `Bearer ${p.apiKey}` } : {}),
+        },
         validateStatus: () => true
       });
-
+      // 2xx/3xx 都视为连通
       if (res.status >= 200 && res.status < 400) {
         return { ok: true, latencyMs: Date.now() - start };
       }
-      return { ok: false, message: `HTTP ${res.status}: ${JSON.stringify(res.data)}` };
+      return { ok: false, message: `HTTP ${res.status}` };
     } catch (e: any) {
       return { ok: false, message: e?.message || 'network error' };
     }

package/src/server/cli/providersMenu.tsx

@@ -30,9 +30,8 @@ const FIXED_APIFMT = 'openai_chat';
 
 const ProvidersMenu: React.FC = () => {
   const { exit } = useApp();
-  const [modelOptions, setModelOptions] = useState<string[]>([]);
   const [modelSelectIdx, setModelSelectIdx] = useState(0);
-  const [addStep, setAddStep] = useState(0); // 0:输入key并加载模型, 1:选模型
+  const [addStep, setAddStep] = useState(0); // 0:选模型, 1:填key
   const [inputKey, setInputKey] = useState('');
   const [addError, setAddError] = useState('');
   const [mode, setMode] = useState<UiMode>('list');
@@ -45,9 +44,6 @@ const ProvidersMenu: React.FC = () => {
   const [msg, setMsg] = useState<string>('');
   const [detail, setDetail] = useState<SavedProvider | null>(null);
   const [presets, setPresets] = useState<any[]>([]);
-  // 临时存储当前正在配置的 Provider 草案
-  const [pendingProvider, setPendingProvider] = useState<CreateProviderInput | null>(null);
-
   useEffect(() => { ProviderManager.listPresets().then(setPresets).catch(()=>setPresets([])); }, []);
 
   const refresh = async () => {
@@ -58,14 +54,7 @@ const ProvidersMenu: React.FC = () => {
   };
   useEffect(() => { refresh(); }, []);
   useEffect(() => {
-    if (mode !== 'add') {
-      setAddStep(0);
-      setInputKey('');
-      setAddError('');
-      setModelSelectIdx(0);
-      setModelOptions([]);
-      setPendingProvider(null);
-    }
+    if (mode !== 'add') { setAddStep(0); setInputKey(''); setAddError(''); setModelSelectIdx(0); }
   }, [mode]);
 
   // 主界面 LIST 模式
@@ -107,55 +96,33 @@ const ProvidersMenu: React.FC = () => {
       setMode('list'); setAddError(''); setInputKey(''); setAddStep(0);
       return;
     }
-    // 步骤1: 选模型
-    if (addStep === 1 && modelOptions.length > 0) {
-      if (key.downArrow) setModelSelectIdx(idx => Math.min(modelOptions.length - 1, idx + 1));
+    // 步骤0: 主模型选择
+    if (addStep === 0) {
+      if (key.downArrow) setModelSelectIdx(idx => Math.min(MODEL_OPTIONS.length - 1, idx + 1));
       else if (key.upArrow) setModelSelectIdx(idx => Math.max(0, idx - 1));
-      else if (key.return) {
-        completeAdd(modelOptions[modelSelectIdx]);
-      }
+      else if (key.return) { setAddStep(1); }
     }
   });
 
-  // 获取模型并进入下一步
-  const fetchModelsStep = async (keyInput: string) => {
+  // 新增表单
+  const addSubmit = async (keyInput: string) => {
+    const selectedModel = MODEL_OPTIONS[modelSelectIdx];
+    const presetId = selectedModel.replace(/[^a-zA-Z0-9]/g, '') + '-preset';
+    const name = `${selectedModel} Provider`;
     if (!keyInput.trim()) { setAddError('API Key 不能为空'); return; }
-    setAddError('正在获取模型列表...');
-    try {
-      // 如果没有 pendingProvider，手动创建一个（比如 Custom 模式）
-      const draft = pendingProvider || {
-        presetId: 'custom-' + Date.now(),
-        name: 'Custom Provider',
-        baseUrl: FIXED_BASEURL,
-        apiFormat: FIXED_APIFMT,
-        apiKey: keyInput.trim(),
-        models: { main: '', haiku: '', sonnet: '', opus: '' }
-      };
-
-      const models = await ProviderManager.fetchModels(draft, keyInput.trim());
-      if (models.length === 0) {
-        setAddError('未获取到可用模型，请检查 API Key 或网络连通性。');
-        return;
-      }
-      setModelOptions(models);
-      setPendingProvider({ ...draft, apiKey: keyInput.trim() });
-      setAddStep(1);
-      setAddError('');
-    } catch (e: any) {
-      setAddError('获取模型失败: ' + (e.message || '未知错误'));
-    }
-  };
-
-  const completeAdd = async (selectedModel: string) => {
-    if (!pendingProvider) return;
-    const name = pendingProvider.name || `${selectedModel} Provider`;
-
+    const exists = (await ProviderManager.listProviders()).some(p => p.id === presetId);
+    if (exists) { setAddError('该模型已添加过，如要更换Key请在列表编辑。'); return; }
+    setAddError('');
+    // 支持预设覆盖
+    const overrideBase = (global as any).__PM_BASEURL_OVERRIDE__ || FIXED_BASEURL;
+    const overrideFmt = (global as any).__PM_APIFMT_OVERRIDE__ || FIXED_APIFMT;
     await ProviderManager.addProvider({
-      ...pendingProvider,
-      name,
+      presetId, name, apiKey: keyInput.trim(),
+      baseUrl: overrideBase, apiFormat: overrideFmt,
       models: { main: selectedModel, haiku: '', sonnet: '', opus: '' }
     });
-
+    delete (global as any).__PM_BASEURL_OVERRIDE__;
+    delete (global as any).__PM_APIFMT_OVERRIDE__;
     setMode('list');
     setAddStep(0);
     setInputKey('');
@@ -186,25 +153,25 @@ const ProvidersMenu: React.FC = () => {
       {/* 新增 */}
       {mode === 'add' && (
         <Box flexDirection="column">
+          <Text>选择模型与输入API Key：</Text>
           {addStep === 0
             ? <>
-                <Text>请输入 API Key (将自动拉取可用模型)：</Text>
+                {MODEL_OPTIONS.map((m, idx) => (
+                  <Text key={m} color={idx === modelSelectIdx ? 'yellow' : undefined}>
+                    {idx === modelSelectIdx ? '> ' : '  '}{m}
+                  </Text>
+                ))}
+                <Text color="gray">↑↓选择，回车下一步，q返回</Text>
+              </>
+            : <>
+                <Text>已选模型：{MODEL_OPTIONS[modelSelectIdx]}</Text>
                 <TextInput
                   value={inputKey}
                   onChange={setInputKey}
-                  onSubmit={fetchModelsStep}
+                  onSubmit={addSubmit}
                   placeholder="请输入API Key"
                 />
-                <Text color="gray">输入后回车继续，q返回</Text>
-              </>
-            : <>
-                <Text>获取成功！请选择主模型：</Text>
-                {modelOptions.map((m, idx) => (
-                  <Text key={m} color={idx === modelSelectIdx ? 'yellow' : undefined}>
-                    {idx === modelSelectIdx ? '> ' : '  '}{m}
-                  </Text>
-                ))}
-                <Text color="gray">↑↓选择，回车保存，q返回</Text>
+                <Text color="gray">输入后回车提交，q返回</Text>
               </>
           }
           {addError && <Text color="red">{addError}</Text>}
@@ -292,14 +259,17 @@ const ProvidersMenu: React.FC = () => {
               <SelectInput
                 items={presets.map((p: any) => ({ label: `${p.name || p.id} ${p.baseUrl || ''}`, value: p.id }))}
                 onSelect={async it => {
-                  try {
-                    const draft = await ProviderManager.applyPreset(it.value);
-                    setPendingProvider(draft);
-                    setMode('add');
-                    setAddStep(0); // 去输入 Key
-                  } catch (e: any) {
-                    setMsg('预设加载失败: ' + e.message);
-                  }
+                  const p = presets.find((x: any) => x.id === it.value);
+                  if (!p) return;
+                  const model = (p.defaultModel || MODEL_OPTIONS[0]);
+                  const presetBase = p.baseUrl || FIXED_BASEURL;
+                  const presetFmt = p.apiFormat || FIXED_APIFMT;
+                  const idx = Math.max(0, MODEL_OPTIONS.findIndex(m => m === model));
+                  setModelSelectIdx(idx);
+                  (global as any).__PM_BASEURL_OVERRIDE__ = presetBase;
+                  (global as any).__PM_APIFMT_OVERRIDE__ = presetFmt;
+                  setMode('add');
+                  setAddStep(1); // 直接跳到 Key 输入
                 }}
               />
               <Text color="gray">回车选择预设，q 返回</Text>

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/config.ts

@@ -1344,17 +1344,11 @@ export function enableConfigs(): void {
   // to prevent us from adding config reading during module initialization
   configReadingAllowed = true
   // We only check the global config because currently all the configs share a file
-  try {
-    getConfig(
-      getGlobalClaudeFile(),
-      createDefaultGlobalConfig,
-      true /* throw on invalid */,
-    )
-  } catch (e) {
-    logForDebugging(`Failed to load config during enableConfigs: ${e}`, { level: 'error' })
-    // If it's a corrupted file, we allow the boostrap to continue with defaults
-    // instead of hard-crashing the process.
-  }
+  getConfig(
+    getGlobalClaudeFile(),
+    createDefaultGlobalConfig,
+    true /* throw on invalid */,
+  )
 
   logForDiagnosticsNoPII('info', 'enable_configs_completed', {
     duration_ms: Date.now() - startTime,

package/src/utils/preflightChecks.tsx

@@ -202,7 +202,7 @@ export function PreflightStep(t0) {
 
 //@C:ID=F.PC._temp;K=F;V=1.0;P=Helper function for process exit;D=UI;M=Connectivity;S=Utility;In=void;Out=void
 function _temp() {
-  console.log("F.PC._temp: Skipping force exit on connectivity failure.");
-
-  // return process.exit(1);
+  console.log("F.PC._temp");
+  
+  return process.exit(1);
 }

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()
-      }
-    },
-  })
-}