olimorris
diff --git a/‎lua/codecompanion/adapters/anthropic.lua
Copy file name to clipboard
+58-16Lines changed: 58 additions & 16 deletions b/‎lua/codecompanion/adapters/anthropic.lua
Copy file name to clipboard
+58-16Lines changed: 58 additions & 16 deletions
diff --git a/‎lua/codecompanion/adapters/deepseek.lua
Copy file name to clipboard
+5-3Lines changed: 5 additions & 3 deletions b/‎lua/codecompanion/adapters/deepseek.lua
Copy file name to clipboard
+5-3Lines changed: 5 additions & 3 deletions
diff --git a/‎lua/codecompanion/adapters/init.lua
Copy file name to clipboard
+4-3Lines changed: 4 additions & 3 deletions b/‎lua/codecompanion/adapters/init.lua
Copy file name to clipboard
+4-3Lines changed: 4 additions & 3 deletions
diff --git a/‎lua/codecompanion/strategies/chat/init.lua
Copy file name to clipboard
+43-16Lines changed: 43 additions & 16 deletions b/‎lua/codecompanion/strategies/chat/init.lua
Copy file name to clipboard
+43-16Lines changed: 43 additions & 16 deletions
diff --git a/‎lua/codecompanion/strategies/chat/ui/builder.lua
Copy file name to clipboard
+8-14Lines changed: 8 additions & 14 deletions b/‎lua/codecompanion/strategies/chat/ui/builder.lua
Copy file name to clipboard
+8-14Lines changed: 8 additions & 14 deletions
@@ -11,8 +11,9 @@ local output_tokens = 0
 ---@return table The filtered message
 local function filter_out_messages(message)
   local allowed = {
-    "role",
     "content",
+    "role",
+    "reasoning",
     "tool_calls",
   }
 
