ai-agents 0.4.3 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a3f2287a007ce187c91546ee4ef723cadcde40e7102454d4d432c2c2c72e4e45
-  data.tar.gz: 4c9b810362d923c0fb821491a63fa8647c926e2666e6902383200ca8f988cf10
+  metadata.gz: d07ac97ca06177ee4504601099af6bc6ba3e4d8557b28d34cd3222240b27575d
+  data.tar.gz: cd0c7121918c8a28c3760325c9acd319e86d349f34fb715d6b953912a99f98a8
 SHA512:
-  metadata.gz: aaa5ba1612a2551b83d3f779a10301c806f9a95eb082b4c6ab6db56fdc90487093b0a5edd0c5edc16c2a4888e1ada2abc66433bab73c569886b3b66f0c41d528
-  data.tar.gz: 2669853cd34f497d696fba2ccf02ed384057ea144b7ffdd0c390aa28c1c4bf830929723f181a0bfd130e206707fc80f9c2a0e12259da53099ef8ab92c5f681d8
+  metadata.gz: 63db003d8bf43b2ba8d52d48dbb24d2f8bf86ee4b4e8ab704316cf89d0b80156110a8438a7ca86a6fc37182ff9f5a723ace7c474e53a078de050cb22eff4b268
+  data.tar.gz: 05606d58c663ca0b9b062ed537cba33a4b987e5fd720a1188c003150f880a7c953cc28096ca4024854dcdec0a9896a7da35653ebb4f95c2e04a0f5b97e3e1c2e

data/CHANGELOG.md

@@ -5,6 +5,14 @@ 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).
 
+## [0.5.0] - 2025-08-20
+
+### Added
+- Tool halting functionality for enhanced agent control
+
+### Removed
+- Removed chat.rb component that made the codebase brittle
+
 ## [0.4.3] - 2025-08-04
 
 ### Fixed

data/CLAUDE.md

@@ -63,7 +63,6 @@ This will start a command-line interface where you can interact with the multi-a
 -   **Agent**: An AI assistant with a specific role, instructions, and tools.
 -   **Tool**: A custom function that an agent can use to perform actions (e.g., look up customer data, send an email).
 -   **Handoff**: The process of transferring a conversation from one agent to another. This is a core feature of the SDK.
--   **AgentRunner**: The thread-safe execution manager that coordinates multi-agent conversations and provides the main API.
 -   **Runner**: Internal component that manages individual conversation turns (used by AgentRunner).
 -   **Context**: A shared state object that stores conversation history and agent information, fully serializable for persistence.
 -   **Callbacks**: Event hooks for monitoring agent execution, including agent thinking, tool start/complete, and handoffs.
@@ -114,7 +113,6 @@ ruby examples/isp-support/interactive.rb
 ### Core Components
 
 - **Agents::Agent**: Individual AI agents with specific roles, instructions, and tools
-- **Agents::AgentRunner**: Thread-safe execution manager with callback support
 - **Agents::Runner**: Orchestrates multi-agent conversations with automatic handoffs
 - **Agents::Tool**: Base class for custom tools that agents can execute
 - **Agents::Context**: Shared state management across agent interactions
@@ -174,7 +172,7 @@ support = Agent.new(name: "Support", instructions: "Technical support...")
 triage.register_handoffs(billing, support)
 
 # Create thread-safe runner (first agent is default entry point)
-runner = Agents::AgentRunner.with_agents(triage, billing, support)
+runner = Agents::Runner.with_agents(triage, billing, support)
 
 # Add real-time callbacks for monitoring
 runner.on_agent_thinking { |agent_name, input| puts "🧠 #{agent_name} is thinking..." }

data/docs/concepts/callbacks.md

@@ -26,7 +26,7 @@ The SDK provides four types of callbacks that give you visibility into different
 Callbacks are registered on the AgentRunner using chainable methods:
 
 ```ruby
-runner = Agents::AgentRunner.with_agents(triage, support)
+runner = Agents::Runner.with_agents(triage, support)
   .on_agent_thinking { |agent, input| puts "#{agent} thinking..." }
   .on_tool_start { |tool, args| puts "Using #{tool}" }
   .on_tool_complete { |tool, result| puts "#{tool} completed" }

data/docs/guides/multi-agent-systems.md

@@ -23,7 +23,7 @@ billing_agent = Agents::Agent.new(
 )
 
 support_agent = Agents::Agent.new(
-  name: "Support", 
+  name: "Support",
   instructions: "Provide technical troubleshooting and product support."
 )
 
@@ -37,7 +37,7 @@ triage_agent = Agents::Agent.new(
 triage_agent.register_handoffs(billing_agent, support_agent)
 
 # Create runner with triage as entry point
-runner = Agents::AgentRunner.with_agents(triage_agent, billing_agent, support_agent)
+runner = Agents::Runner.with_agents(triage_agent, billing_agent, support_agent)
 ```
 
 ### Dynamic Instructions
