fix(chat): tools can now be dynamically added (olimorris#1693)

Author: ravitemer

lua/codecompanion/strategies/chat/agents/init.lua

@@ -58,6 +58,13 @@ function Agent.new(args)
   return self
 end
 
+---Refresh the tools configuration to pick up any dynamically added tools
+---@return CodeCompanion.Agent
+function Agent:refresh_tools()
+  self.tools_config = ToolFilter.filter_enabled_tools(config.strategies.chat.tools)
+  return self
+end
+
 ---Set the autocmds for the tool
 ---@return nil
 function Agent:set_autocmds()

lua/codecompanion/strategies/chat/agents/tool_filter.lua

@@ -1,38 +1,46 @@
+local hash = require("codecompanion.utils.hash")
 local log = require("codecompanion.utils.log")
 
 ---@class CodeCompanion.Agent.ToolFilter
 local ToolFilter = {}
 
 local _enabled_cache = {}
 local _cache_timestamp = 0
+local _config_hash = nil
 local CACHE_TTL = 30000
 
 ---Clear the enabled tools cache
 ---@return nil
 local function clear_cache()
   _enabled_cache = {}
   _cache_timestamp = 0
+  _config_hash = nil
   log:trace("[Tool Filter] Cache cleared")
 end
 
----Check if the cache is valid
+---Check if the cache is valid (time + config unchanged)
+---@param tools_config_hash integer The hash of the tools config
 ---@return boolean
-local function is_cache_valid()
-  return vim.loop.now() - _cache_timestamp < CACHE_TTL
+local function is_cache_valid(tools_config_hash)
+  local time_valid = vim.loop.now() - _cache_timestamp < CACHE_TTL
+  local config_unchanged = _config_hash == tools_config_hash
+  return time_valid and config_unchanged
 end
 
 ---Get enabled tools from the cache or compute them
 ---@param tools_config table The tools configuration
 ---@return table<string, boolean> Map of tool names to enabled status
 local function get_enabled_tools(tools_config)
-  if is_cache_valid() and next(_enabled_cache) then
+  local current_hash = hash.hash(tools_config)
+  if is_cache_valid(current_hash) and next(_enabled_cache) then
     log:trace("[Tool Filter] Using cached enabled tools")
     return _enabled_cache
   end
 
   log:trace("[Tool Filter] Computing enabled tools")
   _enabled_cache = {}
   _cache_timestamp = vim.loop.now()
+  _config_hash = current_hash
 
   for tool_name, tool_config in pairs(tools_config) do
     -- Skip special keys

lua/codecompanion/strategies/chat/init.lua

@@ -857,6 +857,9 @@ function Chat:submit(opts)
     opts.callback()
   end
 
+  -- Refresh agent tools before submitting to pick up any dynamically added tools
+  self.agents:refresh_tools()
+
   local bufnr = self.bufnr
 
   if opts.auto_submit then

tests/strategies/chat/agents/test_agents.lua

@@ -83,6 +83,34 @@ T["Agent"][":find"]["should not find a group when tool name starts with group na
   h.eq({}, result.groups)
 end
 
+T["Agent"][":find"]["should find tools added after a chat is initialized"] = function()
+  child.lua([[
+    --- DO NOT DELETE THIS ---
+    --- WE ARE USING THE `codecompanion.config` instead of `tests.config` AS PER #1693 ---
+    local config = require("codecompanion.config")
+    
+    -- Add a dynamic tool after chat is already created
+    config.strategies.chat.tools.dynamic_test_tool = {
+    callback = "",
+      description = "Dynamic tool",
+      enabled = true,
+    }
+    
+    -- Submit a message with the dynamic tool - this should trigger refresh
+    _G.chat:add_buf_message({
+      role = "user",
+      content = "Use @{dynamic_test_tool} please",
+    })
+    _G.chat:submit()
+    
+    _G.found_dynamic_tool = _G.chat.tools.in_use["dynamic_test_tool"] 
+    -- Clean up
+    config.strategies.chat.tools.dynamic_test_tool = nil
+  ]])
+
+  h.eq(true, child.lua_get("_G.found_dynamic_tool"))
+end
+
 T["Agent"][":parse"] = new_set()
 T["Agent"][":parse"]["add a tool's system prompt to chat buffer"] = function()
   child.lua([[

tests/strategies/chat/agents/test_tool_filter.lua

@@ -66,4 +66,71 @@ T["filters disabled tools in groups"] = function()
   h.eq(filtered.groups.empty_group, nil) -- Empty group should be removed
 end
 
+T["cache invalidation"] = new_set()
+
+T["cache invalidation"]["detects config changes when tools are added"] = function()
+  local initial_config = {
+    tool1 = { callback = "test", enabled = true },
+    opts = {},
+  }
+
+  -- First call - should cache
+  local filtered1 = ToolFilter.filter_enabled_tools(initial_config)
+  h.eq(filtered1.tool1 ~= nil, true)
+  h.eq(filtered1.tool2, nil)
+
+  -- Add a new tool to the config
+  initial_config.tool2 = { callback = "test", enabled = true }
+
+  -- Second call - should detect config change and return new tool
+  local filtered2 = ToolFilter.filter_enabled_tools(initial_config)
+  h.eq(filtered2.tool1 ~= nil, true)
+  h.eq(filtered2.tool2 ~= nil, true)
+end
+
+T["cache invalidation"]["detects config changes when tools are removed"] = function()
+  local config = {
+    tool1 = { callback = "test", enabled = true },
+    tool2 = { callback = "test", enabled = true },
+    opts = {},
+  }
+
+  -- First call - should cache both tools
+  local filtered1 = ToolFilter.filter_enabled_tools(config)
+  h.eq(filtered1.tool1 ~= nil, true)
+  h.eq(filtered1.tool2 ~= nil, true)
+
+  -- Remove a tool from the config
+  config.tool2 = nil
+
+  -- Second call - should detect config change and return only remaining tool
+  local filtered2 = ToolFilter.filter_enabled_tools(config)
+  h.eq(filtered2.tool1 ~= nil, true)
+  h.eq(filtered2.tool2, nil)
+end
+
+T["cache invalidation"]["detects changes in groups"] = function()
+  local config = {
+    tool1 = { callback = "test", enabled = true },
+    tool2 = { callback = "test", enabled = true },
+    groups = {
+      test_group = {
+        tools = { "tool1" },
+      },
+    },
+    opts = {},
+  }
+
+  -- First call - should cache
+  local filtered1 = ToolFilter.filter_enabled_tools(config)
+  h.eq(#filtered1.groups.test_group.tools, 1)
+
+  -- Add tool to group
+  config.groups.test_group.tools = { "tool1", "tool2" }
+
+  -- Second call - should detect config change
+  local filtered2 = ToolFilter.filter_enabled_tools(config)
+  h.eq(#filtered2.groups.test_group.tools, 2)
+end
+
 return T