ruby_llm 0.1.0.pre9 → 0.1.0.pre11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9847f95bd4212c5ff5c587b7f02c3c825cad2040398a6b23e0cf21d4302e3f61
-  data.tar.gz: 8248f03d0d68be21233e1809be6b00e87e5ce953f18412fa5ed4cfbc14436e11
+  metadata.gz: ed2ff977d45e5ac9a14d93b81740516f14f6c4ef33140e0163f6011efa14d697
+  data.tar.gz: a51b24bd4e88512d9abb3d4db33551bd391da97fa8161f8f6d1b23e415f427d1
 SHA512:
-  metadata.gz: a9127a969a82113209fb96e7f5951420865ad00fa3aff8a944111de7db114917558a31e46860e4204b0650fb91bcfba02c95af3a63c7a431712e96a2ada7d387
-  data.tar.gz: 2d2026be2e8365a57c8bfccd9a1b128f847258b8bdd138ff8cc252ba39bcc28d2f57a10512e3509bcd8e28cfdbe770c4c602c921deb4d432bf671a3575c54c2a
+  metadata.gz: ff245f6f9378b51481a096b63a4c5cb688cf80e3b5d218a9e0ff5ca74a0ac09c720a8647df8f8fe9603ee10d9b3b61e4704638d81051c1378694bff47f272e7f
+  data.tar.gz: 8fae7e20c68130cabc9d769a82b5b3a94d765b2cb53804a2df7833c402da37c6c781bcaaf477cb41a0b610026bfa57fee2670029793526c4375dee3731bc4bf3

data/README.md

@@ -39,7 +39,7 @@ chat.ask "What's the best way to learn Ruby?"
 
 ## Available Models
 
-RubyLLM gives you access to the latest models from multiple providers. Check what's available:
+RubyLLM gives you access to the latest models from multiple providers:
 
 ```ruby
 # List all available models
@@ -79,49 +79,53 @@ puts "Conversation used #{last_message.input_tokens} input tokens and #{last_mes
 
 ## Using Tools
 
-Give your AI superpowers by letting it use Ruby tools. This opens up a world of possibilities - from performing calculations to fetching data:
+Give Claude some Ruby superpowers by letting it call your code. Simply create a tool class:
 
 ```ruby
-# Define a calculator tool
-calculator = RubyLLM::Tool.define "calculate" do
-  description "Performs basic arithmetic calculations"
-  param :expression, type: "string"
-  handler do |args|
-    eval(args[:expression]).to_s
-  rescue => e
-    { error: "Invalid expression: #{e.message}" }
+class CalculatorTool < RubyLLM::Tool
+  description "Performs arithmetic calculations"
+
+  param :expression,
+    type: :string,
+    required: true,
+    desc: "A mathematical expression to evaluate (e.g. '2 + 2')"
+
+  def execute(expression:)
+    eval(expression).to_s
   end
 end
+```
 
-# Use the tool in a conversation
-chat = RubyLLM.chat.with_tool calculator
+Then use it in your conversations:
 
-# The model will automatically use the tool when needed
+```ruby
+chat = RubyLLM.chat.with_tool(CalculatorTool)
+
+# Claude will automatically use the calculator when appropriate
 chat.ask "What's 2+2?"
-# => "The result of 2 + 2 is 4."
+# => "Let me calculate that for you. The result is 4."
 
-chat.ask "and what's 2+100000000000?"
-# => "The result of 2 + 100,000,000,000 is 100,000,000,002."
+chat.ask "If I have 3 apples and multiply them by 5, how many do I have?"
+# => "Let me help you calculate that. 3 × 5 = 15, so you would have 15 apples."
 
 # Add multiple tools
-chat.with_tools calculator, other_tool, another_tool
+chat.with_tools(CalculatorTool, WeatherTool, DatabaseTool)
 ```
 
-Tools let you seamlessly integrate Ruby code with AI capabilities. Define tools for anything - database queries, API calls, custom business logic - and let the AI use them naturally in conversation.
-
-## Choosing the Right Model
+Tools let you seamlessly integrate your Ruby code with AI capabilities. The model will automatically decide when to use your tools and handle the results appropriately.
 
-RubyLLM gives you easy access to model capabilities:
+Need to debug a tool? RubyLLM automatically logs all tool calls and their results when debug logging is enabled:
 
 ```ruby
-model = RubyLLM.models.find 'claude-3-5-sonnet-20241022'
+ENV['RUBY_LLM_DEBUG'] = 'true'
 
