fix: stabilize Z.ai and MiniMax provider inference

Author: pmbstyle

src/components/Settings.vue

@@ -216,6 +216,10 @@ import { PREDEFINED_OPENAI_TOOLS } from '../utils/assistantTools'
 import { DEFAULT_ASSISTANT_PERSONA_PROMPT } from '../stores/settingsStore'
 import { useHotkeyRecording } from '../composables/useHotkeyRecording'
 import { useGoogleAuth } from '../composables/useGoogleAuth'
+import {
+  getStaticModelsForProvider,
+  type ProviderModelDefinition,
+} from '../services/llmProviders/providerCatalog'
 import CoreSettingsTab from './settings/CoreSettingsTab.vue'
 import AssistantSettingsTab from './settings/AssistantSettingsTab.vue'
 import HotkeysTab from './settings/HotkeysTab.vue'
@@ -272,6 +276,18 @@ const isBrowserContextToolActive = computed(() => {
 })
 
 const availableModelsForSelect = computed(() => {
+  const staticModels = getStaticModelsForProvider(
+    currentSettings.value.aiProvider
+  )
+  if (staticModels.length > 0) {
+    const staticModelIds = new Set(staticModels.map(model => model.id))
+    return [
+      ...staticModels.map((model: ProviderModelDefinition) => ({
+        id: model.id,
+      })),
+      ...availableModels.value.filter(model => !staticModelIds.has(model.id)),
+    ]
+  }
   return availableModels.value
 })
 

src/components/wizard/OnboardingWizard.vue

@@ -61,9 +61,11 @@ import FinalSetupStep from './steps/FinalSetupStep.vue'
 import OpenAI from 'openai'
 import {
   MINIMAX_OPENAI_BASE_URL,
+  ZAI_CODING_MODELS,
   ZAI_CODING_BASE_URL,
   type AIProviderKey,
 } from '../../services/llmProviders/providerCatalog'
+import { listMiniMaxModelsForConfig } from '../../services/llmProviders/minimax'
 
 const step = ref(1)
 const settingsStore = useSettingsStore()
@@ -91,6 +93,10 @@ const formData = reactive({
   localSttLanguage: 'auto',
 })
 
+function isAuthError(error: any): boolean {
+  return error?.status === 401 || error?.status === 403
+}
+
 const isTesting = reactive({
   openai: false,
   openrouter: false,
@@ -215,13 +221,25 @@ const fetchAvailableModels = async () => {
       return
     }
 
+    if (formData.aiProvider === 'minimax') {
+      const models = await listMiniMaxModelsForConfig(
+        formData.VITE_MINIMAX_API_KEY,
+        baseURL
+      )
+      formData.availableModels = models.map(model => model.id)
+
+      if (formData.availableModels.length > 0) {
+        formData.assistantModel = formData.availableModels[0]
+        formData.summarizationModel = formData.availableModels[0]
+      }
+      return
+    }
+
     const tempClient = new OpenAI({
       apiKey:
         formData.aiProvider === 'zai'
           ? formData.VITE_ZAI_API_KEY
-          : formData.aiProvider === 'minimax'
-            ? formData.VITE_MINIMAX_API_KEY
-            : formData.aiProvider,
+          : formData.aiProvider,
       baseURL,
       dangerouslyAllowBrowser: true,
     })
@@ -234,8 +252,15 @@ const fetchAvailableModels = async () => {
       formData.summarizationModel = formData.availableModels[0]
     }
   } catch (error) {
+    if (formData.aiProvider === 'zai' && !isAuthError(error)) {
+      formData.availableModels = ZAI_CODING_MODELS.map(model => model.id)
+      formData.assistantModel = formData.availableModels[0] || 'glm-5.1'
+      formData.summarizationModel = formData.availableModels[0] || 'glm-5.1'
+      return
+    }
     console.error('Failed to fetch models:', error)
     formData.availableModels = []
+    throw error
   }
 }
 
