ai-agents 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c143345c7d0dd3a91ff483e0db22a7d23f6c85393275727eddcaf288a1341901
-  data.tar.gz: 0f1abfe692571706be41b85a1da924a717f980b8721b21ece7dd62ad4e995fbf
+  metadata.gz: 6391e30443ff9e226e6b3bf3f629f3cd996cbb7fe4479c7a7dc437c82544ae2f
+  data.tar.gz: 22fc6ee4f3130006c1dd1f6c8fb704a176457d35602a434088d25cea5dd3c949
 SHA512:
-  metadata.gz: 74c96799a138a5e725b3e889eba22c45e9581e7606a0cd235cecd50b8bdde1c6f10281ec1516fde77f48373c39022d2f72172be8c29489260df79fb575d92de8
-  data.tar.gz: 257fd42a178107182a53eb737848ae1a023c28712ac450c4603b12cb60e2ad39dbe7b957a324bd6c24a3a175af8b7c373ec30e25e36425e81642a8f160da7ceb
+  metadata.gz: ae3866cfbec885088c5b41b0e91bbc8532fc3115ed981c3428f56c09b40c1a75bc9bb1277ed1991f19cee4c43118c3f9a5d9ea8d6ecc07d29ad03117a77666e6
+  data.tar.gz: b7de2e98dc3ce52b4c80b7b1bcfa4fb1f07f62176d861ab61b9a1092d2de4273657d54edfa18d6afd83acccee21c89e465f18539b8966c5f9645a673b4e5a3c4

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.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+## [0.8.0] - 2026-01-07
+
+### Added
+- **Provider Smoke Tests**: Comprehensive smoke tests for validating against the latest RubyLLM version
+
+### Changed
+- **RubyLLM Update**: Updated to latest RubyLLM version with improved API integration and tool call handling
+
+### Fixed
+- **Tool Message Restoration**: Fixed conversation history restoration to properly handle tool calls and results
+
 ## [0.7.0] - 2025-10-16
 
 ### Added

data/lib/agents/helpers/message_extractor.rb

@@ -54,28 +54,35 @@ module Agents
       end
 
       def extract_user_or_assistant_message(msg, current_agent)
-        return nil unless msg.content && !content_empty?(msg.content)
+        content_present = message_content?(msg)
+        tool_calls_present = assistant_tool_calls?(msg)
+        return nil unless content_present || tool_calls_present
 
         message = {
           role: msg.role,
-          content: msg.content
+          content: content_present ? msg.content : ""
         }
 
-        if msg.role == :assistant
-          # Add agent attribution for conversation continuity
-          message[:agent_name] = current_agent.name if current_agent
+        return message unless msg.role == :assistant
 
-          # Add tool calls if present
-          if msg.tool_call? && msg.tool_calls
-            # RubyLLM stores tool_calls as Hash with call_id => ToolCall object
-            # Reference: RubyLLM::StreamAccumulator#tool_calls_from_stream
-            message[:tool_calls] = msg.tool_calls.values.map(&:to_h)
-          end
+        message[:agent_name] = current_agent.name if current_agent
+
+        if tool_calls_present
+          # RubyLLM stores tool_calls as Hash with call_id => ToolCall object
+          # Reference: RubyLLM::StreamAccumulator#tool_calls_from_stream
+          message[:tool_calls] = msg.tool_calls.values.map(&:to_h)
         end
 
         message
       end
-      private_class_method :extract_user_or_assistant_message
+
+      def message_content?(msg)
+        msg.content && !content_empty?(msg.content)
+      end
+
+      def assistant_tool_calls?(msg)
+        msg.role == :assistant && msg.tool_call? && msg.tool_calls && !msg.tool_calls.empty?
+      end
 
       def extract_tool_message(msg)
         return nil unless msg.tool_result?
@@ -86,7 +93,9 @@ module Agents
           tool_call_id: msg.tool_call_id
         }
       end
-      private_class_method :extract_tool_message
+
+      private_class_method :extract_user_or_assistant_message, :message_content?, :assistant_tool_calls?,
+                           :extract_tool_message
     end
   end
 end

data/lib/agents/run_context.rb

@@ -94,15 +94,21 @@ module Agents
       end
 
       # Add usage metrics from an LLM response to the running totals.
-      # Safely handles nil values in the usage object.
+      # Only tracks usage for responses that have token data (e.g., RubyLLM::Message).
+      # Safely skips responses without token methods (e.g., RubyLLM::Tool::Halt).
       #
-      # @param usage [Object] An object responding to input_tokens, output_tokens, and total_tokens
+      # @param response [RubyLLM::Message] A RubyLLM::Message object with token usage data
       # @example Adding usage from an LLM response
-      #   usage.add(llm_response.usage)
-      def add(usage)
-        @input_tokens += usage.input_tokens || 0
-        @output_tokens += usage.output_tokens || 0
-        @total_tokens += usage.total_tokens || 0
+      #   usage.add(llm_response)
+      def add(response)
+        return unless response.respond_to?(:input_tokens)
+
+        input = response.input_tokens || 0
+        output = response.output_tokens || 0
+
+        @input_tokens += input
+        @output_tokens += output
+        @total_tokens += input + output
       end
     end
   end

data/lib/agents/runner.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "set"
+
 module Agents
   # The execution engine that orchestrates conversations between users and agents.
   # Runner manages the conversation flow, handles tool execution through RubyLLM,
@@ -118,6 +120,7 @@ module Agents
                    chat.complete
                  end
         response = result
