ruby-pi 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0d5744eb38aa0fbf2ff5230ae86a66c85c3ed6c2bdc50fc9bcdd1f0514752fe9
-  data.tar.gz: 8deaa07b7bfe6157de4859ddfb71c68508ef4bc7c3b6ad753bf1a64d44ef597e
+  metadata.gz: 55e144c9f54733981c81f090dad3eb02a4f6cbac0dd4d2a220d972c04133ea97
+  data.tar.gz: abdbb72cfafd293dc30f4517c42dd02f147a41e501034efb7eee2b8af20f9577
 SHA512:
-  metadata.gz: c0c325552e6f82dddcd85c735ce9faa6aa21a8c4424af6b411bae90779a28e32aaecf05c119094d9befd5715e64f16654e435b037561c9446413c2e01c89d898
-  data.tar.gz: cf11a6b47b18beb2c8b35caedb036e44a5a3ccf3c62e96cc5e37209bab237e4c16cb9f05784bfc4d0ce804433964c802fa0699362772adbf1926520717233a78
+  metadata.gz: 608d20395e47a22f7392150e131e5944bab03aabbcc089525c0fcc43f966e3672f3f2cb66e74d34657acdc108b939cbe80fa6b8ba90b281717fb0e1c43cc7242
+  data.tar.gz: d5d0c2f2e1a24928a1b9ee998781f43d1f0d1a5d76aebbcd24d3ed42c11ae132c0c1df10996cbe23676fc94c047d12e456eea5279406484676ddcc3ce3b63068

data/CHANGELOG.md

@@ -5,6 +5,19 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.2] - 2026-04-29
+
+### Fixed
+
+- Anthropic provider: tool result messages (`role: "tool"`) are now converted to `role: "user"` with `tool_result` content blocks containing the matching `tool_use_id`, and consecutive tool results from the same turn are grouped into a single user message as the Messages API requires
+- Anthropic provider: assistant messages with `tool_calls` are now preserved as `tool_use` content blocks (`{type: "tool_use", id:, name:, input:}`) instead of being silently discarded, so the API can match them to subsequent tool results
+- Anthropic and OpenAI providers: structured `content` (Arrays/Hashes, e.g. multimodal vision payloads) is preserved as-is instead of being collapsed by `to_s`
+- OpenAI provider: tool messages now include `tool_call_id` and assistant `tool_calls` are emitted in the full OpenAI function-call structure for proper result matching
+
+### Added
+
+- Comprehensive unit tests for `build_request_body` in both Anthropic and OpenAI providers covering full agent-loop conversations, consecutive tool result grouping, structured content preservation, and string- vs symbol-keyed message edge cases
+
 ## [0.1.1] - 2026-04-28
 
 ### Changed

data/lib/ruby_pi/llm/anthropic.rb

@@ -78,12 +78,29 @@ module RubyPi
 
       # Builds the Anthropic API request body from messages and tools.
       #
+      # Handles three critical conversions from the internal message format to
+      # Anthropic's API format:
+      #
+      # 1. System messages (role: "system") are extracted and promoted to the
+      #    top-level `system:` parameter, since Anthropic does not allow system
+      #    messages in the messages array.
+      #
+      # 2. Tool result messages (role: "tool") are converted to role: "user"
+      #    messages with `tool_result` content blocks. Consecutive tool messages
+      #    are grouped into a single user message, as Anthropic requires.
+      #
+      # 3. Assistant messages that include `tool_calls` are converted to include
+      #    `tool_use` content blocks, so the API can match them to subsequent
+      #    `tool_result` blocks.
+      #
+      # Structured content (Arrays, Hashes) is preserved as-is and never
+      # coerced via `.to_s`, which would destroy the content block structure.
+      #
       # @param messages [Array<Hash>] conversation messages
       # @param tools [Array<Hash>] tool definitions
       # @param stream [Boolean] whether streaming is enabled
       # @return [Hash] the request body
       def build_request_body(messages, tools, stream)
-        # Separate system message from conversation messages
         system_message = nil
         conversation = []
 
@@ -91,10 +108,41 @@ module RubyPi
           role = (msg[:role] || msg["role"]).to_s
           content = msg[:content] || msg["content"]
 
-          if role == "system"
+          case role
+          when "system"
+            # Anthropic requires system prompts as a top-level parameter, not
+            # as a message in the conversation array.
             system_message = content.to_s
