bug: Deleted model file from imported models blocking model loading (#6317)

web-app/src/services/providers/tauri.ts

@@ -2,91 +2,104 @@
  * Tauri Providers Service - Desktop implementation
  */
 
 import { models as providerModels } from 'token.js'
 import { predefinedProviders } from '@/consts/providers'
 import { EngineManager, SettingComponentProps } from '@janhq/core'
 import { ModelCapabilities } from '@/types/models'
 import { modelSettings } from '@/lib/predefined'
 import { ExtensionManager } from '@/lib/extension'
 import { fetch as fetchTauri } from '@tauri-apps/plugin-http'
 import { DefaultProvidersService } from './default'
 
 export class TauriProvidersService extends DefaultProvidersService {
   fetch(): typeof fetch {
     // Tauri implementation uses Tauri's fetch to avoid CORS issues
     return fetchTauri as typeof fetch
   }
 
   async getProviders(): Promise<ModelProvider[]> {
     try {
       const builtinProviders = predefinedProviders.map((provider) => {
         let models = provider.models as Model[]
         if (Object.keys(providerModels).includes(provider.provider)) {
           const builtInModels = providerModels[
             provider.provider as unknown as keyof typeof providerModels
           ].models as unknown as string[]
 
           if (Array.isArray(builtInModels))
             models = builtInModels.map((model) => {
               const modelManifest = models.find((e) => e.id === model)
               // TODO: Check chat_template for tool call support
               const capabilities = [
                 ModelCapabilities.COMPLETION,
                 (
                   providerModels[
                     provider.provider as unknown as keyof typeof providerModels
                   ].supportsToolCalls as unknown as string[]
                 ).includes(model)
                   ? ModelCapabilities.TOOLS
                   : undefined,
               ].filter(Boolean) as string[]
               return {
                 ...(modelManifest ?? { id: model, name: model }),
                 capabilities,
               } as Model
             })
         }
 
         return {
           ...provider,
           models,
         }
       })
 
       const runtimeProviders: ModelProvider[] = []
       for (const [providerName, value] of EngineManager.instance().engines) {
         const models = (await value.list()) ?? []
         const provider: ModelProvider = {
           active: false,
           persist: true,
           provider: providerName,
           base_url:
             'inferenceUrl' in value
               ? (value.inferenceUrl as string).replace('/chat/completions', '')
               : '',
           settings: (await value.getSettings()).map((setting) => {
             return {
               key: setting.key,
               title: setting.title,
               description: setting.description,
               controller_type: setting.controllerType as unknown,
               controller_props: setting.controllerProps as unknown,
             }
           }) as ProviderSetting[],
           models: await Promise.all(
             models.map(
-              async (model) =>
-                ({
+              async (model) => {
+                let capabilities: string[] = []
+
+                // Check for capabilities
+                if ('capabilities' in model) {
+                  capabilities = model.capabilities as string[]
+                } else {
+                  // Try to check tool support, but don't let failures block the model
+                  try {
+                    const toolSupported = await value.isToolSupported(model.id)
+                    if (toolSupported) {
+                      capabilities = [ModelCapabilities.TOOLS]
+                    }
+                  } catch (error) {
+                    console.warn(`Failed to check tool support for model ${model.id}:`, error)
+                    // Continue without tool capabilities if check fails
+                  }
+                }
+
+                return {
                   id: model.id,
                   model: model.id,
                   name: model.name,
                   description: model.description,
-                  capabilities:
-                    'capabilities' in model
-                      ? (model.capabilities as string[])
-                      : (await value.isToolSupported(model.id))
-                        ? [ModelCapabilities.TOOLS]
-                        : [],
+                  capabilities,
                   provider: providerName,
                   settings: Object.values(modelSettings).reduce(
                     (acc, setting) => {
@@ -105,7 +118,8 @@
                     },
                     {} as Record<string, ProviderSetting>
                   ),
-                }) as Model
+                } as Model
+              }
             )
           ),
         }