feat: add custom model management system with add/remove/reset functionality

Author: xiaoY233

src/main/ipc/channels.ts

@@ -29,6 +29,10 @@ export const IpcChannels = {
   PROVIDERS_IMPORT: 'providers:import',
   PROVIDERS_SYNC_MODELS: 'providers:syncModels',
   PROVIDERS_UPDATE_MODELS: 'providers:updateModels',
+  PROVIDERS_GET_EFFECTIVE_MODELS: 'providers:getEffectiveModels',
+  PROVIDERS_ADD_CUSTOM_MODEL: 'providers:addCustomModel',
+  PROVIDERS_REMOVE_MODEL: 'providers:removeModel',
+  PROVIDERS_RESET_MODELS: 'providers:resetModels',
 
   ACCOUNTS_GET_ALL: 'accounts:getAll',
   ACCOUNTS_GET_BY_ID: 'accounts:getById',

src/main/ipc/handlers.ts

@@ -355,23 +355,19 @@ export async function registerIpcHandlers(mainWindow: BrowserWindow | null): Pro
         }
       }
 
-      // Try to get an active account for authentication (include credentials)
       const accounts = AccountManager.getByProviderId(providerId, true)
       const activeAccount = accounts.find(a => a.status === 'active')
 
-      // Build request headers with optional authentication
       const requestHeaders: Record<string, string> = {
         'Content-Type': 'application/json',
         Accept: 'application/json',
         ...modelsApiHeaders,
       }
 
-      // Add authorization header if account exists
       if (activeAccount?.credentials?.token) {
         requestHeaders['Authorization'] = `Bearer ${activeAccount.credentials.token}`
       }
 
-      // Add cookie header if account has cookies (required for qwen-ai)
       if (activeAccount?.credentials?.cookies) {
         requestHeaders['Cookie'] = activeAccount.credentials.cookies
       }
@@ -441,6 +437,63 @@ export async function registerIpcHandlers(mainWindow: BrowserWindow | null): Pro
     }
   })
 
+  ipcMain.handle(IpcChannels.PROVIDERS_GET_EFFECTIVE_MODELS, async (_, providerId: string) => {
+    try {
+      return storeManager.getEffectiveModels(providerId)
+    } catch (error) {
+      console.error('[IPC] Failed to get effective models:', error)
+      return []
+    }
+  })
+
+  ipcMain.handle(IpcChannels.PROVIDERS_ADD_CUSTOM_MODEL, async (_, providerId: string, model: { displayName: string; actualModelId: string }) => {
+    try {
+      return {
+        success: true,
+        models: storeManager.addCustomModel(providerId, model),
+      }
+    } catch (error) {
+      console.error('[IPC] Failed to add custom model:', error)
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to add custom model',
+        models: [],
+      }
+    }
+  })
+
+  ipcMain.handle(IpcChannels.PROVIDERS_REMOVE_MODEL, async (_, providerId: string, modelName: string) => {
+    try {
+      return {
+        success: true,
+        models: storeManager.removeModel(providerId, modelName),
+      }
+    } catch (error) {
+      console.error('[IPC] Failed to remove model:', error)
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to remove model',
+        models: [],
+      }
+    }
+  })
+
+  ipcMain.handle(IpcChannels.PROVIDERS_RESET_MODELS, async (_, providerId: string) => {
+    try {
+      return {
+        success: true,
+        models: storeManager.resetModels(providerId),
+      }
+    } catch (error) {
+      console.error('[IPC] Failed to reset models:', error)
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to reset models',
+        models: [],
+      }
+    }
+  })
+
   ipcMain.handle(IpcChannels.ACCOUNTS_GET_ALL, async (_, includeCredentials?: boolean): Promise<Account[]> => {
     return AccountManager.getAll(includeCredentials)
   })
@@ -558,7 +611,7 @@ export async function registerIpcHandlers(mainWindow: BrowserWindow | null): Pro
         return { success: false, error: 'Provider not found' }
       }
 
