ruby_llm 0.1.0.pre7 → 0.1.0.pre8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8eb02dfff845a6208bc5adfdf8521b631d9d55f426f97055c896e25c225d3951
-  data.tar.gz: 82406d843c66ad41a7a4cdc1b7ea756b6deb120e5e30a77ef983b8cc9e7ca935
+  metadata.gz: 38dc88557f16216a881c8cd0be702de77e8d0d332ab927f8c4fbfb804063a193
+  data.tar.gz: b5cf788ab7d948081e6fdf7649197dcecaa3d596b5afa992fe1b2288cb7bb935
 SHA512:
-  metadata.gz: fe88fbc67f5fd50951fb16b407279a507094b793c674e5cadab99ed2de58aff44aecdc7fcc1f36bb9a22ebb8faf9cc990c8682f7728c4665d08b20bfdcbbfb46
-  data.tar.gz: 62ca5d2399b8ffee6cc247ba36eec99d52488e7cbead4b20e7b7f17284ec65c4113ff3b2dad1b6c1169aab9a8a1bc1365c606a0f172e0d9d205f545c75eef1aa
+  metadata.gz: 7058ba5bad5baf2fabab9c01a8dd076d2b5b408d6538c87b6d8940464fd575f7da1c3c95294794d8bbc5f5875abc8321f0dba8d3085ad449d3720a82ca4c9d30
+  data.tar.gz: 1fe4831f21f43aa924cb86b4871d6318d3d98d910988b21339a327a2ddc818094e251586c37d48981d9ef8bdbd31ca91fd6a6cd55fbc7e47b2ad7d774abdc8a6

data/README.md

@@ -30,13 +30,11 @@ require 'ruby_llm'
 RubyLLM.configure do |config|
   config.openai_api_key = ENV['OPENAI_API_KEY']
   config.anthropic_api_key = ENV['ANTHROPIC_API_KEY']
-  config.default_model = 'gpt-4o-mini' # OpenAI's efficient model
 end
 
 # Start a conversation
 chat = RubyLLM.chat
-response = chat.ask "What's the best way to learn Ruby?"
-puts response.content
+chat.ask "What's the best way to learn Ruby?"
 ```
 
 ## Available Models
@@ -45,12 +43,7 @@ RubyLLM gives you access to the latest models from multiple providers. Check wha
 
 ```ruby
 # List all available models
-RubyLLM.models.all.each do |model|
-  puts "#{model.display_name} (#{model.provider})"
-  puts "  Context window: #{model.context_window}"
-  puts "  Price: $#{model.input_price_per_million}/M tokens (input)"
-  puts "        $#{model.output_price_per_million}/M tokens (output)"
-end
+RubyLLM.models.all
 
 # Get models by type
 chat_models = RubyLLM.models.chat_models
@@ -64,7 +57,7 @@ image_models = RubyLLM.models.image_models
 Conversations are simple and natural, with automatic token counting built right in:
 
 ```ruby
-chat = RubyLLM.chat model: 'claude-3-opus-20240229'
+chat = RubyLLM.chat model: 'claude-3-5-sonnet-20241022'
 
 # Single messages with token tracking
 response = chat.ask "What's your favorite Ruby feature?"
@@ -84,23 +77,54 @@ last_message = chat.messages.last
 puts "Conversation used #{last_message.input_tokens} input tokens and #{last_message.output_tokens} output tokens"
 ```
 
+## 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:
+
+```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}" }
+  end
+end
+
+# Use the tool in a conversation
+chat = RubyLLM.chat.with_tool calculator
+
+# The model will automatically use the tool when needed
+chat.ask "What's 2+2?"
+# => "The result of 2 + 2 is 4."
+
+chat.ask "and what's 2+100000000000?"
+# => "The result of 2 + 100,000,000,000 is 100,000,000,002."
+
+# Add multiple tools
+chat.with_tools calculator, other_tool, another_tool
+```
+
+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
 
 RubyLLM gives you easy access to model capabilities:
 
 ```ruby
-model = RubyLLM.models.find 'claude-3-opus-20240229'
+model = RubyLLM.models.find 'claude-3-5-sonnet-20241022'
 
-model.context_window     # => 200000
-model.max_tokens        # => 4096
-model.supports_vision?  # => true
-model.supports_json_mode? # => true
+model.context_window      # => 200000
+model.max_tokens          # => 8192
+model.supports_vision     # => true
+model.supports_json_mode  # => true
 ```
 
 ## Coming Soon
 
 - Rails integration for seamless database and Active Record support