-model.context_window      # => 200000
-model.max_tokens          # => 8192
-model.supports_vision     # => true
-model.supports_json_mode  # => true
+chat.ask "What's 123 * 456?"
+# D, -- RubyLLM: Tool calculator called with: {"expression" => "123 * 456"}
+# D, -- RubyLLM: Tool calculator returned: "56088"
 ```
 
+Create tools for anything - database queries, API calls, custom business logic - and let Claude use them naturally in conversation.
+
 ## Coming Soon
 
 - Rails integration for seamless database and Active Record support

data/lib/ruby_llm/chat.rb

@@ -26,7 +26,8 @@ module RubyLLM
     def with_tool(tool)
       raise Error, "Model #{@model.id} doesn't support function calling" unless @model.supports_functions
 
-      @tools[tool.name] = tool
+      tool_instance = tool.is_a?(Class) ? tool.to_tool : tool
+      @tools[tool_instance.name.to_sym] = tool_instance
       self
     end
 
@@ -64,7 +65,7 @@ module RubyLLM
     end
 
     def execute_tool(tool_call)
-      tool = tools[tool_call.name]
+      tool = tools[tool_call.name.to_sym]
       args = tool_call.arguments
       tool.call(args)
     end
@@ -85,8 +86,8 @@ module RubyLLM
 
     def ensure_valid_tools
       tools.each_key do |name|
-        unless name.is_a?(String) && tools[name].is_a?(RubyLLM::Tool)
-          raise Error, 'Tools should be of the format {<name>: <RubyLLM::Tool>}'
+        unless name.is_a?(Symbol) && tools[name].is_a?(RubyLLM::Tool)
+          raise Error, 'Tools should be of the format {<name.to_sym>: <RubyLLM::Tool>}'
         end
       end
     end

data/lib/ruby_llm/tool.rb

@@ -1,100 +1,89 @@
 # frozen_string_literal: true
 
+# lib/ruby_llm/tool.rb
 module RubyLLM
   class Tool
-    class Parameter
-      attr_reader :name, :type, :description, :required
+    class << self
+      def description(text = nil)
+        return @description unless text
 
-      def initialize(name, type: 'string', description: nil, required: true)
-        @name = name
-        @type = type
-        @description = description
-        @required = required
+        @description = text
       end
 
-      def to_h
-        {
-          type: type,
-          description: description,
+      def param(name, type:, desc: nil, required: true)
+        param = Parameter.new(
+          name,
+          type: type.to_s,
+          description: desc,
           required: required
-        }.compact
+        )
+        parameters[name] = param
       end
-    end
 
-    class Builder
-      def initialize(tool)
-        @tool = tool
+      def parameters
+        @parameters ||= {}
       end
 
-      def description(text)
-        @tool.instance_variable_set(:@description, text)
-        self
+      def name
+        super
+          .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+          .downcase
+          .delete_suffix('_tool')
       end
 
-      def param(name, type: 'string', description: nil, required: true)
-        @tool.parameters[name] = Parameter.new(name, type: type, description: description, required: required)
-        self
-      end
+      def to_tool
+        tool_instance = new
 
-      def handler(&block)
-        @tool.instance_variable_set(:@handler, block)
-        @tool
-      end
-    end
+        def tool_instance.name
+          self.class.name
+        end
 
-    attr_reader :name, :description, :parameters, :handler
+        def tool_instance.description
+          self.class.description
+        end
 
-    def self.define(name, &block)
-      tool = new(name)
-      builder = Builder.new(tool)
-      builder.instance_eval(&block)
-      tool
-    end
+        def tool_instance.parameters
+          self.class.parameters
+        end
 
-    def initialize(name)
-      @name = name
-      @parameters = {}
+        tool_instance
+      end
     end
 
     def call(args)
-      raise Error, "No handler defined for tool #{name}" unless @handler
-
-      begin
-        RubyLLM.logger.debug "Calling tool #{name}(#{args.inspect})"
-        args = symbolize_keys(args)
-        result = @handler.call(args)
-        RubyLLM.logger.debug "Tool #{name}(#{args.inspect}) returned: #{result.inspect}"
-        result
-      rescue StandardError => e
-        RubyLLM.logger.error "Tool #{name}(#{args.inspect}) failed with error #{e.message}"
-        { error: e.message }
-      end
+      RubyLLM.logger.debug "Tool #{name} called with: #{args.inspect}"
+      symbolized_args = args.transform_keys(&:to_sym)
+      result = execute(**symbolized_args)
+      RubyLLM.logger.debug "Tool #{name} returned: #{result.inspect}"
+      result
+    rescue StandardError => e
+      RubyLLM.logger.error "Tool #{name} failed with error: #{e.message}"
+      { error: e.message }
     end
 
-    class << self
-      def from_method(method, description: nil)
-        define(method.name.to_s) do
-          description description if description
+    def execute(args)
+      raise NotImplementedError, 'Subclasses must implement #execute'
+    end
+  end
 
-          method.parameters.each do |type, name|
-            param name, required: (type == :req)
-          end
+  # Using the existing Parameter class from Tool.rb
+  class Parameter
+    attr_reader :name, :type, :description, :required
 
-          handler do |args|
-            method.owner.new.public_send(method.name, **args)
-          end
-        end
-      end
+    def initialize(name, type: 'string', description: nil, required: true)
+      @name = name
+      @type = type
+      @description = description
+      @required = required
     end
 
-    private
-
-    def symbolize_keys(hash)
-      hash.transform_keys do |key|
-        key.to_sym
-      rescue StandardError
-        key
-      end
+    def to_h
+      {
+        type: type,
+        description: description,
+        required: required
+      }.compact
     end
   end
 end

data/lib/ruby_llm/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RubyLLM
-  VERSION = '0.1.0.pre9'
+  VERSION = '0.1.0.pre11'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_llm
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre9
+  version: 0.1.0.pre11
 platform: ruby
 authors:
 - Carmine Paolino