+
+          when "tool"
+            # Internal tool-result messages must be converted to Anthropic's
+            # format: role "user" with a tool_result content block. The
+            # tool_use_id links this result back to the assistant's tool_use.
+            tool_result_block = build_tool_result_block(msg)
+
+            # Group consecutive tool results into a single "user" message.
+            # Anthropic requires this because alternating user/assistant roles
+            # means multiple tool results from one turn must share one user msg.
+            if conversation.last && conversation.last[:role] == "user" &&
+               conversation.last[:content].is_a?(Array) &&
+               conversation.last[:content].all? { |b| b[:type] == "tool_result" }
+              # Append to the existing grouped tool_result user message
+              conversation.last[:content] << tool_result_block
+            else
+              conversation << { role: "user", content: [tool_result_block] }
+            end
+
+          when "assistant"
+            # Build the assistant message with proper content blocks.
+            # If the message contains tool_calls, they must be included as
+            # tool_use content blocks so Anthropic can match them to the
+            # subsequent tool_result blocks.
+            conversation << build_assistant_message(msg, content)
+
           else
-            conversation << { role: role, content: content.to_s }
+            # Standard user (or other) messages — preserve structured content
+            # as-is and only convert simple values to strings.
+            conversation << { role: role, content: format_content(content) }
           end
         end
 
@@ -114,6 +162,118 @@ module RubyPi
         body
       end
 
+      # Builds an Anthropic tool_result content block from an internal tool
+      # message. Extracts the tool_call_id and content, handling edge cases
+      # like nil IDs or already-structured content.
+      #
+      # @param msg [Hash] internal tool message with :tool_call_id, :content, :name
+      # @return [Hash] Anthropic tool_result content block
+      def build_tool_result_block(msg)
+        tool_use_id = msg[:tool_call_id] || msg["tool_call_id"]
+        content = msg[:content] || msg["content"]
+
+        block = {
+          type: "tool_result",
+          tool_use_id: tool_use_id || "unknown"
+        }
+
+        # Content can be a simple string or a structured content array.
+        # Preserve structured content as-is; convert simple values to strings.
+        if content.is_a?(Array)
+          block[:content] = content
+        elsif content.is_a?(Hash)
+          block[:content] = [content]
+        elsif content.nil?
+          block[:content] = ""
+        else
+          block[:content] = content.to_s
+        end
+
+        block
+      end
+
+      # Builds an Anthropic-formatted assistant message, including tool_use
+      # content blocks when the message has tool_calls.
+      #
+      # Anthropic represents assistant responses as an array of content blocks.
+      # Text content becomes `{ type: "text", text: "..." }` blocks, and tool
+      # calls become `{ type: "tool_use", id: "...", name: "...", input: {...} }`
+      # blocks. Both can appear in the same message.
+      #
+      # @param msg [Hash] internal assistant message with optional :tool_calls
+      # @param content [String, Array, Hash, nil] the message content
+      # @return [Hash] Anthropic-formatted assistant message
+      def build_assistant_message(msg, content)
+        tool_calls = msg[:tool_calls] || msg["tool_calls"]
+        content_blocks = []
+
+        # Add text content block if present. Content may already be a structured
+        # array (from a previous Anthropic response) — preserve it as-is.
+        if content.is_a?(Array)
+          content_blocks.concat(content)
+        elsif content.is_a?(Hash)
+          content_blocks << content
+        elsif content && !content.to_s.empty?
+          content_blocks << { type: "text", text: content.to_s }
+        end
+
+        # Convert internal tool_calls into Anthropic tool_use content blocks.
+        # Each tool_call has :id, :name, and :arguments from ToolCall#to_h.
+        if tool_calls.is_a?(Array) && !tool_calls.empty?
+          tool_calls.each do |tc|
+            tc_id = tc[:id] || tc["id"]
+            tc_name = tc[:name] || tc["name"]
+            tc_args = tc[:arguments] || tc["arguments"] || {}
+
+            # Ensure arguments is a Hash; parse JSON string if needed
+            tc_input = if tc_args.is_a?(Hash)
+                         tc_args
+                       elsif tc_args.is_a?(String) && !tc_args.empty?
+                         begin
+                           JSON.parse(tc_args)
+                         rescue JSON::ParserError
+                           { "_raw" => tc_args }
+                         end
+                       else
+                         {}
+                       end
+
+            content_blocks << {
+              type: "tool_use",
+              id: tc_id || "unknown",
+              name: tc_name || "unknown",
+              input: tc_input
+            }
+          end
+        end
+
+        # If no content blocks were generated (edge case), add an empty text
+        # block to satisfy Anthropic's requirement for non-empty content.
+        content_blocks << { type: "text", text: "" } if content_blocks.empty?
+
+        { role: "assistant", content: content_blocks }
+      end
+
+      # Formats message content for the Anthropic API, preserving structured
+      # content (Arrays and Hashes) and only converting simple values to strings.
+      #
+      # Anthropic accepts both a plain string and an array of content blocks
+      # for the `content` field. Calling `.to_s` on structured content would
+      # destroy it, so this method passes Arrays and Hashes through unchanged.
+      #
+      # @param content [String, Array, Hash, nil] the raw content value
+      # @return [String, Array, Hash] formatted content suitable for Anthropic
+      def format_content(content)
+        case content
+        when Array, Hash
+          content
+        when nil
+          ""
+        else
+          content.to_s
+        end
+      end
+
       # Converts a tool definition to Anthropic's tool format.
       # Accepts either a RubyPi::Tools::Definition or a plain Hash.
       #