-      // Support qwen-ai, minimax, zai, perplexity, deepseek, and glm providers
+      // Support qwen-ai, minimax, zai, perplexity, deepseek, glm, and mimo providers
       if (provider.id === 'qwen-ai') {
         const { QwenAiAdapter } = await import('../proxy/adapters/qwen-ai')
         const adapter = new QwenAiAdapter(provider, account)
@@ -589,6 +642,11 @@ export async function registerIpcHandlers(mainWindow: BrowserWindow | null): Pro
         const adapter = new GLMAdapter(provider, account)
         const success = await adapter.deleteAllChats()
         return { success }
+      } else if (provider.id === 'mimo') {
+        const { MimoAdapter } = await import('../proxy/adapters/mimo')
+        const adapter = new MimoAdapter(provider, account)
+        const success = await adapter.deleteAllChats()
+        return { success }
       } else {
         return { success: false, error: 'This feature is not available for this provider' }
       }

src/main/providers/builtin/minimax.ts

@@ -27,9 +27,11 @@ export const minimaxConfig: BuiltinProviderConfig = {
   description: 'MiniMax Agent - AI assistant with MCP multi-agent collaboration',
   supportedModels: [
     'MiniMax-M2.5',
+    'MiniMax-M2.7',
   ],
   modelMappings: {
     'MiniMax-M2.5': 'MiniMax-M2.5',
+    'MiniMax-M2.7': 'MiniMax-M2.7',
   },
   credentialFields: [
     {

src/main/proxy/adapters/mimo.ts

@@ -357,6 +357,123 @@ export class MimoAdapter {
 
     return { response, conversationId }
   }
+
+  private async getConversationList(pageNum: number = 1, pageSize: number = 100): Promise<{
+    conversationIds: string[]
+    hasMore: boolean
+  }> {
+    const { serviceToken, userId, phToken } = this.getCredentials()
+
+    if (!serviceToken || !userId || !phToken) {
+      throw new Error('Mimo credentials not configured')
+    }
+
+    const url = `${MIMO_API_BASE}/open-apis/chat/conversation/list?xiaomichatbot_ph=${encodeURIComponent(phToken)}`
+
+    const response = await axios.post(
+      url,
+      {
+        pageInfo: {
+          pageNum,
+          pageSize,
+        },
+      },
+      {
+        headers: {
+          'Content-Type': 'application/json',
+          Cookie: `serviceToken=${serviceToken}; userId=${userId}; xiaomichatbot_ph=${phToken}`,
+          Origin: MIMO_API_BASE,
+          Referer: `${MIMO_API_BASE}/`,
+        },
+        timeout: 30000,
+        validateStatus: () => true,
+      }
+    )
+
+    console.log('[Mimo] Get conversation list page', pageNum, 'response:', JSON.stringify(response.data, null, 2))
+
+    const { code, data } = response.data || {}
+    if (response.status !== 200 || code !== 0) {
+      console.error('[Mimo] Failed to get conversation list')
+      return { conversationIds: [], hasMore: false }
+    }
+
+    const conversationList = data?.dataList || []
+    const conversationIds = conversationList.map((c: any) => c.conversationId).filter(Boolean)
+    const hasMore = conversationList.length >= pageSize
+
+    console.log('[Mimo] Found', conversationIds.length, 'conversations, hasMore:', hasMore)
+    return { conversationIds, hasMore }
+  }
+
+  private async deleteConversations(conversationIds: string[]): Promise<boolean> {
+    if (conversationIds.length === 0) {
+      return true
+    }
+
+    const { serviceToken, userId, phToken } = this.getCredentials()
+
+    if (!serviceToken || !userId || !phToken) {
+      throw new Error('Mimo credentials not configured')
+    }
+
+    const url = `${MIMO_API_BASE}/open-apis/chat/conversation/delete?xiaomichatbot_ph=${encodeURIComponent(phToken)}`
+
+    const response = await axios.post(
+      url,
+      conversationIds,
+      {
+        headers: {
+          'Content-Type': 'application/json',
+          Cookie: `serviceToken=${serviceToken}; userId=${userId}; xiaomichatbot_ph=${phToken}`,
+          Origin: MIMO_API_BASE,
+          Referer: `${MIMO_API_BASE}/`,
+        },
+        timeout: 60000,
+        validateStatus: () => true,
+      }
+    )
+
+    console.log('[Mimo] Delete conversations response:', JSON.stringify(response.data, null, 2))
+
+    const { code } = response.data || {}
+    return response.status === 200 && code === 0
+  }
+
+  async deleteAllChats(): Promise<boolean> {
+    try {
+      const allConversationIds: string[] = []
+      let pageNum = 1
+      let hasMore = true
+
+      while (hasMore) {
+        const { conversationIds, hasMore: more } = await this.getConversationList(pageNum, 100)
+        allConversationIds.push(...conversationIds)
+        hasMore = more
+        pageNum++
+
+        if (conversationIds.length === 0) {
+          break
+        }
+      }
+
+      if (allConversationIds.length === 0) {
+        console.log('[Mimo] No conversations to delete')
+        return true
+      }
+
+      console.log('[Mimo] Found', allConversationIds.length, 'conversations to delete')
+
+      const success = await this.deleteConversations(allConversationIds)
+      if (success) {
+        console.log('[Mimo] All chats deleted')
+      }
+      return success
+    } catch (error) {
+      console.error('[Mimo] Failed to delete all chats:', error)
+      return false
+    }
+  }
 }
 
 export class MimoStreamHandler {

src/main/proxy/loadbalancer.ts

@@ -129,13 +129,14 @@ export class LoadBalancer {
    * Check if provider supports model
    */
   private providerSupportsModel(provider: Provider, model: string): boolean {
-    if (!provider.supportedModels || provider.supportedModels.length === 0) {
+    const effectiveModels = storeManager.getEffectiveModels(provider.id)
+    if (effectiveModels.length === 0) {
       return true
     }
 
     const normalizedModel = model.toLowerCase()
-    const supported = provider.supportedModels.some(m => {
-      const normalizedSupported = m.toLowerCase()
+    const supported = effectiveModels.some(m => {
+      const normalizedSupported = m.displayName.toLowerCase()
       if (normalizedSupported.endsWith('*')) {
         return normalizedModel.startsWith(normalizedSupported.slice(0, -1))
       }
@@ -146,17 +147,9 @@ export class LoadBalancer {
       return true
     }
 
-    // Check if model is in provider's model mappings
-    if (provider.modelMappings && provider.modelMappings[model]) {
-      console.log(`[LoadBalancer] Model "${model}" found in provider model mappings`)
-      return true
-    }
-
-    // Check global model mappings
     const config = storeManager.getConfig()
     const globalMapping = config.modelMappings[model]
     if (globalMapping) {
-      // If preferredProviderId is set, only match that provider
       if (globalMapping.preferredProviderId) {
         if (globalMapping.preferredProviderId === provider.id) {
           console.log(`[LoadBalancer] Model "${model}" matched preferred provider ${provider.name}`)
@@ -165,11 +158,10 @@ export class LoadBalancer {
         return false
       }
 
-      // If no preferredProviderId, check if provider supports the actualModel
       const actualModel = globalMapping.actualModel
       const normalizedActualModel = actualModel.toLowerCase()
-      const actualSupported = provider.supportedModels.some(m => {
-        const normalizedSupported = m.toLowerCase()
+      const actualSupported = effectiveModels.some(m => {
+        const normalizedSupported = m.displayName.toLowerCase()
         if (normalizedSupported.endsWith('*')) {
           return normalizedActualModel.startsWith(normalizedSupported.slice(0, -1))
         }
@@ -180,15 +172,9 @@ export class LoadBalancer {
         console.log(`[LoadBalancer] Model "${model}" (actualModel: "${actualModel}") supported by ${provider.name}`)
         return true
       }
-      
-      // Also check provider's model mappings for actualModel
-      if (provider.modelMappings && provider.modelMappings[actualModel]) {
-        console.log(`[LoadBalancer] Model "${model}" (actualModel: "${actualModel}") found in provider model mappings`)
-        return true
-      }
     }
 
-    console.log(`[LoadBalancer] Provider ${provider.name} does not support model ${model}, supported models:`, provider.supportedModels)
+    console.log(`[LoadBalancer] Provider ${provider.name} does not support model ${model}`)
     return false
   }
 
@@ -212,28 +198,30 @@ export class LoadBalancer {
    */
   private mapModel(model: string, provider: Provider): string {
     console.log(`[LoadBalancer] mapModel called with model="${model}", provider="${provider.name}"`)
-    console.log(`[LoadBalancer] provider.modelMappings:`, provider.modelMappings)
 
-    // First check provider-level model mapping
-    if (provider.modelMappings && provider.modelMappings[model]) {
-      const mapped = provider.modelMappings[model]
-      console.log(`[LoadBalancer] Model mapped from "${model}" to "${mapped}" via provider mapping`)
-      return mapped
+    const effectiveModels = storeManager.getEffectiveModels(provider.id)
+    const effectiveModel = effectiveModels.find(m => 
+      m.displayName.toLowerCase() === model.toLowerCase()
+    )
+    
+    if (effectiveModel) {
+      console.log(`[LoadBalancer] Model mapped from "${model}" to "${effectiveModel.actualModelId}" via effective models`)
+      return effectiveModel.actualModelId
     }
 
-    // Then check global config model mapping
     const config = storeManager.getConfig()
     const mapping = config.modelMappings[model]
 
     if (mapping && (!mapping.preferredProviderId || mapping.preferredProviderId === provider.id)) {
       const actualModel = mapping.actualModel
       console.log(`[LoadBalancer] Model mapped from "${model}" to "${actualModel}" via global mapping`)
 
-      // After global mapping, check if provider has a mapping for the actual model
-      if (provider.modelMappings && provider.modelMappings[actualModel]) {
-        const finalModel = provider.modelMappings[actualModel]
-        console.log(`[LoadBalancer] Model further mapped from "${actualModel}" to "${finalModel}" via provider mapping`)
-        return finalModel
+      const actualEffectiveModel = effectiveModels.find(m => 
+        m.displayName.toLowerCase() === actualModel.toLowerCase()
+      )
+      if (actualEffectiveModel) {
+        console.log(`[LoadBalancer] Model further mapped from "${actualModel}" to "${actualEffectiveModel.actualModelId}" via effective models`)
+        return actualEffectiveModel.actualModelId
       }
 
       return actualModel
@@ -340,8 +328,9 @@ export class LoadBalancer {
       const accounts = storeManager.getAccountsByProviderId(provider.id)
         .filter(account => this.isAccountAvailable(account))
 
-      if (accounts.length > 0 && provider.supportedModels) {
-        provider.supportedModels.forEach(m => models.add(m))
+      if (accounts.length > 0) {
+        const effectiveModels = storeManager.getEffectiveModels(provider.id)
+        effectiveModels.forEach(m => models.add(m.displayName))
       }
     }
 

src/main/proxy/modelMapper.ts

@@ -169,13 +169,14 @@ export class ModelMapper {
     }
 
     return providers.filter(provider => {
-      if (!provider.supportedModels || provider.supportedModels.length === 0) {
+      const effectiveModels = storeManager.getEffectiveModels(provider.id)
+      if (effectiveModels.length === 0) {
         return true
       }
 
       const normalizedModel = model.toLowerCase()
-      return provider.supportedModels.some(m => {
-        const normalizedSupported = m.toLowerCase()
+      return effectiveModels.some(m => {
+        const normalizedSupported = m.displayName.toLowerCase()
         if (normalizedSupported.endsWith('*')) {
           return normalizedModel.startsWith(normalizedSupported.slice(0, -1))
         }