rsmolagent 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 374e7d1da7f59eece14d7616f9e21cea9f99290a6ccf4eac4697576972f8e260
+  data.tar.gz: a2892e99d70020084fe207dc58b042be5886fcd55f19dc371bf97fd1602fe169
+SHA512:
+  metadata.gz: 63248253961036a8734c03e1d4201fa259896cc8f015d40a8478518e7e3d1ed6831f5afa512de6d3cfaaebdfc9fa728177d796f360285189dc0f19d805696d57
+  data.tar.gz: 1a75e4e82b4c9479e76e16df77fbe55f6ba96ec6bcf06a3146dd268a0aef1bba8e651e9277f8268c7a1998611670d415329d898328903ab7d8890d305b9be8bb

data/README.md

@@ -0,0 +1,254 @@
+# RSmolagent
+
+A lightweight Ruby library for creating AI agents that can use tools to solve tasks. Inspired by Python's smolagents library, RSmolagent provides a simple way to build agents that can interact with the world through tools.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rsmolagent'
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install rsmolagent
+```
+
+## Usage
+
+RSmolagent is designed to be simple to use. Here's a basic example:
+
+```ruby
+require 'rsmolagent'
+require 'ruby/openai'
+
+# Create a custom tool
+class CalculatorTool < RSmolagent::Tool
+  def initialize
+    super(
+      name: "calculator",
+      description: "Perform mathematical calculations",
+      input_schema: {
+        expression: {
+          type: "string",
+          description: "The mathematical expression to evaluate"
+        }
+      }
+    )
+  end
+
+  def execute(args)
+    expression = args[:expression]
+    eval(expression).to_s
+  rescue => e
+    "Error: #{e.message}"
+  end
+end
+
+# Initialize OpenAI client
+client = OpenAI::Client.new(access_token: ENV["OPENAI_API_KEY"])
+
+# Create LLM provider
+llm = RSmolagent::OpenAIProvider.new(
+  model_id: "gpt-3.5-turbo",
+  client: client
+)
+
+# Create agent with tools
+calculator = CalculatorTool.new
+agent = RSmolagent::Agent.new(
+  llm_provider: llm,
+  tools: [calculator]
+)
+
+# Run the agent
+result = agent.run("What is 123 * 456?")
+puts result  # Outputs the calculated result
+```
+
+## Features
+
+- Simple interface for creating AI agents
+- Support for custom tools
+- Built-in memory for tracking conversation history
+- Works with OpenAI API (easily extensible to other LLM providers)
+- Automatic handling of tool calls and responses
+- Built-in tools including web search
+- Dynamic code execution and custom tool creation
+- Ability to create tools from Ruby code at runtime
+
+## Built-in Tools
+
+RSmolagent comes with several built-in tools:
+
+### WebSearchTool
+
+Searches the web using DuckDuckGo's API:
+
+```ruby
+# Create a web search tool
+web_search = RSmolagent::Tools::WebSearchTool.new(max_results: 3)
+
+# Add it to your agent
+agent = RSmolagent::Agent.new(
+  llm_provider: llm,
+  tools: [web_search]
+)
+
+# The agent can now search the web
+result = agent.run("What are the latest developments in AI?")
+```
+
+### Ruby Code Execution Tools
+
+RSmolagent provides tools for executing Ruby code, allowing you to create custom tools dynamically:
+
+#### 1. RubyExecutorTool
+
+Executes arbitrary Ruby code in a controlled environment:
+
+```ruby
+# Create a Ruby executor tool
+ruby_executor = RSmolagent::Tools::RubyExecutorTool.new
+
+# Add it to your agent
+agent = RSmolagent::Agent.new(
+  llm_provider: llm,
+  tools: [ruby_executor]
+)
+
+# The agent can now execute Ruby code
+result = agent.run("Calculate the factorial of 5")
+```
+
+#### 2. CustomClassExecutorTool
+
+Creates and executes custom tool classes with defined structure:
+
+```ruby
+# Create a custom tool executor
+custom_executor = RSmolagent::Tools::CustomClassExecutorTool.new
+
+# Add it to your agent
+agent = RSmolagent::Agent.new(
+  llm_provider: llm,
+  tools: [custom_executor]
+)
+
+# The agent can now create and use custom tools
+result = agent.run("Create a tool to get the current date and then use it")
+```
+
+#### 3. Creating Custom Tools from Code
+
+You can also create tools from code directly using the CustomToolFactory:
+
+```ruby
+# Define a custom tool class
+tool_code = <<~RUBY
+  class MyCustomTool < CustomToolBase
+    def initialize
+      super(
+        "my_tool",
+        "Description of what my tool does",
+        {
+          param1: {
+            type: "string",
+            description: "Parameter description"
+          }
+        }
+      )
+    end
+    
+    def run(args)
+      # Implement tool logic here
+      "Result: " + args[:param1].upcase
+    end
+  end
+RUBY
+
+# Create a tool from the code
+my_tool = RSmolagent::Tools::CustomToolFactory.create_from_code(tool_code)
+
+# Use the tool
+my_tool.call(param1: "hello world")  # => "Result: HELLO WORLD"
+```
+
+## Creating Custom Tools
+
+To create a custom tool, simply inherit from `RSmolagent::Tool` and implement the `execute` method:
+
+```ruby
+class MyTool < RSmolagent::Tool
+  def initialize
+    super(
+      name: "my_tool",
+      description: "Description of what the tool does",
+      input_schema: {
+        param1: {
+          type: "string",
+          description: "Description of parameter 1"
+        },
+        param2: {
+          type: "number",
+          description: "Description of parameter 2"
+        }
+      }
+    )
+  end
+
+  def execute(args)
+    # Implement your tool logic here
+    # args will contain the parameters passed by the agent
+    "Result of the tool execution"
+  end
+end
+```
+
+## Supporting Other LLM Providers
+
+To add support for other LLM providers, inherit from `RSmolagent::LLMProvider` and implement the required methods:
+
+```ruby
+class MyLLMProvider < RSmolagent::LLMProvider
+  def initialize(model_id:, **options)
+    super(model_id: model_id, **options)
+    # Initialize your LLM client
+  end
+
+  def chat(messages, tools: nil, tool_choice: nil)
+    # Call your LLM provider's API
+    # Return the response in a standardized format
+  end
+
+  def extract_tool_calls(response)
+    # Extract tool calls from the response
+    # Return an array of tool calls in the format:
+    # [{ name: "tool_name", arguments: { param1: "value1", ... } }, ...]
+  end
+end
+```
+
+## Testing
+
+RSmolagent includes a comprehensive test suite using RSpec. To run the tests:
+
+```bash
+# Install development dependencies
+$ bundle install
+
+# Run the tests
+$ bundle exec rake spec
+```
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/rsmolagent/agent.rb

@@ -0,0 +1,164 @@
+module RSmolagent
+  class Agent
+    attr_reader :memory, :tools, :llm, :max_steps
+    
+    def initialize(llm_provider:, tools: [], system_prompt: nil, max_steps: 10)
+      @llm = llm_provider
+      @memory = Memory.new
+      @max_steps = max_steps
+      @dynamic_tools = {}
+      
+      # Initialize system prompt
+      default_system_prompt = "You are a helpful assistant that can use tools to solve tasks. " +
+                              "When you need information or want to perform actions, use the provided tools. " +
+                              "When you have the final answer, use the final_answer tool."
+      
+      system_message = system_prompt || default_system_prompt
+      @memory.add_system_message(system_message)
+      
+      # Set up tools
+      @tools = {}
+      tools.each { |tool| @tools[tool.name] = tool }
+      
+      # Add final answer tool if not present
+      unless @tools["final_answer"]
+        final_answer_tool = FinalAnswerTool.new
+        @tools[final_answer_tool.name] = final_answer_tool
+      end
+    end
+    
+    # Method to register a new tool during execution
+    def register_tool(tool)
+      @dynamic_tools[tool.name] = tool
+      # Update memory with information about the new tool
+      @memory.add_assistant_message("I've created a new tool called '#{tool.name}' that #{tool.description}")
+    end
+    
+    def run(task, verbose: false)
+      @memory.add_user_message(task)
+      step_count = 0
+      
+      while step_count < @max_steps
+        step_count += 1
+        puts "Step #{step_count}/#{@max_steps}" if verbose
+        
+        # Get response from LLM
+        response = execute_step
+        
+        # Check if we've reached a final answer
+        if response[:final_answer]
+          return response[:answer]
+        end
+        
+        puts "Used tool: #{response[:tool_name]}" if verbose
+      end
+      
+      # If we reach max steps without a final answer, return what we have
+      "I couldn't complete the task in the allowed number of steps. My progress so far: " +
+      @memory.history.map { |step| step[:type] == "tool_call" ? "#{step[:tool_name]}: #{step[:result]}" : "" }.join("\n")
+    end
+    
+    private
+    
+    def execute_step
+      # Get current messages
+      messages = @memory.to_openai_messages
+      
+      # Combine static and dynamic tools
+      all_tools = @tools.merge(@dynamic_tools)
+      
+      # Call LLM with all tools
+      response = @llm.chat(messages, tools: all_tools.values)
+      
+      # Handle tool calls or final answer
+      tool_calls = @llm.extract_tool_calls(response)
+      
+      if tool_calls.empty?
+        # No tool calls, add as assistant message
+        @memory.add_assistant_message(response.content)
+        return { content: response.content }
+      else
+        # Process the first tool call
+        tool_call = tool_calls.first
+        tool_name = tool_call[:name]
+        arguments = tool_call[:arguments]
+        
+        # Record assistant message with tool call
+        @memory.add_assistant_message("I'll use the #{tool_name} tool.")
+        
+        if tool_name == "final_answer"
+          # Handle final answer
+          answer = arguments["answer"] || arguments[:answer] || ""
+          @memory.add_final_answer(answer)
+          return { final_answer: true, answer: answer }
+        else
+          # Execute the tool
+          result = execute_tool(tool_name, arguments)
+          
+          # Check if this is a tool creation tool (like CustomClassExecutorTool)
+          if tool_name == "create_tool" || tool_name == "custom_executor"
+            # Try to create a new tool from the result
+            begin
+              # Parse the code from the result if needed
+              code = extract_tool_code_from_result(result)
+              
+              if code
+                # Try to create a tool from the code
+                new_tool = Tools::CustomToolFactory.create_from_code(code)
+                
+                # Register the new tool
+                register_tool(new_tool)
+                
+                # Add confirmation to the result
+                result += "\n\nTool '#{new_tool.name}' has been created and is now available for use."
+              end
+            rescue => e
+              result += "\n\nFailed to create tool: #{e.message}"
+            end
+          end
+          
+          # Add tool result to memory
+          @memory.add_tool_message(tool_name, result)
+          @memory.add_tool_call(tool_name, arguments, result)
+          
+          return { tool_name: tool_name, arguments: arguments, result: result }
+        end
+      end
+    end
+    
+    def execute_tool(tool_name, arguments)
+      # Look in both static and dynamic tools
+      tool = @tools[tool_name] || @dynamic_tools[tool_name]
+      
+      if tool.nil?
+        return "Error: Tool '#{tool_name}' not found"
+      end
+      
+      begin
+        tool.call(arguments)
+      rescue => e
+        "Error executing tool: #{e.message}"
+      end
+    end
+    
+    # Helper method to extract tool code from tool results
+    def extract_tool_code_from_result(result)
+      # Look for class definition in the result
+      if result.include?("class") && result.include?("CustomToolBase")
+        # For cleaner extraction, look for Ruby code blocks
+        if result.include?("```ruby")
+          # Extract code from markdown code blocks
+          code_blocks = result.scan(/```ruby\n(.*?)\n```/m)
+          return code_blocks.first.first if code_blocks.any?
+        end
+        
+        # If no code blocks, try to extract class definition directly
+        class_match = result.match(/class\s+\w+\s*<\s*CustomToolBase.*?end/m)
+        return class_match[0] if class_match
+      end
+      
+      # If we couldn't extract a class definition, return nil
+      nil
+    end
+  end
+end

