Handle empty tool results across providers

Author: crmne

lib/ruby_llm/providers/anthropic/tools.rb

@@ -45,10 +45,13 @@ def format_tool_use_block(tool_call)
         end
 
         def format_tool_result_block(msg)
+          content = msg.content
+          content = '(no output)' if content.nil? || (content.respond_to?(:empty?) && content.empty?)
+
           {
             type: 'tool_result',
             tool_use_id: msg.tool_call_id,
-            content: Media.format_content(msg.content)
+            content: Media.format_content(content)
           }
         end
 

lib/ruby_llm/providers/bedrock/chat.rb

@@ -154,19 +154,23 @@ def render_tool_result_block(msg)
 
         def render_tool_result_content(content)
           return render_raw_tool_result_content(content.value) if content.is_a?(RubyLLM::Content::Raw)
+          return [{ json: content }] if content.is_a?(Hash) || content.is_a?(Array)
+          return render_content_tool_result_content(content) if content.is_a?(RubyLLM::Content)
 
-          if content.is_a?(Hash) || content.is_a?(Array)
-            [{ json: content }]
-          elsif content.is_a?(RubyLLM::Content)
-            blocks = []
-            blocks << { text: content.text } if content.text
-            content.attachments.each do |attachment|
-              blocks << { text: attachment.for_llm }
-            end
-            blocks
-          else
-            [{ text: content.to_s }]
-          end
+          [text_tool_result_block(content)]
+        end
+
+        def render_content_tool_result_content(content)
+          blocks = []
+          blocks << text_tool_result_block(content.text) unless content.text.to_s.empty?
+          content.attachments.each { |attachment| blocks << text_tool_result_block(attachment.for_llm) }
+          blocks.empty? ? [text_tool_result_block(nil)] : blocks
+        end
+
+        def text_tool_result_block(text)
+          text = text.to_s
+          text = '(no output)' if text.empty?
+          { text: text }
         end
 
         def render_raw_tool_result_content(raw_value)

lib/ruby_llm/providers/gemini/tools.rb

@@ -46,13 +46,15 @@ def format_tool_call(msg) # rubocop:disable Metrics/PerceivedComplexity
 
         def format_tool_result(msg, function_name = nil)
           function_name ||= msg.tool_call_id
+          content = msg.content
+          content = '(no output)' if content.nil? || (content.respond_to?(:empty?) && content.empty?)
 
           [{
             functionResponse: {
               name: function_name,
               response: {
                 name: function_name,
-                content: Media.format_content(msg.content)
+                content: Media.format_content(content)
               }
             }
           }]

spec/ruby_llm/providers/anthropic/tools_spec.rb

@@ -164,6 +164,30 @@
                              ]
                            })
     end
+
+    it 'uses a placeholder when the tool returns no content' do
+      msg = instance_double(RubyLLM::Message,
+                            tool_call_id: 'tool_123',
+                            content: '')
+
+      result = tools.format_tool_result(msg)
+
+      expect(result).to eq({
+                             role: 'user',
+                             content: [
+                               {
+                                 type: 'tool_result',
+                                 tool_use_id: 'tool_123',
+                                 content: [
+                                   {
+                                     type: 'text',
+                                     text: '(no output)'
+                                   }
+                                 ]
+                               }
+                             ]
+                           })
+    end
   end
 
   describe '.parse_tool_calls' do

spec/ruby_llm/providers/bedrock/chat_spec.rb

@@ -3,6 +3,14 @@
 require 'spec_helper'
 
 RSpec.describe RubyLLM::Providers::Bedrock::Chat do
+  describe '.render_tool_result_content' do
+    it 'uses a placeholder when the tool returns no content' do
+      result = described_class.render_tool_result_content('')
+
+      expect(result).to eq([{ text: '(no output)' }])
+    end
+  end
+
   describe '.render_payload' do
     let(:model) do
       instance_double(RubyLLM::Model::Info,

spec/ruby_llm/providers/gemini/tools_spec.rb

@@ -72,5 +72,27 @@
                              }
                            ])
     end
+
+    it 'uses a placeholder when the tool returns no content' do
+      message = RubyLLM::Message.new(
+        role: :tool,
+        content: '',
+        tool_call_id: 'uuid-123'
+      )
+
+      result = test_obj.format_tool_result(message)
+
+      expect(result).to eq([
+                             {
+                               functionResponse: {
+                                 name: 'uuid-123',
+                                 response: {
+                                   name: 'uuid-123',
+                                   content: [{ text: '(no output)' }]
+                                 }
+                               }
+                             }
+                           ])
+    end
   end
 end