ruby_llm 0.1.0.pre18 → 0.1.0.pre20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb34b8e16d243dfdc95d7fc6a70a67ecb2afac895da5a646e57dbc915da0a8e9
-  data.tar.gz: 6e95fb39b3670a38422b0dd79ec97263c34e6143751fef2272a6401ccac79c95
+  metadata.gz: c12d4699a9959fb454d21065bc5d666ef59873274f6bcaacb79c63cb7fdf9559
+  data.tar.gz: f391e7cb0970a1362238a5251bb7fc7316d5358af9542f059c112e84d0bed6cd
 SHA512:
-  metadata.gz: af33908a0ff937c4a7d0b074b4406c4211456dbb92c39d5c2237ca6463f3bd8129141a4b2c23270da85fbf90d26c0e8c6b295aaedb8574a23e0ab3eb107abd39
-  data.tar.gz: c6ce63d8d361fffcfaf6bfa2fbdea1df42ddf75e2969d68c5f789fbb14fccb61284c9a6b46fb0c0472c0e18cb31da150544b3cf2e9af4a1e53039a164b4d3e9f
+  metadata.gz: c20e3a9addf60aaa9e475f433ac3ae707d5f07a89f7f4b95c785749f9ad051194d306d6f00ba9570c06cf9b0488ac711646c44251528899304ec2945883fb097
+  data.tar.gz: 9f9f1dca17a24b0c478d98755722721410706f3e5f2993d19290fc55c69da3d3cc3d058fe01826e92e828446e74a552a36b3ede40561d32a65ffd72237ce9a36

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Carmine Paolino
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -82,16 +82,13 @@ Need vector embeddings for your text? RubyLLM makes it simple:
 
 ```ruby
 # Get embeddings with the default model
-vector = RubyLLM.embed "Hello, world!"
+RubyLLM.embed "Hello, world!"
 
 # Use a specific model
-vector = RubyLLM.embed(
-  "Ruby is awesome!",
-  model: "text-embedding-3-large"
-)
+RubyLLM.embed "Ruby is awesome!", model: "text-embedding-3-large"
 
 # Process multiple texts at once
-vectors = RubyLLM.embed([
+RubyLLM.embed([
   "First document",
   "Second document",
   "Third document"
@@ -191,16 +188,30 @@ end
 class CreateMessages < ActiveRecord::Migration[8.0]
   def change
     create_table :messages do |t|
-      t.references :chat
+      t.references :chat, null: false
       t.string :role
       t.text :content
-      t.json :tool_calls, default: {}
-      t.string :tool_call_id
+      t.string :model_id
       t.integer :input_tokens
       t.integer :output_tokens
-      t.string :model_id
+      t.references :tool_call
+      t.timestamps
+    end
+  end
+end
+
+# db/migrate/YYYYMMDDHHMMSS_create_tool_calls.rb
+class CreateToolCalls < ActiveRecord::Migration[8.0]
+  def change
+    create_table :tool_calls do |t|
+      t.references :message, null: false
+      t.string :tool_call_id, null: false
+      t.string :name, null: false
+      t.jsonb :arguments, default: {}
       t.timestamps
     end
+
+    add_index :tool_calls, :tool_call_id
   end
 end
 ```
@@ -218,20 +229,24 @@ end
 class Message < ApplicationRecord
   acts_as_message
 end
+
+class ToolCall < ApplicationRecord
+  acts_as_tool_call
+end
 ```
 
 That's it! Now you can use chats straight from your models:
 
 ```ruby
 # Create a new chat
-chat = Chat.create!(model_id: "gpt-4")
+chat = Chat.create! model_id: "gpt-4o-mini"
 
 # Ask questions - messages are automatically saved
 chat.ask "What's the weather in Paris?"
 
 # Stream responses in real-time
 chat.ask "Tell me a story" do |chunk|
-  broadcast_chunk(chunk)
+  broadcast_chunk chunk
 end
 
 # Everything is persisted automatically