data/lib/rsmolagent/llm_provider.rb

@@ -0,0 +1,70 @@
+module RSmolagent
+  class LLMProvider
+    attr_reader :last_prompt_tokens, :last_completion_tokens
+
+    def initialize(model_id:, **options)
+      @model_id = model_id
+      @options = options
+      @last_prompt_tokens = 0
+      @last_completion_tokens = 0
+    end
+
+    def chat(messages, tools: nil, tool_choice: nil)
+      raise NotImplementedError, "Subclasses must implement the 'chat' method"
+    end
+
+    def extract_tool_calls(response)
+      raise NotImplementedError, "Subclasses must implement the 'extract_tool_calls' method"
+    end
+
+    def parse_json_if_needed(text)
+      return text unless text.is_a?(String)
+      
+      begin
+        JSON.parse(text)
+      rescue JSON::ParserError
+        text
+      end
+    end
+  end
+
+  class OpenAIProvider < LLMProvider
+    def initialize(model_id:, client:, **options)
+      super(model_id: model_id, **options)
+      @client = client
+    end
+
+    def chat(messages, tools: nil, tool_choice: nil)
+      params = {
+        model: @model_id,
+        messages: messages,
+        temperature: @options[:temperature] || 0.7,
+      }
+
+      # Add tools if provided
+      if tools && !tools.empty?
+        params[:tools] = tools.map(&:to_json_schema)
+        params[:tool_choice] = tool_choice || "auto"
+      end
+
+      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
+    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
+end

