Fix handling of multiple tool calls in single LLM response

Previously, the library only processed the first tool call when an LLM
returned multiple tool_use blocks in a single response. This limitation
prevented parallel function execution, a key feature of modern LLMs.

Changes:
- Update Anthropic provider to extract ALL tool_use blocks from responses
- Modify tool parser to handle arrays of content blocks
- Ensure all tools execute before continuing the conversation
- Add comprehensive tests for multi-tool scenarios across all providers

This enables use cases like:
- Executing multiple independent operations in parallel
- Rolling dice multiple times in one request
- Fetching data from multiple sources simultaneously

The implementation maintains backward compatibility while extending
support for advanced parallel tool calling capabilities.

Fixes the limitation where only the first tool call was processed
when multiple were requested.

Author: finbarr

lib/ruby_llm/providers/anthropic/chat.rb

@@ -55,21 +55,21 @@ def parse_completion_response(response)
           content_blocks = data['content'] || []
 
           text_content = extract_text_content(content_blocks)
-          tool_use = Tools.find_tool_use(content_blocks)
+          tool_use_blocks = content_blocks.select { |c| c['type'] == 'tool_use' }
 
-          build_message(data, text_content, tool_use)
+          build_message(data, text_content, tool_use_blocks)
         end
 
         def extract_text_content(blocks)
           text_blocks = blocks.select { |c| c['type'] == 'text' }
           text_blocks.map { |c| c['text'] }.join
         end
 
-        def build_message(data, content, tool_use)
+        def build_message(data, content, tool_use_blocks)
           Message.new(
             role: :assistant,
             content: content,
-            tool_calls: Tools.parse_tool_calls(tool_use),
+            tool_calls: Tools.parse_tool_calls(tool_use_blocks),
             input_tokens: data.dig('usage', 'input_tokens'),
             output_tokens: data.dig('usage', 'output_tokens'),
             model_id: data['model']

lib/ruby_llm/providers/anthropic/tools.rb

@@ -12,11 +12,13 @@ def find_tool_use(blocks)
         end
 
         def format_tool_call(msg)
-          tool_call = msg.tool_calls.values.first
-
           content = []
+
           content << Media.format_text(msg.content) unless msg.content.nil? || msg.content.empty?
-          content << format_tool_use_block(tool_call)
+
+          msg.tool_calls.each_value do |tool_call|
+            content << format_tool_use_block(tool_call)
+          end
 
           {
             role: 'assistant',
@@ -68,16 +70,24 @@ def extract_tool_calls(data)
           end
         end
 
-        def parse_tool_calls(content_block)
-          return nil unless content_block && content_block['type'] == 'tool_use'
+        def parse_tool_calls(content_blocks)
+          return nil if content_blocks.nil?
 
-          {
-            content_block['id'] => ToolCall.new(
-              id: content_block['id'],
-              name: content_block['name'],
-              arguments: content_block['input']
+          # Handle single content block (backward compatibility)
+          content_blocks = [content_blocks] unless content_blocks.is_a?(Array)
+
+          tool_calls = {}
+          content_blocks.each do |block|
+            next unless block && block['type'] == 'tool_use'
+
+            tool_calls[block['id']] = ToolCall.new(
+              id: block['id'],
+              name: block['name'],
+              arguments: block['input']
             )
-          }
+          end
+
+          tool_calls.empty? ? nil : tool_calls
         end
 
         def clean_parameters(parameters)