+        track_usage(response, context_wrapper)
 
         # Check for handoff via RubyLLM's halt mechanism
         if response.is_a?(RubyLLM::Tool::Halt) && context_wrapper.context[:pending_handoff]
@@ -264,26 +267,98 @@ module Agents
 
     # Restores conversation history from context into RubyLLM chat.
     # Converts stored message hashes back into RubyLLM::Message objects with proper content handling.
+    # Supports user, assistant, and tool role messages for complete conversation continuity.
     #
     # @param chat [RubyLLM::Chat] The chat instance to restore history into
     # @param context_wrapper [RunContext] Context containing conversation history
     def restore_conversation_history(chat, context_wrapper)
       history = context_wrapper.context[:conversation_history] || []
+      valid_tool_call_ids = Set.new
 
       history.each do |msg|
-        # Only restore user and assistant messages with content
-        next unless %i[user assistant].include?(msg[:role].to_sym)
-        next unless msg[:content] && !Helpers::MessageExtractor.content_empty?(msg[:content])
+        next unless restorable_message?(msg)
 
-        # Extract text content safely - handle both string and hash content
-        content = RubyLLM::Content.new(msg[:content])
+        if msg[:role].to_sym == :tool &&
+           msg[:tool_call_id] &&
+           !valid_tool_call_ids.include?(msg[:tool_call_id])
+          Agents.logger&.warn("Skipping tool message without matching assistant tool_call_id #{msg[:tool_call_id]}")
+          next
+        end
 
-        # Create a proper RubyLLM::Message and pass it to add_message
-        message = RubyLLM::Message.new(
-          role: msg[:role].to_sym,
-          content: content
-        )
+        message_params = build_message_params(msg)
+        next unless message_params # Skip invalid messages
+
+        message = RubyLLM::Message.new(**message_params)
         chat.add_message(message)
+
+        if message.role == :assistant && message_params[:tool_calls]
+          valid_tool_call_ids.merge(message_params[:tool_calls].keys)
+        end
+      end
+    end
+
+    # Check if a message should be restored
+    def restorable_message?(msg)
+      role = msg[:role].to_sym
+      return false unless %i[user assistant tool].include?(role)
+
+      # Allow assistant messages that only contain tool calls (no text content)
+      tool_calls_present = role == :assistant && msg[:tool_calls] && !msg[:tool_calls].empty?
+      return false if role != :tool && !tool_calls_present &&
+                      Helpers::MessageExtractor.content_empty?(msg[:content])
+
+      true
+    end
+
+    # Build message parameters for restoration
+    def build_message_params(msg)
+      role = msg[:role].to_sym
+
+      content_value = msg[:content]
+      # Assistant tool-call messages may have empty text, but still need placeholder content
+      content_value = "" if content_value.nil? && role == :assistant && msg[:tool_calls]&.any?
+
+      params = {
+        role: role,
+        content: RubyLLM::Content.new(content_value)
+      }
+
+      # Handle tool-specific parameters (Tool Results)
+      if role == :tool
+        return nil unless valid_tool_message?(msg)
+
+        params[:tool_call_id] = msg[:tool_call_id]
+      end
+
+      # FIX: Restore tool_calls on assistant messages
+      # This is required by OpenAI/Anthropic API contracts to link
+      # subsequent tool result messages back to this request.
+      if role == :assistant && msg[:tool_calls] && !msg[:tool_calls].empty?
+        # Convert stored array of hashes back into the Hash format RubyLLM expects
+        # RubyLLM stores tool_calls as: { call_id => ToolCall_object, ... }
+        # Reference: openai/tools.rb:35 uses hash iteration |_, tc|
+        params[:tool_calls] = msg[:tool_calls].each_with_object({}) do |tc, hash|
+          tool_call_id = tc[:id] || tc["id"]
+          next unless tool_call_id
+
+          hash[tool_call_id] = RubyLLM::ToolCall.new(
+            id: tool_call_id,
+            name: tc[:name] || tc["name"],
+            arguments: tc[:arguments] || tc["arguments"] || {}
+          )
+        end
+      end
+
+      params
+    end
+
+    # Validate tool message has required tool_call_id
+    def valid_tool_message?(msg)
+      if msg[:tool_call_id]
+        true
+      else
+        Agents.logger&.warn("Skipping tool message without tool_call_id in conversation history")
+        false
       end
     end
 
@@ -340,6 +415,12 @@ module Agents
       chat.with_headers(**headers)
     end
 
+    def track_usage(response, context_wrapper)
+      return unless context_wrapper&.usage
+
+      context_wrapper.usage.add(response)
+    end
+
     # Builds thread-safe tool wrappers for an agent's tools and handoff tools.
     #
     # @param agent [Agents::Agent] The agent whose tools to wrap

data/lib/agents/tool_wrapper.rb

@@ -73,6 +73,15 @@ module Agents
       @tool.parameters
     end
 
+    # Expose params schema for RubyLLM providers that expect it
+    def params_schema
+      @tool.respond_to?(:params_schema) ? @tool.params_schema : nil
+    end
+
+    def provider_params
+      @tool.respond_to?(:provider_params) ? @tool.provider_params : {}
+    end
+
     # Make this work with RubyLLM's tool calling
     def to_s
       name

data/lib/agents/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Agents
-  VERSION = "0.7.0"
+  VERSION = "0.8.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ai-agents
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Shivam Mishra
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.8.2
+        version: 1.9.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.8.2
+        version: 1.9.1
 description: Ruby AI Agents SDK enables creating complex AI workflows with multi-agent
   orchestration, tool execution, safety guardrails, and provider-agnostic LLM integration.
 email: