bingocode 1.0.25 → 1.0.27

package/package.json

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

package/src/server/services/providerService.ts

@@ -263,6 +263,103 @@ export class ProviderService {
     await this.writeSettings(settings)
   }
 
+  /**
+   * Sync settings.json based on the current slot table.
+   *
+   * Examines all configured slots to determine whether the CLI should connect
+   * through the local proxy or directly. If ANY slot uses a non-anthropic format
+   * (openai_chat, openai_responses), the proxy is required and settings.json is
+   * written with:
+   *   - ANTHROPIC_BASE_URL → http://127.0.0.1:{port}/proxy
+   *   - ANTHROPIC_AUTH_TOKEN → "proxy-managed"
+   *
+   * Model env vars (ANTHROPIC_MODEL, ANTHROPIC_DEFAULT_*_MODEL) are populated
+   * from the slot table so the CLI requests the correct model names, which the
+   * proxy's identifySlot() then routes to the right provider.
+   *
+   * If ALL configured slots use native anthropic format, we write the main
+   * slot's provider info directly (no proxy needed).
+   *
+   * If no slots are configured at all, settings.json is left unchanged.
+   */
+  private async syncSettingsForSlots(slots: SlotTable): Promise<void> {
+    const index = await this.readIndex()
+
+    // Collect resolved slot info
+    type ResolvedSlot = { slot: SlotName; provider: SavedProvider; modelId: string; label?: string | null }
+    const resolved: ResolvedSlot[] = []
+    for (const slotName of ['main', 'haiku', 'sonnet', 'opus'] as const) {
+      const entry = slots[slotName]
+      if (!entry) continue
+      const provider = index.providers.find((p) => p.id === entry.providerId)
+      if (!provider) continue
+      resolved.push({ slot: slotName, provider, modelId: entry.modelId, label: entry.label })
+    }
+
+    // No slots configured at all — don't touch settings.json
+    if (resolved.length === 0) return
+
+    const needsProxy = resolved.some(
+      (r) => r.provider.apiFormat != null && r.provider.apiFormat !== 'anthropic',
+    )
+
+    const settings = await this.readSettings()
+    const existingEnv = (settings.env as Record<string, string>) || {}
+
+    // Build model env vars from slot table.
+    //
+    // The proxy's identifySlot() routes requests by looking for keywords
+    // (haiku/sonnet/opus) in the model name the CLI sends. If the actual
+    // model ID (e.g., "deepseek-chat") doesn't contain the keyword, the
+    // proxy would misroute to "main". To fix this, we ensure the env var
+    // value always contains the slot keyword so identifySlot() can match.
+    const modelEnv: Record<string, string> = {}
+    for (const r of resolved) {
+      const rawName = r.label || r.modelId
+      switch (r.slot) {
+        case 'main':
+          modelEnv.ANTHROPIC_MODEL = rawName
+          break
+        case 'haiku': {
+          // Ensure the value contains "haiku" for identifySlot() routing
+          const name = /haiku/i.test(rawName) ? rawName : `${rawName}-haiku`
+          modelEnv.ANTHROPIC_DEFAULT_HAIKU_MODEL = name
+          break
+        }
+        case 'sonnet': {
+          const name = /sonnet/i.test(rawName) ? rawName : `${rawName}-sonnet`
+          modelEnv.ANTHROPIC_DEFAULT_SONNET_MODEL = name
+          break
+        }
+        case 'opus': {
+          const name = /opus/i.test(rawName) ? rawName : `${rawName}-opus`
+          modelEnv.ANTHROPIC_DEFAULT_OPUS_MODEL = name
+          break
+        }
+      }
+    }
+
+    if (needsProxy) {
+      settings.env = {
+        ...existingEnv,
+        ANTHROPIC_BASE_URL: `http://127.0.0.1:${ProviderService.serverPort}/proxy`,
+        ANTHROPIC_AUTH_TOKEN: 'proxy-managed',
+        ...modelEnv,
+      }
+    } else {
+      // All slots are native anthropic — use main slot's provider directly
+      const mainSlot = resolved.find((r) => r.slot === 'main') || resolved[0]
+      settings.env = {
+        ...existingEnv,
+        ANTHROPIC_BASE_URL: mainSlot.provider.baseUrl,
+        ANTHROPIC_AUTH_TOKEN: mainSlot.provider.apiKey,
+        ...modelEnv,
+      }
+    }
+
+    await this.writeSettings(settings)
+  }
+
   // --- Auth status ---
 
   /**
@@ -356,6 +453,13 @@ export class ProviderService {
     const slots = await this.readSlots()
     slots[slot] = entry
     await this.writeSlots(slots)
+
+    // Auto-sync settings.json so the CLI knows where to connect.
+    // When any slot uses a non-anthropic provider, the CLI must go through
+    // the local proxy; when all slots are anthropic (or empty), we can
+    // write direct provider info instead.
+    await this.syncSettingsForSlots(slots)
+
     return slots
   }