@@ -105,7 +106,7 @@ return {
       return params
     end,
 
-    ---Set the format of the role and content for the messages from the chat buffer
+    ---Set the format of the role and content for the messages that are sent from the chat buffer to the LLM
     ---@param self CodeCompanion.Adapter
     ---@param messages table Format is: { { role = "user", content = "Your prompt here" } }
     ---@return table
@@ -160,20 +161,20 @@ return {
         -- 4. Remove disallowed keys
         message = filter_out_messages(message)
 
-        -- 5. Turn string content into { { type = "text", text } }
-        if
-          (message.role == self.roles.user or message.role == self.roles.llm)
-          and type(message.content) == "string"
-        then
+        -- 5. Turn string content into { { type = "text", text } } and add in the reasoning
+        if message.role == self.roles.user or message.role == self.roles.llm then
           -- Anthropic doesn't allow the user to submit an empty prompt. But
           -- this can be necessary to prompt the LLM to analyze any tool
           -- calls and their output
           if message.role == self.roles.user and message.content == "" then
             message.content = "<prompt></prompt>"
           end
-          message.content = {
-            { type = "text", text = message.content },
-          }
+
+          if type(message.content) == "string" then
+            message.content = {
+              { type = "text", text = message.content },
+            }
+          end
         end
 
         if message.tool_calls and vim.tbl_count(message.tool_calls) > 0 then
@@ -199,13 +200,23 @@ return {
           message.tool_calls = nil
         end
 
+        -- 8. If reasoning is present, format it as a content block
+        if message.reasoning and type(message.content) == "table" then
+          -- Ref: https://docs.anthropic.com/en/docs/build-with-claude/extended-thinking#how-extended-thinking-works
+          table.insert(message.content, 1, {
+            type = "thinking",
+            thinking = message.reasoning.content,
+            signature = message.reasoning._data.signature,
+          })
+        end
+
         return message
       end, messages)
 
-      -- 8. Merge consecutive messages with the same role
+      -- 9. Merge consecutive messages with the same role
       messages = utils.merge_messages(messages)
 
-      -- 9. Ensure that any consecutive tool results are merged
+      -- 10. Ensure that any consecutive tool results are merged
       if has_tools then
         for _, m in ipairs(messages) do
           if m.role == self.roles.user and m.content and m.content ~= "" then
@@ -236,7 +247,7 @@ return {
         end
       end
 
-      -- 10+. Cache large messages per opts.cache_over / cache_breakpoints
+      -- 11+. Cache large messages per opts.cache_over / cache_breakpoints
       local breakpoints_used = 0
       for i = #messages, 1, -1 do
         local msgs = messages[i]
@@ -268,6 +279,31 @@ return {
       return { system = system, messages = messages }
     end,
 
+    ---Form the reasoning output that is stored in the chat buffer
+    ---@param self CodeCompanion.Adapter
+    ---@param data table The reasoning output from the LLM
+    ---@return nil|{ content: string, _data: table }
+    form_reasoning = function(self, data)
+      local content = vim
+        .iter(data)
+        :map(function(item)
+          return item.content
+        end)
+        :filter(function(content)
+          return content ~= nil
+        end)
+        :join("")
+
+      local signature = data[#data].signature
+
+      return {
+        content = content,
+        _data = {
+          signature = signature,
+        },
+      }
+    end,
+
     ---Provides the schemas of the tools that are available to the LLM to call
     ---@param self CodeCompanion.Adapter
     ---@param tools table<string, table>
@@ -344,7 +380,8 @@ return {
             output.content = ""
           elseif json.type == "content_block_start" then
             if json.content_block.type == "thinking" then
-              output.reasoning = ""
+              output.reasoning = output.reasoning or {}
+              output.reasoning.content = ""
             end
             if json.content_block.type == "tool_use" and tools then
               -- Source: https://docs.anthropic.com/en/docs/build-with-claude/tool-use/overview#single-tool-example
@@ -357,7 +394,11 @@ return {
             end
           elseif json.type == "content_block_delta" then
             if json.delta.type == "thinking_delta" then
-              output.reasoning = json.delta.thinking
+              output.reasoning = output.reasoning or {}
+              output.reasoning.content = json.delta.thinking
+            elseif json.delta.type == "signature_delta" then
+              output.reasoning = output.reasoning or {}
+              output.reasoning.signature = json.delta.signature
             else
               output.content = json.delta.text
               if json.delta.partial_json and tools then
@@ -376,7 +417,8 @@ return {
               if content.type == "text" then
                 output.content = (output.content or "") .. content.text
               elseif content.type == "thinking" then
-                output.reasoning = content.text
+                output.reasoning = output.reasoning and output.reasoning or {}
+                output.reasoning.content = content.text
               elseif content.type == "tool_use" and tools then
                 table.insert(tools, {
                   _index = i,
 
@@ -94,9 +94,11 @@ return {
 
           if delta then
             output.role = delta.role
-            output.reasoning = delta.reasoning_content
-            if delta.content then
-              output.content = (output.content or "") .. delta.content
+            output.content = delta.content
+
+            if delta.reasoning_content then
+              output.reasoning = output.reasoning or {}
+              output.reasoning.content = delta.reasoning_content
             end
 
             -- Process tools
 
@@ -21,12 +21,13 @@ local log = require("codecompanion.utils.log")
 ---@field handlers.set_body? fun(self: CodeCompanion.Adapter, data: table): table|nil
 ---@field handlers.form_parameters fun(self: CodeCompanion.Adapter, params: table, messages: table): table
 ---@field handlers.form_messages fun(self: CodeCompanion.Adapter, messages: table): table
----@field handlers.form_tools fun(self: CodeCompanion.Adapter, tools: table): table
+---@field handlers.form_reasoning? fun(self: CodeCompanion.Adapter, messages: table): nil|{ content: string, _data: table }
+---@field handlers.form_tools? fun(self: CodeCompanion.Adapter, tools: table): table
 ---@field handlers.tokens? fun(self: CodeCompanion.Adapter, data: table): number|nil
 ---@field handlers.chat_output fun(self: CodeCompanion.Adapter, data: table, tools: table): table|nil
 ---@field handlers.inline_output fun(self: CodeCompanion.Adapter, data: table, context: table): table|nil
----@field handlers.tools.format fun(self: CodeCompanion.Adapter, tools: table): table
----@field handlers.tools.output_tool_call fun(self: CodeCompanion.Adapter, tool_call: table, output: string): table
+---@field handlers.tools.format? fun(self: CodeCompanion.Adapter, tools: table): table
+---@field handlers.tools.output_tool_call? fun(self: CodeCompanion.Adapter, tool_call: table, output: string): table
 ---@field handlers.on_exit? fun(self: CodeCompanion.Adapter, data: table): table|nil
 ---@field handlers.teardown? fun(self: CodeCompanion.Adapter): any
 ---@field schema table Set of parameters for the generative AI service that the user can customise in the chat buffer
 
@@ -514,6 +514,7 @@ local Chat = {}
 
 Chat.MESSAGE_TYPES = {
   LLM_MESSAGE = "llm_message",
+  REASONING_MESSAGE = "reasoning_message",
   SYSTEM_MESSAGE = "system_message",
   TOOL_MESSAGE = "tool_message",
   USER_MESSAGE = "user_message",
@@ -809,7 +810,7 @@ function Chat:remove_tagged_message(tag)
 end
 
 ---Add a message to the message table
----@param data { role: string, content: string, tool_calls?: table }
+---@param data { role: string, content: string, reasoning?: table, tool_calls?: table }
 ---@param opts? table Options for the message
 ---@return CodeCompanion.Chat
 function Chat:add_message(data, opts)
@@ -821,6 +822,7 @@ function Chat:add_message(data, opts)
   local message = {
     role = data.role,
     content = data.content,
+    reasoning = data.reasoning,
     tool_calls = data.tool_calls,
   }
   message.id = make_id(message)
@@ -928,6 +930,7 @@ function Chat:submit(opts)
   log:info("Chat request started")
 
   local output = {}
+  local reasoning = {}
   local tools = {}
   self.current_request = client.new({ adapter = mapped_settings }):request(payload, {
     ---@param err { message: string, stderr: string }
@@ -956,8 +959,20 @@ function Chat:submit(opts)
               self._last_role = result.output.role
               result.output.role = config.constants.LLM_ROLE
             end
-            table.insert(output, result.output.content)
-            self:add_buf_message(result.output, { type = self.MESSAGE_TYPES.LLM_MESSAGE })
+            if result.output.reasoning then
+              table.insert(reasoning, result.output.reasoning)
+              self:add_buf_message(
+                { role = result.output.role, content = result.output.reasoning.content },
+                { type = self.MESSAGE_TYPES.REASONING_MESSAGE }
+              )
+            end
+            if result.output.content then
+              table.insert(output, result.output.content)
+              self:add_buf_message(
+                { role = result.output.role, content = result.output.content },
+                { type = self.MESSAGE_TYPES.LLM_MESSAGE }
+              )
+            end
           elseif self.status == CONSTANTS.STATUS_ERROR then
             log:error("Error: %s", result.output)
             return self:done(output)
@@ -966,7 +981,7 @@ function Chat:submit(opts)
       end
     end,
     done = function()
-      self:done(output, tools)
+      self:done(output, reasoning, tools)
     end,
   }, { bufnr = bufnr, strategy = "chat" })
   util.fire("ChatSubmitted", { bufnr = self.bufnr, id = self.id })
@@ -981,35 +996,47 @@ function Chat:tools_done(opts)
 end
 
 ---Method to call after the response from the LLM is received
----@param output? table The output from the LLM
----@param tools? table The tools from the LLM
+---@param output? table The message output from the LLM
+---@param reasoning? table The reasoning output from the LLM
+---@param tools? table The tools output from the LLM
 ---@return nil
-function Chat:done(output, tools)
+function Chat:done(output, reasoning, tools)
   self.current_request = nil
 
   -- Commonly, a status may not be set if the message exceeds a token limit
   if not self.status or self.status == "" then
     return self:reset()
   end
-
-  local has_tools = tools and not vim.tbl_isempty(tools)
   local has_output = output and not vim.tbl_isempty(output)
+  local has_tools = tools and not vim.tbl_isempty(tools)
 
-  -- Handle LLM output text
+  local content
   if has_output then
-    local content = vim.trim(table.concat(output or {}, "")) -- No idea why the LSP freaks out that this isn't a table
-    if content ~= "" then
-      self:add_message({
-        role = config.constants.LLM_ROLE,
-        content = content,
-      })
+    content = vim.trim(table.concat(output or {}, ""))
+  end
+
+  local reasoning_content = nil
+  if reasoning and not vim.tbl_isempty(reasoning) then
+    if self.adapter.handlers.form_reasoning then
+      reasoning_content = self.adapter.handlers.form_reasoning(self.adapter, reasoning)
     end
   end
 
+  if content and content ~= "" then
+    self:add_message({
+      role = config.constants.LLM_ROLE,
+      content = content,
+      reasoning = reasoning_content,
+    })
+    reasoning_content = nil
+  end
+
+  -- Process tools last
   if has_tools then
     tools = self.adapter.handlers.tools.format_tool_calls(self.adapter, tools)
     self:add_message({
       role = config.constants.LLM_ROLE,
+      reasoning = reasoning_content,
       tool_calls = tools,
     }, {
       visible = false,
 
@@ -74,22 +74,22 @@ function Builder:add_message(data, opts)
   local fold_info = nil
   local current_type = nil
 
-  -- Create rich formatting state for this message
   local state = create_state(self.state)
 
   local needs_header = self:_should_add_header(data, opts, state)
-  local needs_new_section = self:_should_start_new_section(data, opts, state)
+  local needs_section = self:_should_start_new_section(opts, state)
 
   if needs_header then
     state:update_role(data.role)
     self:_add_header_spacing(lines, state)
     self.chat.ui:set_header(lines, config.strategies.chat.roles[data.role])
-  elseif needs_new_section then
+  elseif needs_section then
     state:start_new_section()
   end
 
-  -- Format content - pass rich state to formatters
-  if data.content or data.reasoning then
+  local has_content = data.content or (data.reasoning and data.reasoning.content)
+
+  if has_content then
     local formatter = self:_get_formatter(data, opts)
     local content_lines, content_fold_info = formatter:format(data, opts, state)
 
@@ -104,39 +104,35 @@ function Builder:add_message(data, opts)
     end
   end
 
-  -- Write to buffer
   if not vim.tbl_isempty(lines) then
     self:_write_to_buffer(lines, opts, fold_info, state)
   end
 
-  -- Update persistent state from rich state
   if current_type then
     state:update_type(current_type)
   end
 
-  -- Sync state back to builder for persistence
   self:_sync_state_from_formatting_state(state)
   self:_sync_state_to_chat()
 end
 
 ---Determine if we should start a new section under the header
----@param data table
 ---@param opts table
 ---@param state table
 ---@return boolean
-function Builder:_should_start_new_section(data, opts, state)
+function Builder:_should_start_new_section(opts, state)
   if not opts.type then
     return false
   end
 
   local tags = self.chat.MESSAGE_TYPES
 
   return (opts.type == tags.TOOL_MESSAGE and state.last_type ~= tags.TOOL_MESSAGE)
-    or (opts.type == tags.REASONING and not state.has_reasoning_output)
+    or (opts.type == tags.REASONING_MESSAGE and state.last_type ~= tags.REASONING_MESSAGE)
     or (opts.type == tags.LLM_MESSAGE and state.last_type ~= tags.LLM_MESSAGE)
 end
 
----Check if we need a header
+---Check if we need to add a header to the chat buffer
 ---@param data table
 ---@param opts table
 ---@param state table
@@ -202,12 +198,10 @@ function Builder:_write_to_buffer(lines, opts, fold_info, state)
     self.chat.ui.tools:create_fold(fold_start, fold_end, fold_info.first_line)
   end
 
-  -- Render headers if new response
   if state.is_new_response then
     self.chat.ui:render_headers()
   end
 
-  -- Lock buffer if not user role
   if state.last_role ~= config.constants.USER_ROLE then
     self.chat.ui:lock_buf()
   end