rsmolagent 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 374e7d1da7f59eece14d7616f9e21cea9f99290a6ccf4eac4697576972f8e260
-  data.tar.gz: a2892e99d70020084fe207dc58b042be5886fcd55f19dc371bf97fd1602fe169
+  metadata.gz: d497306b05c55fd6a5fc261dc5fe129c0f009246ae40c9c35ed43778fffa5e18
+  data.tar.gz: ac8ec9d9befe6cd78a2708bb10e0aa42d38777a5e93926ed2690c5dd024547b3
 SHA512:
-  metadata.gz: 63248253961036a8734c03e1d4201fa259896cc8f015d40a8478518e7e3d1ed6831f5afa512de6d3cfaaebdfc9fa728177d796f360285189dc0f19d805696d57
-  data.tar.gz: 1a75e4e82b4c9479e76e16df77fbe55f6ba96ec6bcf06a3146dd268a0aef1bba8e651e9277f8268c7a1998611670d415329d898328903ab7d8890d305b9be8bb
+  metadata.gz: 1c811483465d931daa25a388c1876f2eb9b67d636d09b7eb5f80023af1171649ae6c2cd9f27faa9133736a94b1f165ca957464498bd857d359980cbe95e924c9
+  data.tar.gz: 875681cd6a3fbecb28bf3ec5e06fdcb82bb91f4e09e8a6baa3f2f3a97efa6175d5b2d12bb72aad9a69c7c2e09dfc7d2da0211047ecaf3eb8ee491441cb3e57b4

data/lib/rsmolagent/agent.rb

@@ -91,6 +91,18 @@ module RSmolagent
           answer = arguments["answer"] || arguments[:answer] || ""
           @memory.add_final_answer(answer)
           return { final_answer: true, answer: answer }
+        elsif tool_name == "answer"
+          # Handle answer tool as final answer too
+          result = arguments["result"] || arguments[:result] || ""
+          explanation = arguments["explanation"] || arguments[:explanation] || ""
+          
+          final_answer = result
+          if explanation && !explanation.empty?
+            final_answer += " (#{explanation})"
+          end
+          
+          @memory.add_final_answer(final_answer)
+          return { final_answer: true, answer: final_answer }
         else
           # Execute the tool
           result = execute_tool(tool_name, arguments)

data/lib/rsmolagent/llm_provider.rb

@@ -32,6 +32,8 @@ module RSmolagent
     def initialize(model_id:, client:, **options)
       super(model_id: model_id, **options)
       @client = client
+      @max_retries = options[:max_retries] || 3
+      @initial_backoff = options[:initial_backoff] || 1
     end
 
     def chat(messages, tools: nil, tool_choice: nil)
@@ -47,13 +49,233 @@ module RSmolagent
         params[:tool_choice] = tool_choice || "auto"
       end
 