data/lib/rsmolagent/memory.rb

@@ -0,0 +1,65 @@
+module RSmolagent
+  class Memory
+    attr_reader :messages, :history
+
+    def initialize
+      @messages = []
+      @history = []
+    end
+
+    def add_system_message(content)
+      add_message("system", content)
+    end
+
+    def add_user_message(content)
+      add_message("user", content)
+    end
+
+    def add_assistant_message(content)
+      add_message("assistant", content)
+    end
+
+    def add_tool_message(name, content)
+      @messages << { role: "tool", name: name, content: content }
+    end
+
+    def add_tool_call(tool_name, arguments, result)
+      step = {
+        type: "tool_call",
+        tool_name: tool_name,
+        arguments: arguments,
+        result: result,
+        timestamp: Time.now
+      }
+      @history << step
+      step
+    end
+
+    def add_final_answer(answer)
+      step = {
+        type: "final_answer",
+        answer: answer,
+        timestamp: Time.now
+      }
+      @history << step
+      step
+    end
+
+    def to_openai_messages
+      @messages.map do |msg|
+        if msg[:role] == "tool"
+          { role: "tool", tool_call_id: "call_#{msg[:name]}", content: msg[:content].to_s }
+        else
+          { role: msg[:role], content: msg[:content] }
+        end
+      end
+    end
+
+    private
+
+    def add_message(role, content)
+      @messages << { role: role, content: content }
+      { role: role, content: content }
+    end
+  end
+end