@@ -289,7 +304,7 @@ The persistence works seamlessly with background jobs:
 ```ruby
 class ChatJob < ApplicationJob
   def perform(chat_id, message)
-    chat = Chat.find(chat_id)
+    chat = Chat.find chat_id
 
     chat.ask(message) do |chunk|
       # Optional: Broadcast chunks for real-time updates
@@ -323,8 +338,8 @@ class WeatherTool < RubyLLM::Tool
 end
 
 # Use tools with your persisted chats
-chat = Chat.create!(model_id: "gpt-4")
-chat.chat.with_tool(WeatherTool.new)
+chat = Chat.create! model_id: "gpt-4"
+chat.chat.with_tool WeatherTool.new
 
 # Ask about weather - tool usage is automatically saved
 chat.ask "What's the weather in Paris?"
@@ -334,8 +349,6 @@ pp chat.messages.map(&:role)
 #=> [:user, :assistant, :tool, :assistant]
 ```
 
-Looking for more examples? Check out the [example Rails app](https://github.com/example/ruby_llm_rails) showing these patterns in action!
-
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt.
@@ -346,4 +359,4 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/crmne/
 
 ## License
 
-Released under the MIT License. See LICENSE.txt for details.
+Released under the MIT License. See [LICENSE](LICENSE) for details.

data/lib/ruby_llm/active_record/acts_as.rb

@@ -8,13 +8,16 @@ module RubyLLM
     module ActsAs
       extend ActiveSupport::Concern
 
-      class_methods do
-        def acts_as_chat(message_class: 'Message') # rubocop:disable Metrics/MethodLength
+      class_methods do # rubocop:disable Metrics/BlockLength
+        def acts_as_chat(message_class: 'Message', tool_call_class: 'ToolCall') # rubocop:disable Metrics/MethodLength
           include ChatMethods
 
+          @message_class = message_class.to_s
+          @tool_call_class = tool_call_class.to_s
+
           has_many :messages,
                    -> { order(created_at: :asc) },
-                   class_name: message_class.to_s,
+                   class_name: @message_class,
                    dependent: :destroy
 
           delegate :complete,
@@ -28,13 +31,35 @@ module RubyLLM
                    to: :to_llm
         end
 
-        def acts_as_message(chat_class: 'Chat')
+        def acts_as_message(chat_class: 'Chat', tool_call_class: 'ToolCall') # rubocop:disable Metrics/MethodLength
           include MessageMethods
 
-          belongs_to :chat, class_name: chat_class.to_s
+          @chat_class = chat_class.to_s
+          @tool_call_class = tool_call_class.to_s
+
+          belongs_to :chat, class_name: @chat_class
+          has_many :tool_calls, class_name: @tool_call_class, dependent: :destroy
+
+          belongs_to :parent_tool_call,
+                     class_name: @tool_call_class,
+                     foreign_key: 'tool_call_id',
+                     optional: true,
+                     inverse_of: :result
 
           delegate :tool_call?, :tool_result?, :tool_results, to: :to_llm
         end
+
+        def acts_as_tool_call(message_class: 'Message')
+          @message_class = message_class.to_s
+
+          belongs_to :message, class_name: @message_class
+
+          has_one :result,
+                  class_name: @message_class,
+                  foreign_key: 'tool_call_id',
+                  inverse_of: :parent_tool_call,
+                  dependent: :nullify
+        end
       end
     end
 
@@ -43,6 +68,10 @@ module RubyLLM
     module ChatMethods
       extend ActiveSupport::Concern
 
+      class_methods do
+        attr_reader :tool_call_class
+      end
+
       def to_llm
         chat = RubyLLM.chat(model: model_id)
 
@@ -73,18 +102,32 @@ module RubyLLM
         )
       end
 
-      def persist_message_completion(message)
+      def persist_message_completion(message) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
         return unless message
 