-- Function calling / tool use capabilities
 - Automatic retries and error handling
 - Much more!
 

data/lib/ruby_llm/chat.rb

@@ -8,10 +8,12 @@ module RubyLLM
 
     def initialize(model: nil)
       model_id = model || RubyLLM.config.default_model
-      @model = Models.find(model_id)
-      @provider = Models.provider_for(model_id)
+      @model = Models.find model_id
+      @provider = Models.provider_for model_id
       @messages = []
-      @tools = []
+      @tools = {}
+
+      ensure_valid_tools
     end
 
     def ask(message, &block)
@@ -19,22 +21,20 @@ module RubyLLM
       complete(&block)
     end
 
-    def tool(tool)
+    alias say ask
+
+    def with_tool(tool)
       raise Error, "Model #{@model.id} doesn't support function calling" unless @model.supports_functions
 
-      @tools << tool
+      @tools[tool.name] = tool
       self
     end
 
-    alias with_tool tool
-
-    def tools(*tools)
-      tools.each { |tool| self.tool(tool) }
+    def with_tools(*tools)
+      tools.each { |tool| with_tool tool }
       self
     end
 
-    alias with_tools tools
-
     def each(&block)
       messages.each(&block)
     end
@@ -45,33 +45,27 @@ module RubyLLM
       response = @provider.complete(messages, tools: @tools, model: @model.id, &block)
 
       if response.tool_call?
-        handle_tool_calls(response)
+        handle_tool_calls response
       else
-        add_message(response)
+        add_message response
+        response
       end
-
-      response
     end
 
     def handle_tool_calls(response)
-      add_message(response)
+      add_message response
 
-      response.tool_calls.each do |tool_call|
-        result = execute_tool(tool_call)
-        add_tool_result(tool_call[:id], result) if result
+      response.tool_calls.each_value do |tool_call|
+        result = execute_tool tool_call
+        add_tool_result tool_call.id, result if result
       end
 
-      # Get final response after tool calls
-      final_response = complete
-      add_message(final_response)
-      final_response
+      complete
     end
 
     def execute_tool(tool_call)
-      tool = @tools.find { |t| t.name == tool_call[:name] }
-      return unless tool
-
-      args = JSON.parse(tool_call[:arguments], symbolize_names: true)
+      tool = tools[tool_call.name]
+      args = tool_call.arguments
       tool.call(args)
     end
 
@@ -83,13 +77,18 @@ module RubyLLM
 
     def add_tool_result(tool_use_id, result)
       add_message(
-        role: :user,
-        tool_results: {
-          tool_use_id: tool_use_id,
-          content: result.is_a?(Hash) && result[:error] ? result[:error] : result.to_s,
-          is_error: result.is_a?(Hash) && result[:error]
-        }
+        role: :tool,
+        content: result.is_a?(Hash) && result[:error] ? result[:error] : result.to_s,
+        tool_call_id: tool_use_id
       )
     end
+
+    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>}'
+        end
+      end
+    end
   end
 end

data/lib/ruby_llm/message.rb

@@ -4,16 +4,16 @@ module RubyLLM
   class Message
     ROLES = %i[system user assistant tool].freeze
 
-    attr_reader :role, :content, :tool_calls, :tool_results, :input_tokens, :output_tokens, :model_id
+    attr_reader :role, :content, :tool_calls, :tool_call_id, :input_tokens, :output_tokens, :model_id
 
     def initialize(options = {})
       @role = options[:role].to_sym
       @content = options[:content]
       @tool_calls = options[:tool_calls]
-      @tool_results = options[:tool_results]
       @input_tokens = options[:input_tokens]
       @output_tokens = options[:output_tokens]
       @model_id = options[:model_id]
+      @tool_call_id = options[:tool_call_id]
 
       ensure_valid_role
     end
@@ -23,7 +23,11 @@ module RubyLLM
     end
 
     def tool_result?
-      !tool_results.nil? && !tool_results.empty?
+      !tool_call_id.nil? && !tool_call_id.empty?
+    end
+
+    def tool_result
+      content if tool_result?
     end
 
     def to_h
@@ -31,7 +35,7 @@ module RubyLLM
         role: role,
         content: content,
         tool_calls: tool_calls,
