ruby_llm 0.1.0.pre11 → 0.1.0.pre13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ed2ff977d45e5ac9a14d93b81740516f14f6c4ef33140e0163f6011efa14d697
-  data.tar.gz: a51b24bd4e88512d9abb3d4db33551bd391da97fa8161f8f6d1b23e415f427d1
+  metadata.gz: 325d22d60cd9f0a4157670442830fe2473e8e46879ee672d0e56207f6b3b8e72
+  data.tar.gz: 355be22334837f40ac717974058d4cceb4d46dd13e36a808c11410a9c4624dc0
 SHA512:
-  metadata.gz: ff245f6f9378b51481a096b63a4c5cb688cf80e3b5d218a9e0ff5ca74a0ac09c720a8647df8f8fe9603ee10d9b3b61e4704638d81051c1378694bff47f272e7f
-  data.tar.gz: 8fae7e20c68130cabc9d769a82b5b3a94d765b2cb53804a2df7833c402da37c6c781bcaaf477cb41a0b610026bfa57fee2670029793526c4375dee3731bc4bf3
+  metadata.gz: a7ea97dbe171c7f62df442134b613c84ec277dffcdf1e86fafeed14a95c7ba2545b950d454153606e205f13ffd5a79a9e6e8158d1f053be51a915bbfb03d4806
+  data.tar.gz: bb20ec1351e7597550283b7b7b2b1dff50a26ceba1b123b5fabd8636150f2fae5eb935dac51153448895b7782cdbb85575c25a671064928a8c83465489bea6b9

data/.rubocop.yml

@@ -1,3 +1,6 @@
 require:
   - rubocop-rake
-  - rubocop-rspec
+  - rubocop-rspec
+
+AllCops:
+  TargetRubyVersion: 3.1

data/README.md

@@ -79,37 +79,61 @@ puts "Conversation used #{last_message.input_tokens} input tokens and #{last_mes
 
 ## Using Tools
 
-Give Claude some Ruby superpowers by letting it call your code. Simply create a tool class:
+Give your AI assistants access to your Ruby code by creating tool classes that do one thing well:
 
 ```ruby
-class CalculatorTool < RubyLLM::Tool
+class Calculator < 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
+
+class Search < RubyLLM::Tool
+  description "Searches documents by similarity"
+
+  param :query,
+    desc: "The search query"
+
+  param :limit,
+    type: :integer,
+    desc: "Number of results to return",
+    required: false
+
+  def initialize(repo:)
+    @repo = repo
+  end
+
+  def execute(query:, limit: 5)
+    @repo.similarity_search(query, limit:)
+  end
+end
 ```
 
-Then use it in your conversations:
+Then use them in your conversations:
 
 ```ruby
-chat = RubyLLM.chat.with_tool(CalculatorTool)
+# Simple tools just work
+chat = RubyLLM.chat.with_tool Calculator
+
+# Tools with dependencies are just regular Ruby objects
+search = Search.new repo: Document
+chat.with_tools search, CalculatorTool
+
+# Need more control? Configure as needed
+chat.with_model('claude-3-5-sonnet-20241022')
+    .with_temperature(0.9)
 
-# Claude will automatically use the calculator when appropriate
 chat.ask "What's 2+2?"
 # => "Let me calculate that for you. The result is 4."
 
-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(CalculatorTool, WeatherTool, DatabaseTool)
+chat.ask "Find documents about Ruby performance"
+# => "I found these relevant documents about Ruby performance..."
 ```
 
 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.

data/lib/ruby_llm/chat.rb

@@ -10,6 +10,7 @@ module RubyLLM
       model_id = model || RubyLLM.config.default_model
       @model = Models.find model_id
       @provider = Models.provider_for model_id
+      @temperature = 0.7
       @messages = []
       @tools = {}
 
@@ -26,7 +27,7 @@ module RubyLLM
     def with_tool(tool)
       raise Error, "Model #{@model.id} doesn't support function calling" unless @model.supports_functions
 
-      tool_instance = tool.is_a?(Class) ? tool.to_tool : tool
+      tool_instance = tool.is_a?(Class) ? tool.new : tool
       @tools[tool_instance.name.to_sym] = tool_instance
       self
     end
@@ -36,6 +37,17 @@ module RubyLLM
       self
     end
 
+    def with_model(model_id)
+      @model = Models.find model_id
+      @provider = Models.provider_for model_id
+      self
+    end
+
+    def with_temperature(temperature)
+      @temperature = temperature
+      self
+    end
+
     def each(&block)
       messages.each(&block)
     end
@@ -43,19 +55,17 @@ module RubyLLM
     private
 
     def complete(&block)
-      response = @provider.complete(messages, tools: @tools, model: @model.id, &block)
+      response = @provider.complete messages, tools: @tools, temperature: @temperature, model: @model.id, &block
 
+      add_message response
       if response.tool_call?
         handle_tool_calls response, &block
       else