-        messages.last.update!(
-          role: message.role,
-          content: message.content,
-          model_id: message.model_id,
-          tool_calls: message.tool_calls,
-          tool_call_id: message.tool_call_id,
-          input_tokens: message.input_tokens,
-          output_tokens: message.output_tokens
-        )
+        if message.tool_call_id
+          tool_call_id = self.class.tool_call_class.constantize.find_by(tool_call_id: message.tool_call_id).id
+        end
+
+        transaction do
+          messages.last.update!(
+            role: message.role,
+            content: message.content,
+            model_id: message.model_id,
+            tool_call_id: tool_call_id,
+            input_tokens: message.input_tokens,
+            output_tokens: message.output_tokens
+          )
+          persist_tool_calls(message.tool_calls) if message.tool_calls.present?
+        end
+      end
+
+      def persist_tool_calls(tool_calls)
+        tool_calls.each_value do |tool_call|
+          attributes = tool_call.to_h
+          attributes[:tool_call_id] = attributes.delete(:id)
+          messages.last.tool_calls.create!(**attributes)
+        end
       end
     end
 
@@ -97,13 +140,30 @@ module RubyLLM
         RubyLLM::Message.new(
           role: role.to_sym,
           content: content,
-          tool_calls: tool_calls,
-          tool_call_id: tool_call_id,
+          tool_calls: extract_tool_calls,
+          tool_call_id: extract_tool_call_id,
           input_tokens: input_tokens,
           output_tokens: output_tokens,
           model_id: model_id
         )
       end
+
+      def extract_tool_calls
+        tool_calls.to_h do |tool_call|
+          [
+            tool_call.tool_call_id,
+            RubyLLM::ToolCall.new(
+              id: tool_call.tool_call_id,
+              name: tool_call.name,
+              arguments: tool_call.arguments
+            )
+          ]
+        end
+      end
+
+      def extract_tool_call_id
+        parent_tool_call&.tool_call_id
+      end
     end
   end
 end

data/lib/ruby_llm/providers/openai.rb

@@ -43,13 +43,14 @@ module RubyLLM
             payload[:tools] = tools.map { |_, tool| tool_for(tool) }
             payload[:tool_choice] = 'auto'
           end
+          payload[:stream_options] = { include_usage: true } if stream
         end
       end
 
       def format_messages(messages)
         messages.map do |msg|
           {
-            role: msg.role.to_s,
+            role: format_role(msg.role),
             content: msg.content,
             tool_calls: format_tool_calls(msg.tool_calls),
             tool_call_id: msg.tool_call_id
@@ -57,6 +58,15 @@ module RubyLLM
         end
       end
 
+      def format_role(role)
+        case role
+        when :system
+          'developer'
+        else
+          role.to_s
+        end
+      end
+
       def build_embedding_payload(text, model:)
         {
           model: model,
@@ -156,14 +166,16 @@ module RubyLLM
         end.compact
       end
 
-      def handle_stream(&block)
+      def handle_stream(&block) # rubocop:disable Metrics/MethodLength
         to_json_stream do |data|
           block.call(
             Chunk.new(
               role: :assistant,
               model_id: data['model'],
               content: data.dig('choices', 0, 'delta', 'content'),
-              tool_calls: parse_tool_calls(data.dig('choices', 0, 'delta', 'tool_calls'), parse_arguments: false)
+              tool_calls: parse_tool_calls(data.dig('choices', 0, 'delta', 'tool_calls'), parse_arguments: false),
+              input_tokens: data.dig('usage', 'prompt_tokens'),
+              output_tokens: data.dig('usage', 'completion_tokens')
             )
           )
         end

data/lib/ruby_llm/tool_call.rb

@@ -19,5 +19,13 @@ module RubyLLM
       @name = name
       @arguments = arguments
     end
+
+    def to_h
+      {
+        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.pre18'
+  VERSION = '0.1.0.pre20'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby_llm
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre18
+  version: 0.1.0.pre20
 platform: ruby
 authors:
 - Carmine Paolino
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-02-06 00:00:00.000000000 Z
+date: 2025-02-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: event_stream_parser
@@ -339,6 +339,7 @@ files:
 - ".rspec"
 - ".rubocop.yml"
 - Gemfile
+- LICENSE
 - README.md
 - Rakefile
 - bin/console