data/lib/ruby_pi/llm/openai.rb

@@ -70,6 +70,20 @@ module RubyPi
 
       # Builds the OpenAI Chat Completions request body.
       #
+      # Handles proper formatting of all message types:
+      #
+      # 1. System messages pass through with role "system" (OpenAI supports them).
+      #
+      # 2. Tool result messages (role: "tool") are formatted with the required
+      #    `tool_call_id` field so OpenAI can match them to the assistant's
+      #    tool_calls.
+      #
+      # 3. Assistant messages with `tool_calls` include the proper OpenAI
+      #    tool_calls structure: `{ id, type: "function", function: { name, arguments } }`.
+      #
+      # Structured content (Arrays, Hashes) is preserved for multimodal content
+      # blocks (e.g., vision messages with image_url content parts).
+      #
       # @param messages [Array<Hash>] conversation messages
       # @param tools [Array<Hash>] tool definitions
       # @param stream [Boolean] whether streaming is enabled
@@ -91,13 +105,101 @@ module RubyPi
 
       # Converts a normalized message hash to OpenAI's message format.
       #
+      # Handles three message types:
+      # - Tool messages (role: "tool"): includes tool_call_id for result matching
+      # - Assistant messages with tool_calls: includes structured tool_calls array
+      # - Standard messages: role + content with structured content preservation
+      #
       # @param message [Hash] a message with :role and :content keys
       # @return [Hash] OpenAI-formatted message
       def format_message(message)
-        {
-          role: (message[:role] || message["role"]).to_s,
-          content: (message[:content] || message["content"]).to_s
+        role = (message[:role] || message["role"]).to_s
+        content = message[:content] || message["content"]
+
+        case role
+        when "tool"
+          # OpenAI accepts role "tool" with a required tool_call_id field
+          # to match this result back to the assistant's tool_call.
+          tool_call_id = message[:tool_call_id] || message["tool_call_id"]
+          {
+            role: "tool",
+            tool_call_id: tool_call_id || "unknown",
+            content: format_content(content)
+          }
+
+        when "assistant"
+          # Assistant messages may include tool_calls that must be preserved
+          # in OpenAI's expected format for conversation continuity.
+          build_assistant_message(message, content)
+
+        else
+          # System and user messages — preserve structured content as-is
+          # for multimodal support (vision, etc.).
+          { role: role, content: format_content(content) }
+        end
+      end
+
+      # Builds an OpenAI-formatted assistant message, including tool_calls
+      # when present. OpenAI requires tool_calls in a specific structure:
+      # `{ id, type: "function", function: { name, arguments } }` where
+      # arguments is a JSON string.
+      #
+      # @param message [Hash] internal assistant message with optional :tool_calls
+      # @param content [String, Array, Hash, nil] the message content
+      # @return [Hash] OpenAI-formatted assistant message
+      def build_assistant_message(message, content)
+        tool_calls = message[:tool_calls] || message["tool_calls"]
+
+        formatted = {
+          role: "assistant",
+          content: format_content(content)
         }
+
+        # Include tool_calls in OpenAI's expected format if present
+        if tool_calls.is_a?(Array) && !tool_calls.empty?
+          formatted[:tool_calls] = tool_calls.map do |tc|
+            tc_id = tc[:id] || tc["id"]
+            tc_name = tc[:name] || tc["name"]
+            tc_args = tc[:arguments] || tc["arguments"] || {}
+
+            # OpenAI requires arguments as a JSON string
+            args_string = if tc_args.is_a?(String)
+                            tc_args
+                          elsif tc_args.is_a?(Hash)
+                            JSON.generate(tc_args)
+                          else
+                            "{}"
+                          end
+
+            {
+              id: tc_id || "unknown",
+              type: "function",
+              function: {
+                name: tc_name || "unknown",
+                arguments: args_string
+              }
+            }
+          end
+        end
+
+        formatted
+      end
+
+      # Formats message content for the OpenAI API, preserving structured
+      # content (Arrays and Hashes) for multimodal messages (e.g., vision)
+      # and only converting simple values to strings.
+      #
+      # @param content [String, Array, Hash, nil] the raw content value
+      # @return [String, Array, Hash, nil] formatted content suitable for OpenAI
+      def format_content(content)
+        case content
+        when Array, Hash
+          content
+        when nil
+          nil
+        else
+          content.to_s
+        end
       end
 
       # Converts a tool definition to OpenAI's function tool format.

data/lib/ruby_pi/version.rb

@@ -7,5 +7,5 @@
 
 module RubyPi
   # The current version of the RubyPi gem, following Semantic Versioning.
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-pi
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - RubyPi Contributors