-        tool_results: tool_results,
+        tool_call_id: tool_call_id,
         input_tokens: input_tokens,
         output_tokens: output_tokens,
         model_id: model_id

data/lib/ruby_llm/provider.rb

@@ -8,49 +8,50 @@ module RubyLLM
 
     module InstanceMethods
       def complete(messages, tools: [], model: nil, &block)
-        # TODO: refactor
-        payload = build_payload(messages, tools, model: model, stream: block_given?)
-
-        content = String.new
-        model_id = nil
-        input_tokens = 0
-        output_tokens = 0
-        response = connection.post(completion_url, payload) do |req|
-          req.headers.merge! headers
-          if block_given?
-            req.options.on_data = handle_stream do |chunk|
-              model_id ||= chunk.model_id
-              content << (chunk.content || '')
-              input_tokens += chunk.input_tokens if chunk.input_tokens
-              output_tokens += chunk.output_tokens if chunk.output_tokens
-              block.call(chunk)
-            end
-          end
-        end
+        payload = build_payload messages, tools, model: model, stream: block_given?
 
         if block_given?
-          Message.new(
-            role: :assistant,
-            content: content,
-            model_id: model_id,
-            input_tokens: input_tokens.positive? ? input_tokens : nil,
-            output_tokens: output_tokens.positive? ? output_tokens : nil
-          )
+          stream_response payload, &block
         else
-          parse_completion_response(response)
+          sync_response payload
         end
       end
 
       def list_models
         response = connection.get(models_url) do |req|
-          req.headers.merge!(headers)
+          req.headers.merge! headers
         end
 
-        parse_list_models_response(response)
+        parse_list_models_response response
       end
 
       private
 
+      def sync_response(payload)
+        response = post payload
+        parse_completion_response response
+      end
+
+      def stream_response(payload, &block)
+        accumulator = StreamAccumulator.new
+
+        post payload do |req|
+          req.options.on_data = handle_stream do |chunk|
+            accumulator.add chunk
+            block.call chunk
+          end
+        end
+
+        accumulator.to_message
+      end
+
+      def post(payload)
+        connection.post completion_url, payload do |req|
+          req.headers.merge! headers
+          yield req if block_given?
+        end
+      end
+
       def connection
         @connection ||= Faraday.new(api_base) do |f|
           f.options.timeout = RubyLLM.config.request_timeout

data/lib/ruby_llm/providers/openai.rb

@@ -33,7 +33,7 @@ module RubyLLM
           stream: stream
         }.tap do |payload|
           if tools.any?
-            payload[:tools] = tools.map { |t| tool_for(t) }
+            payload[:tools] = tools.map { |_, tool| tool_for(tool) }
             payload[:tool_choice] = 'auto'
           end
         end
@@ -44,21 +44,22 @@ module RubyLLM
           {
             role: msg.role.to_s,
             content: msg.content,
-            tool_calls: format_tool_calls(msg.tool_calls)
+            tool_calls: format_tool_calls(msg.tool_calls),
+            tool_call_id: msg.tool_call_id
           }.compact
         end
       end
 
       def format_tool_calls(tool_calls)
-        return nil unless tool_calls
+        return nil unless tool_calls&.any?
 
-        tool_calls.map do |tc|
+        tool_calls.map do |_, tc|
           {
-            id: tc[:id],
+            id: tc.id,
             type: 'function',
             function: {
-              name: tc[:name],
-              arguments: tc[:arguments]
+              name: tc.name,
+              arguments: JSON.generate(tc.arguments)
             }
           }
         end
@@ -103,15 +104,18 @@ module RubyLLM
         )
       end
 
-      def parse_tool_calls(tool_calls)
+      def parse_tool_calls(tool_calls, parse_arguments: true)
         return nil unless tool_calls&.any?
 
-        tool_calls.map do |tc|
-          {
-            id: tc['id'],
-            name: tc.dig('function', 'name'),
-            arguments: tc.dig('function', 'arguments')
-          }
+        tool_calls.to_h do |tc|
+          [
+            tc['id'],
+            ToolCall.new(
+              id: tc['id'],
+              name: tc.dig('function', 'name'),
+              arguments: parse_arguments ? JSON.parse(tc.dig('function', 'arguments')) : tc.dig('function', 'arguments')
+            )
+          ]
         end
       end
 