data/lib/rsmolagent/tool.rb

@@ -0,0 +1,73 @@
+require 'json'
+
+module RSmolagent
+  class Tool
+    attr_reader :name, :description, :input_schema
+
+    def initialize(name:, description:, input_schema: {}, output_type: "string")
+      @name = name
+      @description = description
+      @input_schema = input_schema
+      @output_type = output_type
+    end
+
+    def call(args = {})
+      args = args.transform_keys(&:to_sym) if args.is_a?(Hash)
+      execute(args)
+    end
+
+    def execute(args)
+      raise NotImplementedError, "Subclasses must implement the 'execute' method"
+    end
+
+    def to_json_schema
+      {
+        "name" => @name,
+        "description" => @description,
+        "parameters" => {
+          "type" => "object",
+          "properties" => formatted_input_schema,
+          "required" => required_parameters
+        }
+      }
+    end
+
+    private
+
+    def formatted_input_schema
+      result = {}
+      @input_schema.each do |name, details|
+        result[name.to_s] = {
+          "type" => details[:type] || "string",
+          "description" => details[:description] || ""
+        }
+      end
+      result
+    end
+
+    def required_parameters
+      @input_schema.select { |_, details| details[:required] != false }
+                  .keys
+                  .map(&:to_s)
+    end
+  end
+
+  class FinalAnswerTool < Tool
+    def initialize
+      super(
+        name: "final_answer",
+        description: "Use this to provide the final answer to the task",
+        input_schema: {
+          answer: {
+            type: "string",
+            description: "The final answer to the task"
+          }
+        }
+      )
+    end
+
+    def execute(args)
+      args[:answer].to_s
+    end
+  end
+end

