ruby_llm 0.1.0.pre8 → 0.1.0.pre10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 38dc88557f16216a881c8cd0be702de77e8d0d332ab927f8c4fbfb804063a193
-  data.tar.gz: b5cf788ab7d948081e6fdf7649197dcecaa3d596b5afa992fe1b2288cb7bb935
+  metadata.gz: 7d37a2d7434c6fba64700425cb86e29a6d04108f72e89e2a51273581adacb2a8
+  data.tar.gz: 45021416cdf96bf2ffdac2917a689515d519014d51054c6a4fe02bc60343685d
 SHA512:
-  metadata.gz: 7058ba5bad5baf2fabab9c01a8dd076d2b5b408d6538c87b6d8940464fd575f7da1c3c95294794d8bbc5f5875abc8321f0dba8d3085ad449d3720a82ca4c9d30
-  data.tar.gz: 1fe4831f21f43aa924cb86b4871d6318d3d98d910988b21339a327a2ddc818094e251586c37d48981d9ef8bdbd31ca91fd6a6cd55fbc7e47b2ad7d774abdc8a6
+  metadata.gz: 7ba9769ef1b6763e983540a02f42139bd4063bbdfb03b5999e33d78db82a46cb09b58778406b575f7b4d66105a42db8973c0a96939706ad80697aca01623a7dc
+  data.tar.gz: 0027621e9fbb2e2261eb4d2d8ef44672813cf9e0a5b523d8b850ca2ea1c52614671dbf914ca55bbe3cd5d029b163b4ac7308221f63afa4dae20230ce9ee88f4c

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,55 @@ 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|
+class CalculatorTool < RubyLLM::Tool
+  description "Performs arithmetic calculations"
+
+  param :expression,
+    type: :string,
+    required: true,
+    desc: "A mathematical expression to evaluate (e.g. '2 + 2')"
+
+  private
+
+  def execute(args)
     eval(args[:expression]).to_s
-  rescue => e
-    { error: "Invalid expression: #{e.message}" }
   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.
+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.
 
-## Choosing the Right Model
-
-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
 
@@ -45,14 +46,14 @@ module RubyLLM
       response = @provider.complete(messages, tools: @tools, model: @model.id, &block)
 
       if response.tool_call?
-        handle_tool_calls response
+        handle_tool_calls response, &block
       else
         add_message response
         response
       end
     end
 
-    def handle_tool_calls(response)
+    def handle_tool_calls(response, &block)
       add_message response
 
       response.tool_calls.each_value do |tool_call|
@@ -60,11 +61,11 @@ module RubyLLM
         add_tool_result tool_call.id, result if result
       end
 
-      complete
+      complete(&block)
     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,90 @@
 # frozen_string_literal: true
 
+# lib/ruby_llm/tool.rb
 module RubyLLM
   class Tool
-    class Parameter
-      attr_reader :name, :type, :description, :required
-
-      def initialize(name, type: 'string', description: nil, required: true)
-        @name = name
-        @type = type
-        @description = description
-        @required = required
+    class << self
+      def description(text = nil)
+        return @description unless text
+
+        @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}"
+      result = execute(args.transform_keys(&:to_sym))
+      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
-
-          method.parameters.each do |type, name|
-            param name, required: (type == :req)
-          end
+    private
 
-          handler do |args|
-            method.owner.new.public_send(method.name, **args)
-          end
-        end
-      end
+    def execute(args)
+      raise NotImplementedError, 'Subclasses must implement #execute'
     end
+  end
 
-    private
+  # Using the existing Parameter class from Tool.rb
+  class Parameter
+    attr_reader :name, :type, :description, :required
 
-    def symbolize_keys(hash)
-      hash.transform_keys do |key|
-        key.to_sym
-      rescue StandardError
-        key
-      end
+    def initialize(name, type: 'string', description: nil, required: true)
+      @name = name
+      @type = type
+      @description = description
+      @required = required
+    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.pre8'
+  VERSION = '0.1.0.pre10'
 end

metadata

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