fix: wrong desc setting cont_batching

extensions/llamacpp-extension/settings.json

@@ -153,7 +153,7 @@
   {
     "key": "cont_batching",
     "title": "Continuous Batching",
-    "description": "Enable continuous batching (a.k.a dynamic batching) for concurrent requests (default: enabled).",
+    "description": "Enable continuous batching (a.k.a dynamic batching) for concurrent requests.",
     "controllerType": "checkbox",
     "controllerProps": {
       "value": false

web-app/src/hooks/useModelProvider.ts

@@ -29,123 +29,123 @@
       selectedModel: null,
       deletedModels: [],
       getModelBy: (modelId: string) => {
         const provider = get().providers.find(
           (provider) => provider.provider === get().selectedProvider
         )
         if (!provider) return undefined
         return provider.models.find((model) => model.id === modelId)
       },
       setProviders: (providers) =>
         set((state) => {
           const existingProviders = state.providers
             // Filter out legacy llama.cpp provider for migration
             // Can remove after a couple of releases
             .filter((e) => e.provider !== 'llama.cpp')
             .map((provider) => {
               return {
                 ...provider,
                 models: provider.models.filter(
                   (e) =>
                     ('id' in e || 'model' in e) &&
                     typeof (e.id ?? e.model) === 'string'
                 ),
               }
             })
 
           let legacyModels: Model[] | undefined = []
           /// Cortex Migration
           if (
             localStorage.getItem('cortex_model_settings_migrated') !== 'true'
           ) {
             legacyModels = state.providers.find(
               (e) => e.provider === 'llama.cpp'
             )?.models
             localStorage.setItem('cortex_model_settings_migrated', 'true')
           }
           // Ensure deletedModels is always an array
           const currentDeletedModels = Array.isArray(state.deletedModels)
             ? state.deletedModels
             : []
 
           const updatedProviders = providers.map((provider) => {
             const existingProvider = existingProviders.find(
               (x) => x.provider === provider.provider
             )
             const models = (existingProvider?.models || []).filter(
               (e) =>
                 ('id' in e || 'model' in e) &&
                 typeof (e.id ?? e.model) === 'string'
             )
             const mergedModels = [
               ...(provider?.models ?? []).filter(
                 (e) =>
                   ('id' in e || 'model' in e) &&
                   typeof (e.id ?? e.model) === 'string' &&
                   !models.some((m) => m.id === e.id) &&
                   !currentDeletedModels.includes(e.id)
               ),
               ...models,
             ]
             const updatedModels = provider.models?.map((model) => {
               const settings =
                 (legacyModels && legacyModels?.length > 0
                   ? legacyModels
                   : models
                 ).find(
                   (m) => m.id.split(':').slice(0, 2).join(sep()) === model.id
                 )?.settings || model.settings
               const existingModel = models.find((m) => m.id === model.id)
               return {
                 ...model,
                 settings: settings,
                 capabilities: existingModel?.capabilities || model.capabilities,
               }
             })
 
             return {
               ...provider,
               models: provider.persist ? updatedModels : mergedModels,
               settings: provider.settings.map((setting) => {
                 const existingSetting = provider.persist
                   ? undefined
                   : existingProvider?.settings?.find(
                       (x) => x.key === setting.key
                     )
                 return {
                   ...setting,
                   controller_props: {
                     ...setting.controller_props,
                     ...(existingSetting?.controller_props || {}),
                   },
                 }
               }),
               api_key: existingProvider?.api_key || provider.api_key,
               base_url: existingProvider?.base_url || provider.base_url,
               active: existingProvider ? existingProvider?.active : true,
             }
           })
           return {
             providers: [
               ...updatedProviders,
               ...existingProviders.filter(
                 (e) => !updatedProviders.some((p) => p.provider === e.provider)
               ),
             ],
           }
         }),
       updateProvider: (providerName, data) => {
         set((state) => ({
           providers: state.providers.map((provider) => {
             if (provider.provider === providerName) {
               return {
                 ...provider,
                 ...data,
               }
             }
             return provider
           }),
         }))
       },
       getProviderByName: (providerName: string) => {
         const provider = get().providers.find(
           (provider) => provider.provider === providerName
@@ -155,9 +155,9 @@
       },
       selectModelProvider: (providerName: string, modelName: string) => {
         // Find the model object
         const provider = get().providers.find(
           (provider) => provider.provider === providerName
         )
 
         let modelObject: Model | undefined = undefined
 
@@ -210,6 +210,29 @@
     {
       name: localStorageKey.modelProvider,
       storage: createJSONStorage(() => localStorage),
+      migrate: (persistedState: unknown, version: number) => {
+        const state = persistedState as ModelProviderState
+
+        // Migration for cont_batching description update (version 0 -> 1)
+        if (version === 0 && state?.providers) {
+          state.providers = state.providers.map((provider) => {
+            if (provider.provider === 'llamacpp' && provider.settings) {
+              provider.settings = provider.settings.map((setting) => {
+                if (setting.key === 'cont_batching') {
+                  return {
+                    ...setting,
+                    description: 'Enable continuous batching (a.k.a dynamic batching) for concurrent requests.'
+                  }
+                }
+                return setting
+              })
+            }
+            return provider
+          })
+        }
+        return state
+      },
+      version: 1,
     }
   )
 )