data/lib/rsmolagent/tools/custom_tool_base.rb

@@ -0,0 +1,91 @@
+module RSmolagent
+  module Tools
+    # Base class that custom tools can inherit from when using the CustomClassExecutorTool
+    class CustomToolBase
+      attr_reader :name, :description, :input_schema
+      
+      def initialize(name, description, input_schema = {})
+        @name = name
+        @description = description
+        @input_schema = input_schema
+      end
+      
+      # This method must be implemented by subclasses
+      def run(args = {})
+        raise NotImplementedError, "Subclasses must implement the 'run' method"
+      end
+      
+      # Helper methods that custom tools can use
+      
+      def fetch_url(url)
+        require 'net/http'
+        require 'uri'
+        
+        uri = URI(url)
+        Net::HTTP.get(uri)
+      end
+      
+      def parse_json(json_string)
+        require 'json'
+        JSON.parse(json_string)
+      end
+      
+      def to_tool
+        # Convert this custom tool to a RSmolagent::Tool
+        RSmolagent::Tool.new(
+          name: @name,
+          description: @description,
+          input_schema: @input_schema
+        ) do |args|
+          run(args)
+        end
+      end
+      
+      # Additional helper methods for safe file operations
+      def read_file(path)
+        # Only allow reading files from a specific directory in a real implementation
+        File.read(path)
+      end
+      
+      def write_file(path, content)
+        # Only allow writing files to a specific directory in a real implementation
+        File.write(path, content)
+      end
+    end
+    
+    # Factory for creating tools from custom tool classes
+    class CustomToolFactory
+      def self.create_from_code(code)
+        # Create a clean binding
+        context = Object.new.instance_eval { binding }
+        
+        # Make CustomToolBase available in the context
+        context.eval("CustomToolBase = RSmolagent::Tools::CustomToolBase")
+        
+        # Evaluate the code to define the class
+        context.eval(code)
+        
+        # Find the class name
+        class_name = extract_class_name(code)
+        
+        # Create an instance of the class
+        tool_instance = context.eval("#{class_name}.new")
+        
+        # Ensure it's a CustomToolBase
+        unless tool_instance.is_a?(CustomToolBase)
+          raise "The class must inherit from CustomToolBase"
+        end
+        
+        # Convert to a Tool
+        tool_instance.to_tool
+      end
+      
+      private
+      
+      def self.extract_class_name(code)
+        match = code.match(/class\s+([A-Z][A-Za-z0-9_]*)\s*(?:<\s*(?:CustomToolBase|[A-Z][A-Za-z0-9_]*))?\s*/)
+        match ? match[1] : nil
+      end
+    end
+  end
+end

data/lib/rsmolagent/tools/ruby_executor.rb