-        add_message response
         response
       end
     end
 
     def handle_tool_calls(response, &block)
-      add_message response
-
       response.tool_calls.each_value do |tool_call|
         result = execute_tool tool_call
         add_tool_result tool_call.id, result if result

data/lib/ruby_llm/message.rb

@@ -26,7 +26,7 @@ module RubyLLM
       !tool_call_id.nil? && !tool_call_id.empty?
     end
 
-    def tool_result
+    def tool_results
       content if tool_result?
     end
 

data/lib/ruby_llm/provider.rb

@@ -7,8 +7,8 @@ module RubyLLM
     end
 
     module InstanceMethods
-      def complete(messages, tools: [], model: nil, &block)
-        payload = build_payload messages, tools, model: model, stream: block_given?
+      def complete(messages, tools:, temperature:, model:, &block)
+        payload = build_payload messages, tools: tools, temperature: temperature, model: model, stream: block_given?
 
         if block_given?
           stream_response payload, &block

data/lib/ruby_llm/providers/anthropic.rb

@@ -26,7 +26,7 @@ module RubyLLM
         '/v1/models'
       end
 
-      def build_payload(messages, tools, model:, temperature: 0.7, stream: false)
+      def build_payload(messages, tools:, temperature:, model:, stream: false)
         {
           model: model,
           messages: format_messages(messages),
@@ -34,7 +34,7 @@ module RubyLLM
           stream: stream,
           max_tokens: RubyLLM.models.find(model).max_tokens
         }.tap do |payload|
-          payload[:tools] = tools.map { |t| function_for(t) } if tools.any?
+          payload[:tools] = tools.values.map { |t| function_for(t) } if tools.any?
         end
       end
 
@@ -42,26 +42,26 @@ module RubyLLM
         data = response.body
         content_blocks = data['content'] || []
 
-        text_content = content_blocks.find { |c| c['type'] == 'text' }&.fetch('text', '')
+        text_blocks = content_blocks.select { |c| c['type'] == 'text' }
+        text_content = text_blocks.map { |c| c['text'] }.join('')
+
         tool_use = content_blocks.find { |c| c['type'] == 'tool_use' }
 
         if tool_use
           Message.new(
             role: :assistant,
             content: text_content,
-            tool_calls: [
-              {
-                name: tool_use['name'],
-                arguments: JSON.generate(tool_use['input'] || {})
-              }
-            ]
+            tool_calls: parse_tool_calls(tool_use),
+            input_tokens: data.dig('usage', 'input_tokens'),
+            output_tokens: data.dig('usage', 'output_tokens'),
+            model_id: data['model']
           )
         else
           Message.new(
             role: :assistant,
             content: text_content,
-            input_tokens: data['usage']['input_tokens'],
-            output_tokens: data['usage']['output_tokens'],
+            input_tokens: data.dig('usage', 'input_tokens'),
+            output_tokens: data.dig('usage', 'output_tokens'),
             model_id: data['model']
           )
         end
@@ -90,18 +90,44 @@ module RubyLLM
 
       def handle_stream(&block)
         to_json_stream do |data|
