Update mistral model cache mecachnisme

Author: kwibus

lua/codecompanion/adapters/http/mistral/get_models.lua

@@ -16,22 +16,30 @@ local M = {}
 ---@field formatted_name string?
 ---@field opts {can_use_tools: boolean, has_vision: boolean}
 
----@alias MistralModelCache table<string, MistralModelInfo>
-
----@type MistralModelCache
+---@class MistralApiCapabilities
+---@field completion_chat boolean
+---@field vision boolean
+---@field function_calling boolean
+
+---@class MistralApiModel
+---@field id string
+---@field name string
+---@field aliases string[]
+---@field deprecation any?
+---@field capabilities MistralApiCapabilities
+
+---@type table<string, MistralModelInfo>
 local _cached_models = {}
 
----@return MistralModelCache
+---@return table<string, MistralModelInfo>
 local function get_cached_models()
-  assert(_cached_models ~= nil, "Model info is not available in the cache.")
-  local models = _cached_models
-  return models
+  return _cached_models
 end
 
 ---When given a list of names that are aliases for the same model, returns the preferred name.
 ---The preference order is: names ending with '-latest' (highest priority),
 ---then names ending with four digits (e.g., '-2023'), and finally other names.
----@param names table List of names, should at least contain 1 entry
+---@param names string[] List of names, should at least contain 1 entry
 ---@return string?
 local function preferred_model_name(names)
   local high_score = -1
@@ -55,16 +63,13 @@ end
 
 ---Multiple id can refer to the same Model,
 ---This function removes duplicates, only using preferred model name
----@param models table[] Table as returned by Mistral API response
----@return table[]
+---@param models MistralApiModel[] Table as returned by Mistral API response
+---@return MistralApiModel[]
 local function dedup_models(models)
   local preferred_names = {}
   for _, model in ipairs(models) do
     if model.id then
-      local aliases = {}
-      if model.aliases then
-        aliases = model.aliases
-      end
+      local aliases = model.aliases
       table.insert(aliases, model.id)
 
       if preferred_names[model.id] then
@@ -92,25 +97,27 @@ end
 
 ---Fetch model list and model info.
 ---Aborts if there's another fetch job running.
----Returns the number of models if the fetches are fired.
+---@return boolean cache was successful updated
 ---@param adapter CodeCompanion.HTTPAdapter Mistral adapter with env var replaced.
 local function fetch_async(adapter)
   assert(adapter ~= nil)
+
+  utils.get_env_vars(adapter)
   if running then
-    return
+    return false
   end
 
   running = true
 
-  _cached_models = _cached_models or {} -- TODO: this has the side effect models are never removed
+  _cached_models = _cached_models or {}
 
   local models_endpoint = "/v1/models"
   local headers = {
     ["content-type"] = "application/json",
     ["Authorization"] = "Bearer " .. adapter.env_replaced.api_key,
   }
   local url = adapter.env_replaced.url