@@ -52,7 +52,7 @@ support_agent = Agents::Agent.new(
     <<~INSTRUCTIONS
       You are a technical support specialist for #{customer_tier} tier customers.
       #{customer_tier == "premium" ? "Provide priority white-glove service." : ""}
-      
+
       Available tools: diagnostics, escalation
     INSTRUCTIONS
   }
@@ -73,7 +73,7 @@ sales_agent = Agents::Agent.new(
 )
 
 support_agent = Agents::Agent.new(
-  name: "Support", 
+  name: "Support",
   instructions: "Handle technical issues and product troubleshooting. Transfer sales questions to sales team."
 )
 ```
@@ -108,7 +108,7 @@ The first agent in `AgentRunner.with_agents()` becomes the default entry point:
 
 ```ruby
 # Triage agent handles all initial conversations
-runner = Agents::AgentRunner.with_agents(triage_agent, billing_agent, support_agent)
+runner = Agents::Runner.with_agents(triage_agent, billing_agent, support_agent)
 
 # Start conversation
 result = runner.run("I need help with my account")
@@ -168,9 +168,9 @@ triage_agent = Agents::Agent.new(
   name: "Triage",
   instructions: ->(context) {
     business_hours = context[:business_hours] || false
-    
+
     base_instructions = "Route users to appropriate departments."
-    
+
     if business_hours
       base_instructions + " All departments are available."
     else
@@ -189,8 +189,8 @@ Test each agent in isolation:
 ```ruby
 RSpec.describe "BillingAgent" do
   let(:agent) { create_billing_agent }
-  let(:runner) { Agents::AgentRunner.with_agents(agent) }
-  
+  let(:runner) { Agents::Runner.with_agents(agent) }
+
   it "handles payment inquiries" do
     result = runner.run("What payment methods do you accept?")
     expect(result.output).to include("credit card", "bank transfer")
@@ -205,13 +205,13 @@ Test complete workflows:
 ```ruby
 RSpec.describe "Customer Support Workflow" do
   let(:runner) { create_support_runner } # Creates triage + specialists
-  
+
   it "routes billing questions correctly" do
     result = runner.run("I have a billing question")
-    
+
     # Verify handoff occurred
     expect(result.context[:current_agent]).to eq("Billing")
-    
+
     # Test continued conversation
     followup = runner.run("What are your payment terms?", context: result.context)
     expect(followup.output).to include("payment terms")
@@ -258,4 +258,4 @@ threads = users.map do |user|
     # Handle result...
   end
 end
-```
+```

data/docs/guides/rails-integration.md

@@ -49,7 +49,7 @@ class CreateConversations < ActiveRecord::Migration[7.0]
       t.string :current_agent
       t.timestamps
     end
-    
+
     add_index :conversations, [:user_id, :created_at]
   end
 end
@@ -61,25 +61,25 @@ Define the Conversation model:
 # app/models/conversation.rb
 class Conversation < ApplicationRecord
   belongs_to :user
-  
+
   # Serialize context as JSON
   serialize :context, JSON
-  
+
   validates :context, presence: true
-  
+
   def self.for_user(user)
     where(user: user).order(:created_at)
   end
-  
+
   def self.latest_for_user(user)
     for_user(user).last
   end
-  
+
   # Convert to agent context hash
   def to_agent_context
     context.deep_symbolize_keys
   end
-  
+
   # Create from agent result
   def self.from_agent_result(user, result)
     create!(
@@ -102,26 +102,26 @@ class AgentConversationService
     @user = user
     @runner = create_agent_runner
   end
-  
+
   def send_message(message)
     # Get existing conversation context
     context = load_conversation_context
-    
+
     # Run agent with message
     result = @runner.run(message, context: context)
-    
+
     # Persist updated conversation
     save_conversation(result)
-    
+
     result
   end
-  
+
   def reset_conversation
     Conversation.where(user: @user).destroy_all
   end
-  
+
   private
-  
+
   def create_agent_runner
     # Create your agents here
     triage_agent = Agents::Agent.new(
@@ -129,52 +129,52 @@ class AgentConversationService
       instructions: build_triage_instructions,
       tools: [CustomerLookupTool.new]
     )
-    
+
     billing_agent = Agents::Agent.new(
       name: "Billing",
       instructions: "Handle billing and payment inquiries.",
       tools: [BillingTool.new, PaymentTool.new]
     )
-    
+
     support_agent = Agents::Agent.new(
       name: "Support",
       instructions: "Provide technical support and troubleshooting.",
       tools: [TechnicalTool.new]
     )
-    
+
     triage_agent.register_handoffs(billing_agent, support_agent)
-    
-    Agents::AgentRunner.with_agents(triage_agent, billing_agent, support_agent)
+
+    Agents::Runner.with_agents(triage_agent, billing_agent, support_agent)
   end
-  
+
   def build_triage_instructions
     ->(context) {
       user_info = context[:user_info] || {}
-      
+
       <<~INSTRUCTIONS
         You are a customer service triage agent for #{@user.name}.
-        
+
         Customer Details:
         - Name: #{@user.name}
         - Email: #{@user.email}
         - Account Type: #{user_info[:account_type] || 'standard'}
-        
+
         Route customers to the appropriate department:
         - Billing: Payment issues, account billing, refunds
         - Support: Technical problems, product questions
-        
+
         Always be professional and helpful.
       INSTRUCTIONS
     }
   end
-  
+
   def load_conversation_context
     latest_conversation = Conversation.latest_for_user(@user)
     return initial_context unless latest_conversation
-    
+
     latest_conversation.to_agent_context
   end
-  
+
   def initial_context
     {
       user_id: @user.id,
@@ -185,7 +185,7 @@ class AgentConversationService
       }
     }
   end
-  
+
   def save_conversation(result)
     Conversation.from_agent_result(@user, result)
   end
@@ -200,13 +200,13 @@ Create a controller for handling agent conversations:
 # app/controllers/agent_conversations_controller.rb
 class AgentConversationsController < ApplicationController
   before_action :authenticate_user!
-  
+
   def create
     service = AgentConversationService.new(current_user)
-    
+
     begin
       result = service.send_message(params[:message])
-      
+
       render json: {
         response: result.output,
         agent: result.context[:current_agent],
@@ -217,19 +217,19 @@ class AgentConversationsController < ApplicationController
       render json: { error: "Unable to process your request" }, status: 500
     end
   end
-  
+
   def reset
     service = AgentConversationService.new(current_user)
     service.reset_conversation
-    
+
     render json: { message: "Conversation reset successfully" }
   end
-  
+
   def history
     conversations = Conversation.for_user(current_user)
                                .includes(:user)
                                .limit(50)
-    
+
     render json: conversations.map do |conv|
       {
         id: conv.id,
@@ -252,13 +252,13 @@ class CustomerLookupTool < Agents::Tool
   name "lookup_customer"
   description "Look up customer information by email or ID"
   param :identifier, type: "string", desc: "Email address or customer ID"
-  
+
   def perform(tool_context, identifier:)
     # Access Rails models safely
     customer = User.find_by(email: identifier) || User.find_by(id: identifier)
-    
+
     return "Customer not found" unless customer
-    
+
     {
       name: customer.name,
       email: customer.email,
@@ -274,13 +274,13 @@ class BillingTool < Agents::Tool
   name "get_billing_info"
   description "Retrieve billing information for a customer"
   param :user_id, type: "integer", desc: "Customer user ID"
-  
+
   def perform(tool_context, user_id:)
     user = User.find(user_id)
     billing_info = user.billing_profile
-    
+
     return "No billing information found" unless billing_info
-    
+
     {
       plan: billing_info.plan_name,
       status: billing_info.status,
@@ -301,13 +301,13 @@ For longer conversations, use background jobs:
 # app/jobs/agent_conversation_job.rb
 class AgentConversationJob < ApplicationJob
   queue_as :default
-  
+
   def perform(user_id, message, conversation_id = nil)
     user = User.find(user_id)
     service = AgentConversationService.new(user)
-    
+
     result = service.send_message(message)
-    
+
     # Broadcast result via ActionCable
     ActionCable.server.broadcast(
       "agent_conversation_#{user_id}",
@@ -327,7 +327,7 @@ def create_async
     params[:message],
     params[:conversation_id]
   )
-  
+
   render json: { job_id: job_id }
 end
 ```
@@ -341,12 +341,12 @@ Implement comprehensive error handling:
 class AgentConversationService
   class AgentError < StandardError; end
   class ContextError < StandardError; end
-  
+
   def send_message(message)
     validate_message(message)
-    
+
     context = load_conversation_context
-    
+
     begin
       result = @runner.run(message, context: context)
       save_conversation(result)
@@ -359,9 +359,9 @@ class AgentConversationService
       raise ContextError, "Conversation context corrupted"
     end
   end
-  
+
   private
-  
+
   def validate_message(message)
     raise ArgumentError, "Message cannot be blank" if message.blank?
     raise ArgumentError, "Message too long" if message.length > 5000
@@ -378,26 +378,26 @@ Test Rails integration with RSpec:
 RSpec.describe AgentConversationService do
   let(:user) { create(:user) }
   let(:service) { described_class.new(user) }
-  
+
   describe '#send_message' do
     it 'creates a conversation record' do
       expect {
         service.send_message("Hello")
       }.to change(Conversation, :count).by(1)
     end
-    
+
     it 'persists context correctly' do
       result = service.send_message("Hello")
       conversation = Conversation.last
-      
+
       expect(conversation.user).to eq(user)
       expect(conversation.context).to include('user_id' => user.id)
     end
   end
-  
+
   describe '#reset_conversation' do
     before { service.send_message("Hello") }
-    
+
     it 'destroys all conversations for user' do
       expect {
         service.reset_conversation
@@ -437,4 +437,4 @@ add_index :conversations, :created_at
 every 1.day, at: '2:00 am' do
   runner "Conversation.where('created_at < ?', 30.days.ago).destroy_all"
 end
-```
+```

data/docs/guides/structured-output.md

@@ -30,7 +30,7 @@ extraction_agent = Agents::Agent.new(
   }
 )
 
-runner = Agents::AgentRunner.with_agents(extraction_agent)
+runner = Agents::Runner.with_agents(extraction_agent)
 result = runner.run("I love the new product features, especially the API and dashboard!")
 
 # Response will be valid JSON matching the schema:
@@ -62,7 +62,7 @@ contact_agent = Agents::Agent.new(
   response_schema: ContactSchema
 )
 
-runner = Agents::AgentRunner.with_agents(contact_agent)
+runner = Agents::Runner.with_agents(contact_agent)
 result = runner.run("Hi, I'm Sarah Johnson from TechCorp. You can reach me at sarah@techcorp.com or 555-0123. I'm interested in AI and automation solutions.")
 
 # Returns structured contact data:

data/docs/index.md

@@ -81,7 +81,7 @@ support = Agents::Agent.new(
 triage.register_handoffs(support)
 
 # Create runner and start conversation
-runner = Agents::AgentRunner.with_agents(triage, support)
+runner = Agents::Runner.with_agents(triage, support)
 result = runner.run("I need help with a technical issue")
 
 puts result.output

data/examples/isp-support/agents_factory.rb

@@ -90,7 +90,7 @@ module ISPSupport
 
         Keep responses brief and professional. Use handoff tools to transfer to specialists.
 
-        Your response MUST be in the required JSON format with greeting, intent_category, needs_clarification, clarifying_question, and recommended_agent fields.
+        Your response MUST be in the required JSON format with response, clarifying_question, needs_clarification, and intent fields.
       INSTRUCTIONS
     end
 
@@ -98,30 +98,17 @@ module ISPSupport
       {
         type: "object",
         properties: {
-          greeting: {
+          response: {
             type: "string",
-            description: "A brief, friendly greeting acknowledging the customer's inquiry"
+            description: "Your response to the customer"
           },
-          intent_category: {
+          intent: {
             type: "string",
             enum: %w[sales support unclear],
-            description: "The detected category of the customer's intent"
-          },
-          needs_clarification: {
-            type: "boolean",
-            description: "Whether the intent is unclear and needs clarification"
-          },
-          clarifying_question: {
-            type: ["string", "null"],
-            description: "A question to ask if the intent is unclear (null if clear)"
-          },
-          recommended_agent: {
-            type: ["string", "null"],
-            enum: ["Sales Agent", "Support Agent", null],
-            description: "The recommended specialist agent to route to (null if unclear)"
+            description: "The detected intent category"
           }
         },
-        required: %w[greeting intent_category needs_clarification],
+        required: %w[response intent],
         additionalProperties: false
       }
     end

data/examples/isp-support/interactive.rb

@@ -58,23 +58,13 @@ class ISPSupportDemo
 
       # Handle structured output from triage agent
       output = result.output || "[No output]"
-      if @context[:current_agent] == "Triage Agent" && output.start_with?("{")
-        begin
-          structured = JSON.parse(output)
-          # Display the greeting from structured response
-          puts "🤖 #{structured["greeting"]}"
-          if structured["intent_category"]
-            puts "   [Intent: #{structured["intent_category"]}, Routing to: #{structured["recommended_agent"] || "TBD"}]"
-          end
-        rescue JSON::ParserError
-          # Fall back to regular output if not valid JSON
-          puts "🤖 #{output}"
-        end
+      if @context[:current_agent] == "Triage Agent" && output.is_a?(Hash)
+        # Display the response from structured response
+        puts "🤖 #{output["response"]}"
+        puts "\e[2m   [Intent]: #{output["intent"]}\e[0m" if output["intent"]
       else
         puts "🤖 #{output}"
       end
-
-      puts
     end
   end
 

data/lib/agents/handoff.rb

@@ -69,11 +69,19 @@ module Agents
       @tool_description
     end
 
-    # Handoff tools now work with the extended Chat class for proper handoff handling
-    # No longer need context signaling - the Chat class detects handoffs directly
-    def perform(_tool_context)
-      # Simply return the transfer message - Chat class will handle the handoff
-      "I'll transfer you to #{@target_agent.name} who can better assist you with this."
+    # Use RubyLLM's halt mechanism to stop continuation after handoff
+    # Store handoff info in context for Runner to detect and process
+    def perform(tool_context)
+      # Store handoff information in context for Runner to detect
+      # TODO: The following is a race condition that needs to be addressed in future versions
+      # If multiple handoff tools execute concurrently, they overwrite each other's pending_handoff data.
+      tool_context.run_context.context[:pending_handoff] = {
+        target_agent: @target_agent,
+        timestamp: Time.now
+      }
+
+      # Return halt to stop LLM continuation
+      halt("I'll transfer you to #{@target_agent.name} who can better assist you with this.")
     end
 
     # NOTE: RubyLLM will handle schema generation internally when needed

data/lib/agents/runner.rb

@@ -110,17 +110,23 @@ module Agents
                  end
         response = result
 
-        # Check for handoff response from our extended chat
-        if response.is_a?(Agents::Chat::HandoffResponse)
-          next_agent = response.target_agent
+        # Check for handoff via RubyLLM's halt mechanism
+        if response.is_a?(RubyLLM::Tool::Halt) && context_wrapper.context[:pending_handoff]
+          handoff_info = context_wrapper.context.delete(:pending_handoff)
+          next_agent = handoff_info[:target_agent]
 
           # Validate that the target agent is in our registry
           # This prevents handoffs to agents that weren't explicitly provided
           unless registry[next_agent.name]
             puts "[Agents] Warning: Handoff to unregistered agent '#{next_agent.name}', continuing with current agent"
-            next if response.tool_call?
-
-            next
+            # Return the halt content as the final response
+            save_conversation_state(chat, context_wrapper, current_agent)
+            return RunResult.new(
+              output: response.content,
+              messages: MessageExtractor.extract_messages(chat, current_agent),
+              usage: context_wrapper.usage,
+              context: context_wrapper.context
+            )
           end
 
           # Save current conversation state before switching
@@ -143,6 +149,17 @@ module Agents
           next
         end
 
+        # Handle non-handoff halts - return the halt content as final response
+        if response.is_a?(RubyLLM::Tool::Halt)
+          save_conversation_state(chat, context_wrapper, current_agent)
+          return RunResult.new(
+            output: response.content,
+            messages: MessageExtractor.extract_messages(chat, current_agent),
+            usage: context_wrapper.usage,
+            context: context_wrapper.context
+          )
+        end
+
         # If tools were called, continue the loop to let them execute
         next if response.tool_call?
 
@@ -202,16 +219,23 @@ module Agents
         next unless %i[user assistant].include?(msg[:role].to_sym)
         next unless msg[:content] && !MessageExtractor.content_empty?(msg[:content])
 
-        chat.add_message(
+        # Extract text content safely - handle both string and hash content
+        content = RubyLLM::Content.new(msg[:content])
+
+        # Create a proper RubyLLM::Message and pass it to add_message
+        message = RubyLLM::Message.new(
           role: msg[:role].to_sym,
-          content: msg[:content]
+          content: content
         )
+        chat.add_message(message)
       rescue StandardError => e
         # Continue with partial history on error
-        puts "[Agents] Failed to restore message: #{e.message}"
+        # TODO: Remove this, and let the error propagate up the call stack
+        puts "[Agents] Failed to restore message: #{e.message}\n#{e.backtrace.join("\n")}"
       end
     rescue StandardError => e
       # If history restoration completely fails, continue with empty history
+      # TODO: Remove this, and let the error propagate up the call stack
       puts "[Agents] Failed to restore conversation history: #{e.message}"
       context_wrapper.context[:conversation_history] = []
     end
@@ -234,24 +258,29 @@ module Agents
       # Get system prompt (may be dynamic)
       system_prompt = agent.get_system_prompt(context_wrapper)
 
-      # Separate handoff tools from regular tools
-      handoff_tools = agent.handoff_agents.map { |target_agent| HandoffTool.new(target_agent) }
-      regular_tools = agent.tools
+      # Create standard RubyLLM chat
+      chat = RubyLLM::Chat.new(model: agent.model)
 
-      # Only wrap regular tools - handoff tools will be handled directly by Chat
-      wrapped_regular_tools = regular_tools.map { |tool| ToolWrapper.new(tool, context_wrapper) }
+      # Combine all tools - both handoff and regular tools need wrapping
+      all_tools = []
 
-      # Create extended chat with handoff awareness and context
-      chat = Agents::Chat.new(
-        model: agent.model,
-        temperature: agent.temperature,
-        handoff_tools: handoff_tools,        # Direct tools, no wrapper
-        context_wrapper: context_wrapper,    # Pass context directly
-        response_schema: agent.response_schema # Pass structured output schema
-      )
+      # Add handoff tools
+      agent.handoff_agents.each do |target_agent|
+        handoff_tool = HandoffTool.new(target_agent)
+        all_tools << ToolWrapper.new(handoff_tool, context_wrapper)
+      end
 
+      # Add regular tools
+      agent.tools.each do |tool|
+        all_tools << ToolWrapper.new(tool, context_wrapper)
+      end
+
+      # Configure chat with instructions, temperature, tools, and schema
       chat.with_instructions(system_prompt) if system_prompt
-      chat.with_tools(*wrapped_regular_tools) if wrapped_regular_tools.any?
+      chat.with_temperature(agent.temperature) if agent.temperature
+      chat.with_tools(*all_tools) if all_tools.any?
+      chat.with_schema(agent.response_schema) if agent.response_schema
+
       chat
     end
   end

data/lib/agents/version.rb

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

data/lib/agents.rb

@@ -114,7 +114,6 @@ require_relative "agents/handoff"
 require_relative "agents/agent"
 
 # Execution components
-require_relative "agents/chat"
 require_relative "agents/tool_wrapper"
 require_relative "agents/message_extractor"
 require_relative "agents/callback_manager"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ai-agents
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.5.0
 platform: ruby
 authors:
 - Shivam Mishra
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: 1.6.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: 1.6.0
 description: Ruby AI Agents SDK enables creating complex AI workflows with multi-agent
   orchestration, tool execution, safety guardrails, and provider-agnostic LLM integration.
 email:
@@ -101,7 +101,6 @@ files:
 - lib/agents/agent_runner.rb
 - lib/agents/agent_tool.rb
 - lib/agents/callback_manager.rb
-- lib/agents/chat.rb
 - lib/agents/handoff.rb
 - lib/agents/message_extractor.rb
 - lib/agents/result.rb

data/lib/agents/chat.rb

@@ -1,161 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "tool_context"
-
-module Agents
-  # Extended chat class that inherits from RubyLLM::Chat but adds proper handoff handling.
-  # This solves the infinite handoff loop problem by treating handoffs as turn-ending
-  # operations rather than allowing auto-continuation.
-  class Chat < RubyLLM::Chat
-    # Response object that indicates a handoff occurred
-    class HandoffResponse
-      attr_reader :target_agent, :response, :handoff_message
-
-      def initialize(target_agent:, response:, handoff_message:)
-        @target_agent = target_agent
-        @response = response
-        @handoff_message = handoff_message
-      end
-
-      def tool_call?
-        true
-      end
-
-      def content
-        @handoff_message
-      end
-    end
-
-    def initialize(model: nil, handoff_tools: [], context_wrapper: nil, temperature: nil, response_schema: nil,
-                   **options)
-      super(model: model, **options)
-      @handoff_tools = handoff_tools
-      @context_wrapper = context_wrapper
-
-      # Set temperature if provided (RubyLLM::Chat sets this via accessor)
-      @temperature = temperature if temperature
-
-      # Set response schema if provided
-      with_schema(response_schema) if response_schema
-
-      # Register handoff tools with RubyLLM for schema generation
-      @handoff_tools.each { |tool| with_tool(tool) }
-    end
-
-    # Override the problematic auto-execution method from RubyLLM::Chat
-    def complete(&block)
-      @on[:new_message]&.call
-      response = @provider.complete(
-        messages,
-        tools: @tools,
-        temperature: @temperature,
-        model: @model.id,
-        connection: @connection,
-        params: @params,
-        schema: @schema,
-        &block
-      )
-      @on[:end_message]&.call(response)
-
-      # Handle JSON parsing for structured output (like RubyLLM::Chat)
-      if @schema && response.content.is_a?(String)
-        begin
-          response.content = JSON.parse(response.content)
-        rescue JSON::ParserError
-          # If parsing fails, keep content as string
-        end
-      end
-
-      add_message(response)
-
-      if response.tool_call?
-        handle_tools_with_handoff_detection(response, &block)
-      else
-        response
-      end
-    end
-
-    private
-
-    def handle_tools_with_handoff_detection(response, &block)
-      handoff_calls, regular_calls = classify_tool_calls(response.tool_calls)
-
-      if handoff_calls.any?
-        # Execute first handoff only
-        handoff_result = execute_handoff_tool(handoff_calls.first)
-
-        # Add tool result to conversation
-        add_tool_result(handoff_calls.first.id, handoff_result[:message])
-
-        # Return handoff response to signal agent switch (ends turn)
-        HandoffResponse.new(
-          target_agent: handoff_result[:target_agent],
-          response: response,
-          handoff_message: handoff_result[:message]
-        )
-      else
-        # Use RubyLLM's original tool execution for regular tools
-        execute_regular_tools_and_continue(regular_calls, &block)
-      end
-    end
-
-    def classify_tool_calls(tool_calls)
-      handoff_tool_names = @handoff_tools.map(&:name).map(&:to_s)
-
-      handoff_calls = []
-      regular_calls = []
-
-      tool_calls.each_value do |tool_call|
-        if handoff_tool_names.include?(tool_call.name)
-          handoff_calls << tool_call
-        else
-          regular_calls << tool_call
-        end
-      end
-
-      [handoff_calls, regular_calls]
-    end
-
-    def execute_handoff_tool(tool_call)
-      tool = @handoff_tools.find { |t| t.name.to_s == tool_call.name }
-      raise "Handoff tool not found: #{tool_call.name}" unless tool
-
-      # Execute the handoff tool directly with context
-      tool_context = ToolContext.new(run_context: @context_wrapper)
-      result = tool.execute(tool_context, **{}) # Handoff tools take no additional params
-
-      {
-        target_agent: tool.target_agent,
-        message: result.to_s
-      }
-    end
-
-    def execute_regular_tools_and_continue(tool_calls, &block)
-      # Execute each regular tool call
-      tool_calls.each do |tool_call|
-        @on[:new_message]&.call
-        result = execute_tool(tool_call)
-        message = add_tool_result(tool_call.id, result)
-        @on[:end_message]&.call(message)
-      end
-
-      # Continue conversation after tool execution
-      complete(&block)
-    end
-
-    # Reuse RubyLLM's existing tool execution logic
-    def execute_tool(tool_call)
-      tool = tools[tool_call.name.to_sym]
-      args = tool_call.arguments
-      tool.call(args)
-    end
-
-    def add_tool_result(tool_use_id, result)
-      add_message(
-        role: :tool,
-        content: result.is_a?(Hash) && result[:error] ? result[:error] : result.to_s,
-        tool_call_id: tool_use_id
-      )
-    end
-  end
-end