@@ -0,0 +1,189 @@
+require 'stringio'
+
+module RSmolagent
+  module Tools
+    class RubyExecutorTool < Tool
+      def initialize(name: "ruby_executor", description: nil)
+        description ||= "Executes Ruby code in a controlled environment. Use this to run custom Ruby code."
+        
+        super(
+          name: name,
+          description: description,
+          input_schema: {
+            code: {
+              type: "string",
+              description: "The Ruby code to execute. Can include class and method definitions."
+            }
+          }
+        )
+        
+        # Set of allowed classes/modules to access
+        @allowed_constants = [
+          'Array', 'Hash', 'String', 'Integer', 'Float', 'Time', 'Date',
+          'Enumerable', 'Math', 'JSON', 'CSV', 'URI', 'Net', 'File', 'Dir',
+          'StringIO', 'Regexp'
+        ]
+      end
+
+      def execute(args)
+        code = args[:code]
+        return "Error: No code provided" if code.nil? || code.strip.empty?
+        
+        # Capture stdout to return it along with the result
+        original_stdout = $stdout
+        captured_stdout = StringIO.new
+        $stdout = captured_stdout
+        
+        result = nil
+        begin
+          # Execute the code in the current binding with security limitations
+          result = execute_with_safety(code)
+          
+          # Format the output
+          stdout_content = captured_stdout.string.strip
+          
+          if stdout_content.empty?
+            "Result: #{result.inspect}"
+          else
+            "Output:\n#{stdout_content}\n\nResult: #{result.inspect}"
+          end
+        rescue => e
+          "Error: #{e.message}\n#{e.backtrace.first(3).join("\n")}"
+        ensure
+          # Restore stdout
+          $stdout = original_stdout
+        end
+      end
+      
+      private
+      
+      def execute_with_safety(code)
+        # Create a secure binding for execution
+        secure_binding = create_secure_binding
+        
+        # Execute the code in the secure binding
+        secure_binding.eval(code)
+      end
+      
+      def create_secure_binding
+        # Create a new binding with limited access to dangerous methods
+        safe_binding = binding.dup
+        
+        # Disable potentially dangerous methods in the binding
+        disable_dangerous_methods(safe_binding)
+        
+        # Return the secured binding
+        safe_binding
+      end
+      
+      def disable_dangerous_methods(binding_obj)
+        # This is a simplified approach - in a production environment,
+        # you would want a more comprehensive security model
+        dangerous_methods = [
+          'system', 'exec', '`', 'eval', 'syscall', 'fork', 'trap',
+          'require', 'load', 'open', 'Class.new', 'define_method'
+        ]
+        
+        # This is just a basic example - a real implementation would need
+        # more sophisticated sandboxing
+        # Note: This is not a complete security solution and should be enhanced
+        # for production use
+      end
+    end
+    
+    # A more specific custom tool executor that defines a class template
+    class CustomClassExecutorTool < Tool
+      def initialize(name: "custom_executor", description: nil, base_class: nil)
+        description ||= "Executes a custom Ruby class with predefined methods. " +
+                       "The class must implement a 'run' method that will be called."
+                       
+        @base_class = base_class
+        
+        super(
+          name: name,
+          description: description,
+          input_schema: {
+            code: {
+              type: "string",
+              description: "The Ruby class definition, must include a 'run' method"
+            },
+            args: {
+              type: "object",
+              description: "Arguments to pass to the run method (optional)",
+              required: false
+            }
+          }
+        )
+      end
+      
+      def execute(args)
+        code = args[:code]
+        run_args = args[:args] || {}
+        
+        return "Error: No code provided" if code.nil? || code.strip.empty?
+        
+        # Capture stdout
+        original_stdout = $stdout
+        captured_stdout = StringIO.new
+        $stdout = captured_stdout
+        
+        begin
+          # Create a clean context
+          context = Object.new.instance_eval { binding }
+          
+          # Inject base class if provided
+          if @base_class
+            context.eval("BaseClass = #{@base_class.name}")
+          end
+          
+          # Evaluate the code to define the class
+          context.eval(code)
+          
+          # Find the class we just defined
+          class_name = extract_class_name(code)
+          
+          if class_name.nil?
+            return "Error: Could not find a class definition in the provided code"
+          end
+          
+          # Instantiate the class
+          runner = context.eval("#{class_name}.new")
+          
+          # Ensure it has a run method
+          unless runner.respond_to?(:run)
+            return "Error: The class must implement a 'run' method"
+          end
+          
+          # Run the class's run method with provided arguments
+          if run_args.is_a?(Hash)
+            result = runner.run(**run_args)
+          else
+            result = runner.run(run_args)
+          end
+          
+          # Format the output
+          stdout_content = captured_stdout.string.strip
+          
+          if stdout_content.empty?
+            "Result: #{result.inspect}"
+          else
+            "Output:\n#{stdout_content}\n\nResult: #{result.inspect}"
+          end
+        rescue => e
+          "Error: #{e.message}\n#{e.backtrace.first(3).join("\n")}"
+        ensure
+          # Restore stdout
+          $stdout = original_stdout
+        end
+      end
+      
+      private
+      
+      def extract_class_name(code)
+        # Simple regex to extract the class name
+        match = code.match(/class\s+([A-Z][A-Za-z0-9_]*)\s*(?:<\s*(?:BaseClass|[A-Z][A-Za-z0-9_]*))?\s*/)
+        match ? match[1] : nil
+      end
+    end
+  end
+end

data/lib/rsmolagent/tools/web_search.rb