@@ -139,7 +143,8 @@ module RubyLLM
             Chunk.new(
               role: :assistant,
               model_id: data['model'],
-              content: data.dig('choices', 0, 'delta', 'content')
+              content: data.dig('choices', 0, 'delta', 'content'),
+              tool_calls: parse_tool_calls(data.dig('choices', 0, 'delta', 'tool_calls'), parse_arguments: false)
             )
           )
         end

data/lib/ruby_llm/stream_accumulator.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  class StreamAccumulator
+    attr_reader :content, :model_id, :tool_calls
+
+    def initialize
+      @content = String.new
+      @tool_calls = {}
+      @input_tokens = 0
+      @output_tokens = 0
+      @latest_tool_call_id = nil
+    end
+
+    def add(chunk)
+      RubyLLM.logger.debug chunk.inspect
+      @model_id ||= chunk.model_id
+
+      if chunk.tool_call?
+        accumulate_tool_calls chunk.tool_calls
+      else
+        @content << (chunk.content || '')
+      end
+
+      count_tokens chunk
+      RubyLLM.logger.debug inspect
+    end
+
+    def to_message
+      Message.new(
+        role: :assistant,
+        content: content,
+        model_id: model_id,
+        tool_calls: tool_calls_from_stream,
+        input_tokens: @input_tokens.positive? ? @input_tokens : nil,
+        output_tokens: @output_tokens.positive? ? @output_tokens : nil
+      )
+    end
+
+    private
+
+    def tool_calls_from_stream
+      tool_calls.transform_values do |tc|
+        ToolCall.new(
+          id: tc.id,
+          name: tc.name,
+          arguments: JSON.parse(tc.arguments)
+        )
+      end
+    end
+
+    def accumulate_tool_calls(new_tool_calls)
+      new_tool_calls.each_value do |tool_call|
+        if tool_call.id
+          @tool_calls[tool_call.id] = ToolCall.new(
+            id: tool_call.id,
+            name: tool_call.name,
+            arguments: String.new
+          )
+          @latest_tool_call_id = tool_call.id
+        else
+          existing = @tool_calls[@latest_tool_call_id]
+          existing.arguments << tool_call.arguments if existing
+        end
+      end
+    end
+
+    def find_tool_call(tool_call_id)
+      if tool_call_id.nil?
+        @tool_calls[@latest_tool_call]
+      else
+        @latest_tool_call_id = tool_call_id
+        @tool_calls[tool_call_id]
+      end
+    end
+
+    def count_tokens(chunk)
+      @input_tokens += chunk.input_tokens if chunk.input_tokens
+      @output_tokens += chunk.output_tokens if chunk.output_tokens
+    end
+  end
+end

data/lib/ruby_llm/tool.rb

@@ -60,9 +60,13 @@ module RubyLLM
       raise Error, "No handler defined for tool #{name}" unless @handler
 
       begin
+        RubyLLM.logger.debug "Calling tool #{name}(#{args.inspect})"
         args = symbolize_keys(args)
-        @handler.call(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
     end

data/lib/ruby_llm/tool_call.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  class ToolCall
+    attr_reader :id, :name, :arguments
+
+    def initialize(id:, name:, arguments: {})
+      @id = id
+      @name = name
+      @arguments = arguments
+    end
+  end
+end

data/lib/ruby_llm/version.rb

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

data/lib/ruby_llm.rb

@@ -28,7 +28,11 @@ module RubyLLM
     end
 
     def logger
-      @logger ||= Logger.new($stdout, level: ENV['RUBY_LLM_DEBUG'] == 'true' ? Logger::DEBUG : Logger::INFO)
+      @logger ||= Logger.new(
+        $stdout,
+        progname: 'RubyLLM',
+        level: ENV['RUBY_LLM_DEBUG'] == 'true' ? Logger::DEBUG : Logger::INFO
+      )
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby_llm
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre7
+  version: 0.1.0.pre8
 platform: ruby
 authors:
 - Carmine Paolino
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-02-01 00:00:00.000000000 Z
+date: 2025-02-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: event_stream_parser
@@ -357,7 +357,9 @@ files:
 - lib/ruby_llm/providers/anthropic.rb
 - lib/ruby_llm/providers/openai.rb
 - lib/ruby_llm/railtie.rb
+- lib/ruby_llm/stream_accumulator.rb
 - lib/ruby_llm/tool.rb
+- lib/ruby_llm/tool_call.rb
 - lib/ruby_llm/version.rb
 - lib/tasks/models.rake
 - ruby_llm.gemspec