-  pcall(function()
+  local ok, err = pcall(function()
     Curl.get(url .. models_endpoint, {
       headers = headers,
       insecure = config.adapters.http.opts.allow_insecure,
@@ -120,18 +127,19 @@ local function fetch_async(adapter)
       -- This can happen wen you update vim ui in curl callback.
       callback = vim.schedule_wrap(function(response)
         if response.status ~= 200 then
-          running = false
-          return log:error(
+          log:error(
             "Could not get Mistral models from " .. url .. models_endpoint .. ". Error: %s",
             response.body
           )
+          running = false
+          return false
         end
 
         local ok, json = pcall(vim.json.decode, response.body)
         if not ok then
-          running = false
           log:error("Could not parse the response from " .. url .. models_endpoint)
-          return {}
+          running = false
+          return false
         end
 
         for _, model_obj in ipairs(dedup_models(json.data)) do
@@ -150,39 +158,29 @@ local function fetch_async(adapter)
         running = false
       end),
     })
-    if adapter.opts.cache_adapter == false then
-      vim.wait(CONSTANTS.TIMEOUT, function()
-        local models = _cached_models
-        return models ~= nil and not vim.tbl_isempty(models) and not running
-      end)
-    end
   end)
+
+  if not ok then
+    log:error("Could not fetch fetch Mistral Copilot models: %s", err)
+    running = false
+    return false
+  end
+  return true
 end
 
 ---@param self CodeCompanion.HTTPAdapter
----@return MistralModelCache
-function M.choices(self, opts)
-  local adapter = require("codecompanion.adapters.http").resolve(self)
+---@return table<string, MistralModelInfo>
+function M.choices(self)
 
-  if not adapter then
-    log:error("Could not resolve Mistral adapter in the `choices` function")
-    return {}
+  local models = get_cached_models()
+  if models ~= nil and next(models) then
+    return models
   end
-  opts = opts or { async = true }
-
-  utils.get_env_vars(adapter)
-  local is_uninitialised = _cached_models == nil or next(_cached_models)
-
-  local should_block = (adapter.opts.cache_adapter == false) or is_uninitialised or not opts.async
 
-  fetch_async(adapter)
-
-  if should_block and running then
-    vim.wait(CONSTANTS.TIMEOUT, function()
-      return not running
-    end)
-  end
+  fetch_async(self)
+  vim.wait(CONSTANTS.TIMEOUT, function()
+    return not running
+  end)
   return get_cached_models()
 end
-
 return M

lua/codecompanion/adapters/http/mistral/init.lua

@@ -3,7 +3,7 @@ local openai = require("codecompanion.adapters.http.openai")
 
 ---Resolves the options that a model has
 ---@param adapter CodeCompanion.HTTPAdapter
----@return table
+---@return MistralModelInfo | nil
 local function resolve_model_opts(adapter)
   local model = adapter.schema.model.default
   local choices = adapter.schema.model.choices
@@ -28,7 +28,6 @@ return {
     stream = true,
     tools = true,
     vision = true,
-    cache_adapter = true, -- Cache the resolved adapter to prevent multiple resolutions
   },
   features = {
     text = true,
@@ -44,6 +43,9 @@ return {
     ["Content-Type"] = "application/json",
   },
   handlers = {
+
+    ---@param self CodeCompanion.HTTPAdapter
+    ---@return boolean
     setup = function(self)
       local model_opts = resolve_model_opts(self)
 
@@ -104,9 +106,9 @@ return {
       type = "enum",
       desc = "ID of the model to use. See the model endpoint compatibility table for details on which models work with the Chat API.",
       default = "mistral-small-latest",
-      ---@type fun(self: CodeCompanion.HTTPAdapter, opts?: table): table
-      choices = function(self, opts)
-        return get_models.choices(self, opts)
+      ---@type fun(self: CodeCompanion.HTTPAdapter): table<string, MistralModelInfo>
+      choices = function(self)
+        return get_models.choices(self)
       end,
     },
     temperature = {

tests/adapters/http/mistral/test_models.lua

@@ -2,8 +2,6 @@
 local h = require("tests.helpers")
 
 local new_set = MiniTest.new_set
-local expect = MiniTest.expect
-local eq = MiniTest.expect.equality
 
 local child = MiniTest.new_child_neovim()
 
@@ -56,7 +54,7 @@ T["mistral.models"]["choices() synchronous returns expected models"] = function(
     adapters_utils.get_env_vars = function(adapter) end
 
     local adapter = { opts = {} }
-    return get_models.choices(adapter, { async = false })
+    return get_models.choices(adapter)
   ]])
 
   -- This expected output is based on the logic in get_models.lua:
@@ -93,79 +91,4 @@ T["mistral.models"]["choices() synchronous returns expected models"] = function(
   h.eq(result, expected)
 end
 
-T["mistral.models"]["choices() async populates cache and returns later"] = function()
-  local first, second = unpack(child.lua([[
-    local get_models = require("codecompanion.adapters.http.mistral.get_models")
-
-    -- Mock Curl.get to return stub data
-    local curl = require("plenary.curl")
-    local body = vim.fn.readfile("tests/adapters/http/stubs/mistral_models.json")
-    body = table.concat(body, "\n")
-
-    curl.get = function(url, opts)
-      if opts and type(opts.callback) == "function" then
-        opts.callback({ status = 200, body = body })
-      end
-      return { status = 200, body = body }
-    end
-
-    -- Mock resolve() to return test adapter
-    local http_adapters = require("codecompanion.adapters.http")
-    http_adapters.resolve = function(self)
-      return {
-        env_replaced = {
-          url = "https://api.mistral.ai",
-          api_key = "test-key",
-        },
-        opts = {},
-      }
-    end
-
-    -- Mock get_env_vars() to do nothing
-    local adapters_utils = require("codecompanion.utils.adapters")
-    adapters_utils.get_env_vars = function(adapter) end
-
-    local adapter = { opts = {} }
-
-    -- Start async fetch: should return nil initially (no cache yet)
-    local first = get_models.choices(adapter, { async = true })
-
-    -- Give scheduled callback a chance to run and fill cache
-    vim.wait(50, function() return false end)
-
-    -- Second call should return cached models
-    local second = get_models.choices(adapter, { async = true })
-
-    return { first, second }
-  ]]))
-
-  local expected = {
-    ["mistral-medium-2505"] = {
-      formatted_name = "mistral-medium-2505",
-      opts = {
-        has_vision = true,
-        can_use_tools = true,
-      },
-    },
-    ["mistral-large-latest"] = {
-      formatted_name = "mistral-large-latest",
-      opts = {
-        has_vision = true,
-        can_use_tools = true,
-      },
-    },
-    ["ministral-8b-latest"] = {
-      formatted_name = "ministral-8b-2410",
-      opts = {
-        has_vision = false,
-        can_use_tools = true,
-      },
-    },
-  }
-
-  -- Mistral blocks on first call when cache is uninitialized, even with async=true
-  h.eq(expected, first)
-  h.eq(expected, second)
-end
-
 return T