-      response = @client.chat(parameters: params)
+      retries = 0
+      begin
+        response = @client.chat(parameters: params)
+        
+        # Update token counts
+        @last_prompt_tokens = response.usage.prompt_tokens
+        @last_completion_tokens = response.usage.completion_tokens
+        
+        response.choices.first.message
+      rescue Faraday::TooManyRequestsError => e
+        retries += 1
+        if retries <= @max_retries
+          # Exponential backoff with jitter
+          sleep_time = @initial_backoff * (2 ** (retries - 1)) * (0.5 + rand)
+          puts "Rate limited (429). Retrying in #{sleep_time.round(1)} seconds... (#{retries}/#{@max_retries})"
+          sleep(sleep_time)
+          retry
+        else
+          puts "Max retries (#{@max_retries}) exceeded. Rate limit error persists."
+          raise e
+        end
+      end
+    end
+
+    def extract_tool_calls(response)
+      return [] unless response.tool_calls
+      
+      response.tool_calls.map do |tool_call|
+        {
+          name: tool_call.function.name,
+          arguments: parse_json_if_needed(tool_call.function.arguments)
+        }
+      end
+    end
+  end
+
+  class ClaudeProvider < LLMProvider
+    def initialize(model_id:, client:, **options)
+      super(model_id: model_id, **options)
+      @client = client
+      @max_retries = options[:max_retries] || 3
+      @initial_backoff = options[:initial_backoff] || 1
+    end
+
+    def chat(messages, tools: nil, tool_choice: nil)
+      # Prepare the system message
+      system_message = nil
+      filtered_messages = messages.reject do |message|
+        if message[:role] == 'system'
+          system_message = message[:content]
+          true
+        else
+          false
+        end
+      end
+
+      # Convert messages format for Claude
+      claude_messages = filtered_messages.map do |msg|
+        role = msg[:role] == 'assistant' ? 'assistant' : 'user'
+        
+        # Process assistant messages to help guide Claude's behavior
+        content = msg[:content]
+        if role == 'assistant' && content.start_with?("I'll use the calculator tool")
+          content = "I'll use the calculator tool to solve this problem."
+        end
+        
+        { role: role, content: content }
+      end
+
+      # Check current state of conversation to guide the model
+      calculator_used = false
+      calculator_result = nil
+      
+      # Analyze the conversation to detect patterns
+      claude_messages.each_with_index do |msg, i|
+        # Check for calculator result
+        if msg[:role] == 'user' && msg[:content].match?(/^\d+$/) && i > 0
+          calculator_used = true
+          calculator_result = msg[:content]
+        end
+      end
+      
+      # Prepare parameters
+      params = {
+        model: @model_id,
+        messages: claude_messages,
+        temperature: @options[:temperature] || 0.7,
+        max_tokens: @options[:max_tokens] || 4096
+      }
+
+      # Add system message with appropriate guidance based on conversation state
+      if system_message
+        enhanced_system = system_message.dup
+        if calculator_used && calculator_result
+          enhanced_system += " IMPORTANT: You have already calculated the result (#{calculator_result}). Use the answer tool now to provide your final answer."
+        end
+        params[:system] = enhanced_system
+      end
+
+      # Add tools if provided - Format specifically for Claude's API
+      if tools && !tools.empty?
+        claude_tools = tools.map do |tool|
+          schema = tool.to_json_schema
+          {
+            name: schema["name"],
+            description: schema["description"],
+            input_schema: {
+              type: "object",
+              properties: schema["parameters"]["properties"],
+              required: schema["parameters"]["required"]
+            }
+          }
+        end
+        params[:tools] = claude_tools
+      end
+
+      # Debug information
+      puts "CLAUDE REQUEST PARAMS:"
+      puts "Model: #{params[:model]}"
+      puts "Messages: #{params[:messages].inspect}"
+      puts "System: #{params[:system]}" if params[:system]
+      puts "Tools: #{params[:tools].inspect}" if params[:tools]
+      
+      retries = 0
+      begin
+        response = @client.messages(parameters: params)
+        
+        # Update token counts if available
+        if response.respond_to?(:usage)
+          @last_prompt_tokens = response.usage.input_tokens if response.usage.respond_to?(:input_tokens)
+          @last_completion_tokens = response.usage.output_tokens if response.usage.respond_to?(:output_tokens)
+        end
+        
+        # Create a response object that matches the structure expected by Agent
+        content = nil
+        
+        # Handle hash response
+        if response.is_a?(Hash) && response["content"].is_a?(Array)
+          text_item = response["content"].find { |item| item["type"] == "text" }
+          content = text_item["text"] if text_item
+        # Handle object response
+        elsif response.respond_to?(:content) && response.content.is_a?(Array) && !response.content.empty?
+          content_item = response.content.find { |item| item.type == 'text' }
+          content = content_item ? content_item.text : nil
+        end
+
+        OpenStruct.new(
+          content: content,
+          tool_calls: extract_tool_calls_from_response(response)
+        )
+      rescue => e
+        if e.is_a?(Faraday::TooManyRequestsError) || e.message.include?('429')
+          retries += 1
+          if retries <= @max_retries
+            # Exponential backoff with jitter
+            sleep_time = @initial_backoff * (2 ** (retries - 1)) * (0.5 + rand)
+            puts "Rate limited (429). Retrying in #{sleep_time.round(1)} seconds... (#{retries}/#{@max_retries})"
+            sleep(sleep_time)
+            retry
+          else
+            puts "Max retries (#{@max_retries}) exceeded. Rate limit error persists."
+            raise e
+          end
+        elsif e.is_a?(Faraday::BadRequestError) || e.message.include?('400')
+          puts "Bad request error (400). Request parameters may be invalid:"
+          puts "Error details: #{e.message}"
+          puts "Response body: #{e.response[:body] if e.respond_to?(:response) && e.response.is_a?(Hash)}"
+          raise e
+        else
+          puts "Unknown error occurred: #{e.class} - #{e.message}"
+          raise e
+        end
+      end
+    end
+
+    def extract_tool_calls_from_response(response)
+      # Debug information about the response
+      puts "Response type: #{response.class}"
+      puts "Response content: #{response.inspect}"
       
-      # Update token counts
-      @last_prompt_tokens = response.usage.prompt_tokens
-      @last_completion_tokens = response.usage.completion_tokens
+      # Check if response is a hash (the anthropic gem might return raw hash)
+      if response.is_a?(Hash)
+        puts "Response is a Hash, extracting from hash"
+        content_array = response["content"] rescue nil
+        return nil unless content_array && content_array.is_a?(Array)
+        
+        tool_calls_content = content_array.find { |c| c["type"] == "tool_use" }
+        return nil unless tool_calls_content
+        
+        tool_call = tool_calls_content["id"] ? {
+          "name" => tool_calls_content["name"],
+          "input" => tool_calls_content["input"]
+        } : nil
+        
+        return nil unless tool_call
+        
+        return [
+          OpenStruct.new(
+            function: OpenStruct.new(
+              name: tool_call["name"],
+              arguments: tool_call["input"].to_json
+            )
+          )
+        ]
+      end
       
-      response.choices.first.message
+      # Handle object-style response (if anthropic gem parses to objects)
+      begin
+        return nil unless response.respond_to?(:content) && 
+                          response.content.is_a?(Array) && 
+                          !response.content.empty?
+                          
+        tool_use_blocks = response.content.select { |c| c.type == "tool_use" }
+        return nil if tool_use_blocks.empty?
+        
+        return tool_use_blocks.map do |tool_block|
+          OpenStruct.new(
+            function: OpenStruct.new(
+              name: tool_block.name,
+              arguments: tool_block.input.to_json
+            )
+          )
+        end
+      rescue => e
+        puts "Error extracting tool calls: #{e.message}"
+        nil
+      end
     end
 
     def extract_tool_calls(response)

data/lib/rsmolagent/version.rb

@@ -1,3 +1,3 @@
 module RSmolagent
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rsmolagent
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - gkosmo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-03-10 00:00:00.000000000 Z
+date: 2025-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: anthropic
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -53,7 +67,8 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3.0'
 description: RSmolagent is a Ruby library for building AI agents that can use tools
-  to solve tasks
+  to solve tasks. Supports both OpenAI and Claude models with automatic retries and
+  rate limiting capabilities.
 email:
 - gkosmo1@hotmail.com
 executables: []