@@ -320,17 +345,8 @@ const testZAIKey = async () => {
   testResult.zai.success = false
 
   try {
-    const tempClient = new OpenAI({
-      apiKey: formData.VITE_ZAI_API_KEY,
-      baseURL: formData.zaiBaseUrl,
-      dangerouslyAllowBrowser: true,
-      timeout: 10 * 1000,
-      maxRetries: 1,
-    })
-
-    await tempClient.models.list()
-    testResult.zai.success = true
     await fetchAvailableModels()
+    testResult.zai.success = true
   } catch (e: any) {
     testResult.zai.error =
       'API key or Coding Plan endpoint is invalid or has no permissions.'
@@ -361,17 +377,8 @@ const testMiniMaxKey = async () => {
   testResult.minimax.success = false
 
   try {
-    const tempClient = new OpenAI({
-      apiKey: formData.VITE_MINIMAX_API_KEY,
-      baseURL: formData.minimaxBaseUrl,
-      dangerouslyAllowBrowser: true,
-      timeout: 10 * 1000,
-      maxRetries: 1,
-    })
-
-    await tempClient.models.list()
-    testResult.minimax.success = true
     await fetchAvailableModels()
+    testResult.minimax.success = true
   } catch (e: any) {
     testResult.minimax.error =
       'API key or OpenAI-compatible endpoint is invalid or has no permissions.'

src/modules/conversation/__tests__/turnManager.test.ts

@@ -155,6 +155,7 @@ describe('createTurnManager', () => {
 
     ctx.state.setAudioPlayer({ paused: true })
     ctx.state.setAudioQueueLength(0)
+    ctx.state.setAudioState('IDLE')
     vi.advanceTimersByTime(250)
 
     expect(ctx.deps.getAudioState()).toBe('IDLE')
@@ -198,5 +199,28 @@ describe('createTurnManager', () => {
     expect(ctx.triggerSummarization).not.toHaveBeenCalled()
     manager.dispose()
   })
-})
 
+  it('does not force IDLE while audio playback is being prepared', () => {
+    const ctx = buildDependencies()
+    ctx.state.setAudioPlayer({ paused: true })
+    ctx.state.setAudioQueueLength(0)
+    ctx.state.setAudioState('SPEAKING')
+    const manager = createTurnManager(ctx.deps)
+
+    manager.finalizeAfterStream({
+      streamEndedNormally: true,
+      isContinuationAfterTool: false,
+    })
+
+    vi.advanceTimersByTime(250)
+
+    expect(ctx.deps.getAudioState()).toBe('SPEAKING')
+    expect(ctx.triggerSummarization).not.toHaveBeenCalled()
+
+    ctx.state.setAudioState('IDLE')
+    vi.advanceTimersByTime(250)
+
+    expect(ctx.triggerSummarization).toHaveBeenCalled()
+    manager.dispose()
+  })
+})

src/modules/conversation/turnManager.ts

@@ -64,6 +64,11 @@ export function createTurnManager(
     if (!streamEndedNormally) return
 
     const finalizeInterval = setInterval(() => {
+      const audioState = dependencies.getAudioState()
+      if (audioState === 'SPEAKING') {
+        return
+      }
+
       const audioPlayer = dependencies.getAudioPlayer()
       if (audioPlayer && !audioPlayer.paused) {
         return
@@ -73,8 +78,7 @@ export function createTurnManager(
         return
       }
 
-      const audioState = dependencies.getAudioState()
-      if (audioState === 'SPEAKING' || audioState === 'WAITING_FOR_RESPONSE') {
+      if (audioState === 'WAITING_FOR_RESPONSE') {
         dependencies.setAudioState(
           dependencies.isRecordingRequested() ? 'LISTENING' : 'IDLE'
         )
@@ -98,4 +102,3 @@ export function createTurnManager(
     dispose,
   }
 }
-

src/services/apiService.ts

@@ -28,7 +28,14 @@ import {
   createMiniMaxResponse,
   listMiniMaxModels,
 } from './llmProviders/minimax'
-import { isChatCompletionsProvider } from './llmProviders/providerCatalog'
+import {
+  createMiniMaxChatCompletionViaMain,
+  stripReasoningFromMiniMaxContent,
+} from './llmProviders/openAICompatible'
+import {
+  getSafeProviderModel,
+  isChatCompletionsProvider,
+} from './llmProviders/providerCatalog'
 import type { AppChatMessageContentPart } from '../types/chat'
 import type { RagSearchResult } from '../types/rag'
 
@@ -715,16 +722,21 @@ export const createSummarizationResponse = async (
     .join('\n\n')
 
   if (isChatCompletionsProvider(settings.aiProvider)) {
-    const response = await client.chat.completions.create({
-      model: summarizationModel,
+    const params = {
+      model: getSafeProviderModel(settings.aiProvider, summarizationModel),
       messages: [
         { role: 'system', content: systemPrompt },
         { role: 'user', content: combinedText },
       ],
       stream: false,
-    } as any)
-
-    return response.choices[0]?.message?.content?.trim() || null
+    } as any
+    const response =
+      settings.aiProvider === 'minimax'
+        ? await createMiniMaxChatCompletionViaMain(params)
+        : await client.chat.completions.create(params)
+
+    const content = response.choices[0]?.message?.content?.trim()
+    return content ? stripReasoningFromMiniMaxContent(content) : null
   } else {
     const response = await client.responses.create({
       model: summarizationModel,
@@ -767,18 +779,23 @@ export const createContextAnalysisResponse = async (
     .join('\n\n')
 
   if (isChatCompletionsProvider(settings.aiProvider)) {
-    const response = await client.chat.completions.create({
-      model: analysisModel,
+    const params = {
+      model: getSafeProviderModel(settings.aiProvider, analysisModel),
       messages: [
         { role: 'system', content: analysisSystemPrompt },
         { role: 'user', content: combinedText },
       ],
       stream: false,
-    } as any)
-
-    return (
-      response.choices[0]?.message?.content?.trim().replace(/"/g, '') || null
-    )
+    } as any
+    const response =
+      settings.aiProvider === 'minimax'
+        ? await createMiniMaxChatCompletionViaMain(params)
+        : await client.chat.completions.create(params)
+
+    const content = response.choices[0]?.message?.content?.trim()
+    return content
+      ? stripReasoningFromMiniMaxContent(content).replace(/"/g, '')
+      : null
   } else {
     const response = await client.responses.create({
       model: analysisModel,

src/services/llmProviders/__tests__/minimax.test.ts

@@ -0,0 +1,41 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { listMiniMaxModelsForConfig } from '../minimax'
+
+describe('MiniMax model listing', () => {
+  afterEach(() => {
+    vi.restoreAllMocks()
+    delete (globalThis as any).window
+  })
+
+  it('uses the Electron HTTP bridge without OpenAI SDK stainless headers', async () => {
+    const request = vi.fn().mockResolvedValue({
+      success: true,
+      status: 200,
+      data: {
+        data: [{ id: 'MiniMax-M2.7' }, { id: 'unrelated-model' }],
+      },
+    })
+    ;(globalThis as any).window = {
+      httpAPI: {
+        request,
+      },
+    }
+
+    const models = await listMiniMaxModelsForConfig(
+      'sk-test',
+      'https://api.minimax.io/v1/'
+    )
+
+    expect(models.map(model => model.id)).toEqual(['MiniMax-M2.7'])
+    expect(request).toHaveBeenCalledWith(
+      expect.objectContaining({
+        url: 'https://api.minimax.io/v1/models',
+        method: 'GET',
+        headers: {
+          Authorization: 'Bearer sk-test',
+        },
+      })
+    )
+    expect(request.mock.calls[0][0].headers['x-stainless-os']).toBeUndefined()
+  })
+})