-          block.call(
-            Chunk.new(
-              role: :assistant,
-              model_id: data.dig('message', 'model'),
-              content: data.dig('delta', 'text'),
-              input_tokens: data.dig('message', 'usage', 'input_tokens'),
-              output_tokens: data.dig('message', 'usage', 'output_tokens') || data.dig('usage', 'output_tokens')
+          if data['type'] == 'content_block_delta' && data.dig('delta', 'type') == 'input_json_delta'
+            block.call(
+              Chunk.new(
+                role: :assistant,
+                model_id: data.dig('message', 'model'),
+                content: data.dig('delta', 'text'),
+                input_tokens: data.dig('message', 'usage', 'input_tokens'),
+                output_tokens: data.dig('message', 'usage', 'output_tokens') || data.dig('usage', 'output_tokens'),
+                tool_calls: { nil => ToolCall.new(id: nil, name: nil, arguments: data.dig('delta', 'partial_json')) }
+              )
             )
-          )
+          else
+            block.call(
+              Chunk.new(
+                role: :assistant,
+                model_id: data.dig('message', 'model'),
+                content: data.dig('delta', 'text'),
+                input_tokens: data.dig('message', 'usage', 'input_tokens'),
+                output_tokens: data.dig('message', 'usage', 'output_tokens') || data.dig('usage', 'output_tokens'),
+                tool_calls: parse_tool_calls(data['content_block'])
+              )
+            )
+          end
         end
       end
 
+      def parse_tool_calls(content_block)
+        return nil unless content_block && content_block['type'] == 'tool_use'
+
+        {
+          content_block['id'] => ToolCall.new(
+            id: content_block['id'],
+            name: content_block['name'],
+            arguments: content_block['input']
+          )
+        }
+      end
+
       def function_for(tool)
         {
           name: tool.name,
@@ -116,16 +142,31 @@ module RubyLLM
 
       def format_messages(messages)
         messages.map do |msg|
-          if msg.tool_results
+          if msg.tool_call?
             {
-              role: convert_role(msg.role),
+              role: 'assistant',
+              content: [
+                {
+                  type: 'text',
+                  text: msg.content
+                },
+                {
+                  type: 'tool_use',
+                  id: msg.tool_calls.values.first.id,
+                  name: msg.tool_calls.values.first.name,
+                  input: msg.tool_calls.values.first.arguments
+                }
+              ]
+            }
+          elsif msg.tool_result?
+            {
+              role: 'user',
               content: [
                 {
                   type: 'tool_result',
-                  tool_use_id: msg.tool_results[:tool_use_id],
-                  content: msg.tool_results[:content],
-                  is_error: msg.tool_results[:is_error]
-                }.compact
+                  tool_use_id: msg.tool_call_id,
+                  content: msg.content
+                }
               ]
             }
           else
@@ -139,19 +180,23 @@ module RubyLLM
 
       def convert_role(role)
         case role
+        when :tool then 'user'
         when :user then 'user'
         else 'assistant'
         end
       end
 
       def clean_parameters(parameters)
-        parameters.transform_values do |props|
-          props.except(:required)
+        parameters.transform_values do |param|
+          {
+            type: param.type,
+            description: param.description
+          }.compact
         end
       end
 
       def required_parameters(parameters)
-        parameters.select { |_, props| props[:required] }.keys
+        parameters.select { |_, param| param.required }.keys
       end
     end
   end

data/lib/ruby_llm/providers/openai.rb

@@ -25,7 +25,7 @@ module RubyLLM
         '/v1/models'
       end
 
-      def build_payload(messages, tools, model:, temperature: 0.7, stream: false)
+      def build_payload(messages, tools:, temperature:, model:, stream: false)
         {
           model: model,
           messages: format_messages(messages),

data/lib/ruby_llm/tool.rb

@@ -1,7 +1,17 @@
 # frozen_string_literal: true
 
-# lib/ruby_llm/tool.rb
 module RubyLLM
+  class Parameter
+    attr_reader :name, :type, :description, :required
+
+    def initialize(name, type: 'string', desc: nil, required: true)
+      @name = name
+      @type = type
+      @description = desc
+      @required = required
+    end
+  end
+
   class Tool
     class << self
       def description(text = nil)
@@ -10,51 +20,34 @@ module RubyLLM
         @description = text
       end
 
-      def param(name, type:, desc: nil, required: true)
-        param = Parameter.new(
-          name,
-          type: type.to_s,
-          description: desc,
-          required: required
-        )
-        parameters[name] = param
+      def param(name, **options)
+        parameters[name] = Parameter.new(name, **options)
       end
 
       def parameters
         @parameters ||= {}
       end
+    end
 
-      def name
-        super
+    def name
+      self.class.name
           .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
           .gsub(/([a-z\d])([A-Z])/, '\1_\2')
           .downcase
           .delete_suffix('_tool')
-      end
-
-      def to_tool
-        tool_instance = new
-
-        def tool_instance.name
-          self.class.name
-        end
-
-        def tool_instance.description
-          self.class.description
-        end
+    end
 
-        def tool_instance.parameters
-          self.class.parameters
-        end
+    def description
+      self.class.description
+    end
 
-        tool_instance
-      end
+    def parameters
+      self.class.parameters
     end
 
     def call(args)
       RubyLLM.logger.debug "Tool #{name} called with: #{args.inspect}"
-      symbolized_args = args.transform_keys(&:to_sym)
-      result = execute(**symbolized_args)
+      result = execute(**args.transform_keys(&:to_sym))
       RubyLLM.logger.debug "Tool #{name} returned: #{result.inspect}"
       result
     rescue StandardError => e
@@ -62,28 +55,8 @@ module RubyLLM
       { error: e.message }
     end
 
-    def execute(args)
+    def execute(...)
       raise NotImplementedError, 'Subclasses must implement #execute'
     end
   end
-
-  # Using the existing Parameter class from Tool.rb
-  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
-    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.pre11'
+  VERSION = '0.1.0.pre13'
 end

data/ruby_llm.gemspec

@@ -15,7 +15,7 @@ Gem::Specification.new do |spec|
                        ' works.'
   spec.homepage      = 'https://github.com/crmne/ruby_llm'
   spec.license       = 'MIT'
-  spec.required_ruby_version = Gem::Requirement.new('>= 2.7.0')
+  spec.required_ruby_version = Gem::Requirement.new('>= 3.1.0')
 
   spec.metadata['homepage_uri'] = spec.homepage
   spec.metadata['source_code_uri'] = spec.homepage

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby_llm
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre11
+  version: 0.1.0.pre13
 platform: ruby
 authors:
 - Carmine Paolino
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-02-03 00:00:00.000000000 Z
+date: 2025-02-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: event_stream_parser
@@ -380,7 +380,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.7.0
+      version: 3.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="