@@ -0,0 +1,101 @@
+require 'net/http'
+require 'json'
+require 'uri'
+require 'cgi'
+
+module RSmolagent
+  module Tools
+    class WebSearchTool < Tool
+      def initialize(max_results: 5)
+        super(
+          name: "web_search",
+          description: "Performs a web search based on your query (like a Google search) and returns the top search results",
+          input_schema: {
+            query: {
+              type: "string",
+              description: "The search query to perform"
+            }
+          }
+        )
+        @max_results = max_results
+      end
+
+      def execute(args)
+        query = args[:query]
+        
+        # Ensure query isn't empty
+        return "Error: Search query cannot be empty" if query.nil? || query.strip.empty?
+        
+        begin
+          results = search_duckduckgo(query)
+          
+          if results.nil? || results.empty?
+            return "No results found for query: '#{query}'. Try a less restrictive/shorter query."
+          end
+          
+          # Format the results as markdown
+          formatted_results = format_results(results)
+          return "## Search Results\n\n#{formatted_results}"
+        rescue => e
+          return "Error performing search: #{e.message}"
+        end
+      end
+
+      private
+
+      def search_duckduckgo(query)
+        # Use the DuckDuckGo API
+        encoded_query = CGI.escape(query)
+        uri = URI("https://api.duckduckgo.com/?q=#{encoded_query}&format=json")
+        
+        response = Net::HTTP.get_response(uri)
+        
+        if response.is_a?(Net::HTTPSuccess)
+          # Parse the response
+          data = JSON.parse(response.body)
+          
+          # Extract results
+          results = []
+          
+          # Get results from "AbstractText" if available
+          if data["AbstractText"] && !data["AbstractText"].empty?
+            results << {
+              title: data["Heading"],
+              url: data["AbstractURL"],
+              body: data["AbstractText"]
+            }
+          end
+          
+          # Get results from "RelatedTopics"
+          if data["RelatedTopics"]
+            data["RelatedTopics"].each do |topic|
+              next if topic["Text"].nil? || topic["FirstURL"].nil?
+              
+              # Extract title from the text (first few words)
+              text_parts = topic["Text"].split(" - ", 2)
+              title = text_parts.first || "Related Topic"
+              body = text_parts.last || text_parts.first
+              
+              results << {
+                title: title,
+                url: topic["FirstURL"],
+                body: body
+              }
+            end
+          end
+          
+          # Limit results to max_results
+          return results.first(@max_results)
+        else
+          raise "Request failed with status: #{response.code}"
+        end
+      end
+
+      def format_results(results)
+        results.map do |result|
+          "[#{result[:title]}](#{result[:url]})\n#{result[:body]}"
+        end.join("\n\n")
+      end
+    end
+  end
+end

data/lib/rsmolagent/tools.rb

@@ -0,0 +1,9 @@
+require 'rsmolagent/tools/web_search'
+require 'rsmolagent/tools/ruby_executor'
+require 'rsmolagent/tools/custom_tool_base'
+
+module RSmolagent
+  module Tools
+    # Add more tools here as needed
+  end
+end

data/lib/rsmolagent/version.rb

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

data/lib/rsmolagent.rb

@@ -0,0 +1,10 @@
+require "rsmolagent/version"
+require "rsmolagent/tool"
+require "rsmolagent/agent"
+require "rsmolagent/llm_provider"
+require "rsmolagent/memory"
+require "rsmolagent/tools"
+
+module RSmolagent
+  class Error < StandardError; end
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: rsmolagent
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- gkosmo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2025-03-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: ruby-openai
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: RSmolagent is a Ruby library for building AI agents that can use tools
+  to solve tasks
+email:
+- gkosmo1@hotmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/rsmolagent.rb
+- lib/rsmolagent/agent.rb
+- lib/rsmolagent/llm_provider.rb
+- lib/rsmolagent/memory.rb
+- lib/rsmolagent/tool.rb
+- lib/rsmolagent/tools.rb
+- lib/rsmolagent/tools/custom_tool_base.rb
+- lib/rsmolagent/tools/ruby_executor.rb
+- lib/rsmolagent/tools/web_search.rb
+- lib/rsmolagent/version.rb
+homepage: https://github.com/gkosmo/rsmolagent
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/gkosmo/rsmolagent
+  source_code_uri: https://github.com/gkosmo/rsmolagent
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.9
+signing_key: 
+specification_version: 4
+summary: A simple AI agent framework in Ruby
+test_files: []