ruby_llm 1.3.2beta1 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b069393971ae461a63487ba8a13d1f81a791d96fc0f537fceb02de88d9e690d0
-  data.tar.gz: c34f0884ffd9cffd3c0311ebbe8d7fbacc151b17512984b999dace24fa0bfe74
+  metadata.gz: cb8de9c3cea5895389517529bcf2a69c9c2f02aadbc6cc299fae6192e7776135
+  data.tar.gz: da3fabd00fbe863009d04d88c0092f03c90d4ab4bea1ec9c727048b479e9b0dd
 SHA512:
-  metadata.gz: 5ba83dd19febb3070e0f127eb6dc87fd92664d8afae2f4024240588fdc8624dabdcc5c2b089e5147d22601c3505b966f4bed7383fbf6e36ce8dff5bea568ef87
-  data.tar.gz: b7940d1a6b8bf72ba08eb9d63440505935022d372ffdab6aac51599fb23a9e68af49085cb965488f7306d28143f7b39ec9c0138a93ba52ad3ca3ac574e03a442
+  metadata.gz: 23ef0c8b9b4afa983526fa3327d06432bec87dbb0f002a726b9ae44c0d65c390416ac46208a93d5956d3ec8539505c72e3fffc44ca5907faadc14e444d6910d9
+  data.tar.gz: 31be38b7ff4ad1dad3f49e2eb8a27d4027f0970d2da3dcdce55a132887bf00459f7c92fd8271c73c70ff844f3aab9ba8edf19f6b0dd030977fe6447ed8a6df2b

data/README.md

@@ -12,6 +12,8 @@
   <img src="https://registry.npmmirror.com/@lobehub/icons-static-svg/latest/files/icons/deepseek-text.svg" alt="DeepSeek" class="logo-small">
   &nbsp;
   <img src="https://registry.npmmirror.com/@lobehub/icons-static-svg/latest/files/icons/gemini-brand-color.svg" alt="Gemini" class="logo-large">
+  <br>
+  <img src="https://raw.githubusercontent.com/gpustack/gpustack/main/docs/assets/gpustack-logo.png" alt="GPUStack" class="logo-medium" height="16">
   &nbsp;
   <img src="https://registry.npmmirror.com/@lobehub/icons-static-svg/latest/files/icons/ollama.svg" alt="Ollama" class="logo-medium">
   <img src="https://registry.npmmirror.com/@lobehub/icons-static-svg/latest/files/icons/ollama-text.svg" alt="Ollama" class="logo-medium">
@@ -121,34 +123,31 @@ See the [Installation Guide](https://rubyllm.com/installation) for full details.
 
 Add persistence to your chat models effortlessly:
 
+```bash
+# Generate models and migrations (available in v1.4.0)
+rails generate ruby_llm:install
+```
+
 ```ruby
-# app/models/chat.rb
+# Or add to existing models
 class Chat < ApplicationRecord
   acts_as_chat # Automatically saves messages & tool calls
-  # ... your other model logic ...
 end
 
-# app/models/message.rb
 class Message < ApplicationRecord
   acts_as_message
-  # ...
 end
 
-# app/models/tool_call.rb (if using tools)
 class ToolCall < ApplicationRecord
   acts_as_tool_call
-  # ...
 end
 
-# Now interacting with a Chat record persists the conversation:
-chat_record = Chat.create!(model_id: "gpt-4.1-nano")
-chat_record.ask("Explain Active Record callbacks.") # User & Assistant messages saved
-
-# Works seamlessly with file attachments - types automatically detected
-chat_record.ask("What's in this file?", with: "report.pdf")
-chat_record.ask("Analyze these", with: ["image.jpg", "data.csv", "notes.txt"])
+# Now chats persist automatically
+chat = Chat.create!(model_id: "gpt-4.1-nano")
+chat.ask("What's in this file?", with: "report.pdf")
 ```
-Check the [Rails Integration Guide](https://rubyllm.com/guides/rails) for more.
+
+See the [Rails Integration Guide](https://rubyllm.com/guides/rails) for details.
 
 ## Learn More
 

data/lib/generators/ruby_llm/install/templates/INSTALL_INFO.md.tt

@@ -0,0 +1,108 @@
+# RubyLLM Rails Setup Complete!
+
+Thanks for installing RubyLLM in your Rails application. Here's what was created:
+
+## Models
+
+- `<%= options[:chat_model_name] %>` - Stores chat sessions and their associated model ID
+- `<%= options[:message_model_name] %>` - Stores individual messages in a chat
+- `<%= options[:tool_call_model_name] %>` - Stores tool calls made by language models
+
+**Note:** Do not add `validates :content, presence: true` to your Message model - RubyLLM creates empty assistant messages before API calls for streaming support.
+
+## Configuration Options
+
+The generator supports the following options to customize model names:
+
+```bash
+rails generate ruby_llm:install \
+  --chat-model-name=Conversation \
+  --message-model-name=ChatMessage \
+  --tool-call-model-name=FunctionCall
+```
+
+This is useful when you need to avoid namespace collisions with existing models in your application. Table names will be automatically derived from the model names following Rails conventions.
+
+## Next Steps
+
+1. **Run migrations:**
+   ```bash
+   rails db:migrate
+   ```
+
+   **Database Note:** The migrations use `jsonb` for PostgreSQL and `json` for MySQL/SQLite automatically.
+
+2. **Set your API keys** in `config/initializers/ruby_llm.rb` or using environment variables:
+   ```ruby
+   # config/initializers/ruby_llm.rb
+   RubyLLM.configure do |config|
+     config.openai_api_key = ENV['OPENAI_API_KEY']
+     config.anthropic_api_key = ENV['ANTHROPIC_API_KEY']
+     config.gemini_api_key = ENV['GEMINI_API_KEY']
+     # ... add other providers as needed
+   end
+   ```
+
+3. **Start using RubyLLM in your code:**
+   ```ruby
+   # Basic usage
+   chat = <%= options[:chat_model_name] %>.create!(model_id: 'gpt-4.1-nano')
+   response = chat.ask("What is Ruby on Rails?")
+
+   # With file attachments (requires ActiveStorage setup)
+   chat.ask("What's in this file?", with: "report.pdf")
+   chat.ask("Analyze these files", with: ["image.jpg", "data.csv", "notes.txt"])
+   ```
+
+4. **For streaming responses** with Hotwire/Turbo:
+   ```ruby
+   # app/models/<%= options[:message_model_name].underscore %>.rb
+   class <%= options[:message_model_name] %> < ApplicationRecord
+     acts_as_message
+
+     # Helper to broadcast chunks during streaming
+     def broadcast_append_chunk(chunk_content)
+       broadcast_append_to [ chat, "messages" ],
+         target: dom_id(self, "content"),
+         html: chunk_content
+     end
+   end
+
+   # app/jobs/chat_stream_job.rb
+   class ChatStreamJob < ApplicationJob
+     def perform(chat_id, user_content)
+       chat = <%= options[:chat_model_name] %>.find(chat_id)
+       chat.ask(user_content) do |chunk|
+         assistant_message = chat.messages.last
+         if chunk.content && assistant_message
+           assistant_message.broadcast_append_chunk(chunk.content)
+         end
+       end
+     end
+   end
+
+   # In your controller
+   ChatStreamJob.perform_later(@chat.id, params[:content])
+   ```
+
+## Optional: ActiveStorage for Attachments
+
+If you want to use file attachments (PDFs, images, etc.), set up ActiveStorage:
+
+```bash
+rails active_storage:install
+rails db:migrate
+```
+
+Then add to your Message model:
+```ruby
+class <%= options[:message_model_name] %> < ApplicationRecord
+  acts_as_message
+  has_many_attached :attachments
+end
+```
+
+## Learn More
+
+- See the [Rails Integration Guide](https://rubyllm.com/guides/rails) for detailed examples
+- Visit the [RubyLLM Documentation](https://rubyllm.com) for full API reference

data/lib/generators/ruby_llm/install/templates/chat_model.rb.tt

@@ -0,0 +1,3 @@
+class <%= options[:chat_model_name] %> < ApplicationRecord
+  <%= acts_as_chat_declaration %>
+end

data/lib/generators/ruby_llm/install/templates/create_chats_migration.rb.tt

@@ -0,0 +1,8 @@
+class Create<%= options[:chat_model_name].pluralize %> < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :<%= options[:chat_model_name].tableize %> do |t|
+      t.string :model_id
+      t.timestamps
+    end
+  end
+end

data/lib/generators/ruby_llm/install/templates/create_messages_migration.rb.tt

@@ -0,0 +1,15 @@
+# Migration for creating messages table with references to chats and tool_calls
+class Create<%= options[:message_model_name].pluralize %> < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :<%= options[:message_model_name].tableize %> do |t|
+      t.references :<%= options[:chat_model_name].tableize.singularize %>, null: false, foreign_key: true
+      t.string :role
+      t.text :content
+      t.string :model_id
+      t.integer :input_tokens
+      t.integer :output_tokens
+      t.references :<%= options[:tool_call_model_name].tableize.singularize %>
+      t.timestamps
+    end
+  end
+end

data/lib/generators/ruby_llm/install/templates/create_tool_calls_migration.rb.tt

@@ -0,0 +1,14 @@
+<%#- # Migration for creating tool_calls table with database-specific JSON handling -%>
+class Create<%= options[:tool_call_model_name].pluralize %> < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :<%= options[:tool_call_model_name].tableize %> do |t|
+      t.references :<%= options[:message_model_name].tableize.singularize %>, null: false, foreign_key: true
+      t.string :tool_call_id, null: false
+      t.string :name, null: false
+      t.<%= postgresql? ? 'jsonb' : 'json' %> :arguments, default: {}
+      t.timestamps
+    end
+
+    add_index :<%= options[:tool_call_model_name].tableize %>, :tool_call_id
+  end
+end

data/lib/generators/ruby_llm/install/templates/initializer.rb.tt

@@ -0,0 +1,6 @@
+RubyLLM.configure do |config|
+  config.openai_api_key = ENV["OPENAI_API_KEY"]
+  config.anthropic_api_key = ENV["ANTHROPIC_API_KEY"]
+
+  # config.default_model = "gpt-4.1-nano"
+end

data/lib/generators/ruby_llm/install/templates/message_model.rb.tt

@@ -0,0 +1,3 @@
+class <%= options[:message_model_name] %> < ApplicationRecord
+  <%= acts_as_message_declaration %>
+end

data/lib/generators/ruby_llm/install/templates/tool_call_model.rb.tt

@@ -0,0 +1,3 @@
+class <%= options[:tool_call_model_name] %> < ApplicationRecord
+  <%= acts_as_tool_call_declaration %>
+end

data/lib/generators/ruby_llm/install_generator.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+require 'rails/generators/active_record'
+
+module RubyLLM
+  # Generator for RubyLLM Rails models and migrations
+  class InstallGenerator < Rails::Generators::Base
+    include Rails::Generators::Migration
+
+    namespace 'ruby_llm:install'
+
+    source_root File.expand_path('install/templates', __dir__)
+
+    class_option :chat_model_name, type: :string, default: 'Chat',
+                                   desc: 'Name of the Chat model class'
+    class_option :message_model_name, type: :string, default: 'Message',
+                                      desc: 'Name of the Message model class'
+    class_option :tool_call_model_name, type: :string, default: 'ToolCall',
+                                        desc: 'Name of the ToolCall model class'
+
+    desc 'Creates model files for Chat, Message, and ToolCall, and creates migrations for RubyLLM Rails integration'
+
+    def self.next_migration_number(dirname)
+      ::ActiveRecord::Generators::Base.next_migration_number(dirname)
+    end
+
+    def migration_version
+      "[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]"
+    end
+
+    def postgresql?
+      ActiveRecord::Base.connection.adapter_name.downcase.include?('postgresql')
+    rescue StandardError
+      false
+    end
+
+    def acts_as_chat_declaration
+      acts_as_chat_params = []
+      if options[:message_model_name] != 'Message'
+        acts_as_chat_params << "message_class: \"#{options[:message_model_name]}\""
+      end
+      if options[:tool_call_model_name] != 'ToolCall'
+        acts_as_chat_params << "tool_call_class: \"#{options[:tool_call_model_name]}\""
+      end
+      if acts_as_chat_params.any?
+        "acts_as_chat #{acts_as_chat_params.join(', ')}"
+      else
+        'acts_as_chat'
+      end
+    end
+
+    def acts_as_message_declaration
+      acts_as_message_params = []
+      acts_as_message_params << "chat_class: \"#{options[:chat_model_name]}\"" if options[:chat_model_name] != 'Chat'
+      if options[:tool_call_model_name] != 'ToolCall'
+        acts_as_message_params << "tool_call_class: \"#{options[:tool_call_model_name]}\""
+      end
+      if acts_as_message_params.any?
+        "acts_as_message #{acts_as_message_params.join(', ')}"
+      else
+        'acts_as_message'
+      end
+    end
+
+    def acts_as_tool_call_declaration
+      acts_as_tool_call_params = []
+      if options[:message_model_name] != 'Message'
+        acts_as_tool_call_params << "message_class: \"#{options[:message_model_name]}\""
+      end
+      if acts_as_tool_call_params.any?
+        "acts_as_tool_call #{acts_as_tool_call_params.join(', ')}"
+      else
+        'acts_as_tool_call'
+      end
+    end
+
+    def create_migration_files
+      # Create migrations with timestamps to ensure proper order
+      # First create chats table
+      migration_template 'create_chats_migration.rb.tt',
+                         "db/migrate/create_#{options[:chat_model_name].tableize}.rb"
+
+      # Then create tool_calls table
+      sleep 1 # Ensure different timestamp
+      migration_template 'create_tool_calls_migration.rb.tt',
+                         "db/migrate/create_#{options[:tool_call_model_name].tableize}.rb"
+
+      # Finally create messages table
+      sleep 1 # Ensure different timestamp
+      migration_template 'create_messages_migration.rb.tt',
+                         "db/migrate/create_#{options[:message_model_name].tableize}.rb"
+    end
+
+    def create_model_files
+      template 'chat_model.rb.tt', "app/models/#{options[:chat_model_name].underscore}.rb"
+      template 'message_model.rb.tt', "app/models/#{options[:message_model_name].underscore}.rb"
+      template 'tool_call_model.rb.tt', "app/models/#{options[:tool_call_model_name].underscore}.rb"
+    end
+
+    def create_initializer
+      template 'initializer.rb.tt', 'config/initializers/ruby_llm.rb'
+    end
+
+    def show_install_info
+      say "\n  ✅ RubyLLM installed!", :green
+
+      say "\n  Next steps:", :yellow
+      say '     1. Run: rails db:migrate'
+      say '     2. Set your API keys in config/initializers/ruby_llm.rb'
+      say "     3. Start chatting: #{options[:chat_model_name]}.create!(model_id: 'gpt-4.1-nano').ask('Hello!')"
+
+      say "\n  📚 Full docs: https://rubyllm.com", :cyan
+
+      say "\n  ❤️  Love RubyLLM?", :magenta
+      say '     • ⭐ Star on GitHub: https://github.com/crmne/ruby_llm'
+      say '     • 💖 Sponsor: https://github.com/sponsors/crmne'
+      say "\n"
+    end
+  end
+end

data/lib/ruby_llm/active_record/acts_as.rb

@@ -84,8 +84,12 @@ module RubyLLM
         attr_reader :tool_call_class
       end
 
-      def to_llm
-        @chat ||= RubyLLM.chat(model: model_id)
+      def to_llm(context: nil)
+        @chat ||= if context
+                    context.chat(model: model_id)
+                  else
+                    RubyLLM.chat(model: model_id)
+                  end
         @chat.reset_messages!
 
         messages.each do |msg|
@@ -125,8 +129,18 @@ module RubyLLM
         self
       end
 
-      def with_context(...)
-        to_llm.with_context(...)
+      def with_context(context)
+        to_llm(context: context)
+        self
+      end
+
+      def with_params(...)
+        to_llm.with_params(...)
+        self
+      end
+
+      def with_schema(...)
+        to_llm.with_schema(...)
         self
       end
 
@@ -175,9 +189,13 @@ module RubyLLM
         tool_call_id = find_tool_call_id(message.tool_call_id) if message.tool_call_id
 
         transaction do
+          # Convert parsed JSON back to JSON string for storage
+          content = message.content
+          content = content.to_json if content.is_a?(Hash) || content.is_a?(Array)
+
           @message.update!(
             role: message.role,
-            content: message.content,
+            content: content,
             model_id: message.model_id,
             input_tokens: message.input_tokens,
             output_tokens: message.output_tokens

data/lib/ruby_llm/aliases.json

@@ -3,16 +3,6 @@
     "openai": "chatgpt-4o-latest",
     "openrouter": "openai/chatgpt-4o-latest"
   },
-  "claude-2.0": {
-    "anthropic": "claude-2.0",
-    "openrouter": "anthropic/claude-2.0",
-    "bedrock": "anthropic.claude-v2:1:200k"
-  },
-  "claude-2.1": {
-    "anthropic": "claude-2.1",
-    "openrouter": "anthropic/claude-2.1",
-    "bedrock": "anthropic.claude-v2:1:200k"
-  },
   "claude-3-5-haiku": {
     "anthropic": "claude-3-5-haiku-20241022",
     "openrouter": "anthropic/claude-3.5-haiku",
@@ -39,9 +29,8 @@
     "bedrock": "anthropic.claude-3-opus-20240229-v1:0:200k"
   },
   "claude-3-sonnet": {
-    "anthropic": "claude-3-sonnet-20240229",
-    "openrouter": "anthropic/claude-3-sonnet",
-    "bedrock": "anthropic.claude-3-sonnet-20240229-v1:0:200k"
+    "bedrock": "anthropic.claude-3-sonnet-20240229-v1:0",
+    "openrouter": "anthropic/claude-3-sonnet"
   },
   "claude-opus-4": {
     "anthropic": "claude-opus-4-20250514",
@@ -69,6 +58,10 @@
     "gemini": "gemini-2.5-flash",
     "openrouter": "google/gemini-2.5-flash"
   },
+  "gemini-2.5-flash-lite": {
+    "gemini": "gemini-2.5-flash-lite",
+    "openrouter": "google/gemini-2.5-flash-lite"
+  },
   "gemini-2.5-flash-lite-preview-06-17": {
     "gemini": "gemini-2.5-flash-lite-preview-06-17",
     "openrouter": "google/gemini-2.5-flash-lite-preview-06-17"
@@ -181,14 +174,6 @@
     "openai": "o1-mini-2024-09-12",
     "openrouter": "openai/o1-mini-2024-09-12"
   },
-  "o1-preview": {
-    "openai": "o1-preview",
-    "openrouter": "openai/o1-preview"
-  },
-  "o1-preview-2024-09-12": {
-    "openai": "o1-preview-2024-09-12",
-    "openrouter": "openai/o1-preview-2024-09-12"
-  },
   "o1-pro": {
     "openai": "o1-pro",
     "openrouter": "openai/o1-pro"

data/lib/ruby_llm/chat.rb

@@ -11,7 +11,7 @@ module RubyLLM
   class Chat
     include Enumerable
 
-    attr_reader :model, :messages, :tools
+    attr_reader :model, :messages, :tools, :params, :schema
 
     def initialize(model: nil, provider: nil, assume_model_exists: false, context: nil)
       if assume_model_exists && !provider
@@ -25,9 +25,12 @@ module RubyLLM
       @temperature = 0.7
       @messages = []
       @tools = {}
+      @params = {}
+      @schema = nil
       @on = {
         new_message: nil,
-        end_message: nil
+        end_message: nil,
+        tool_call: nil
       }
     end
 
@@ -78,6 +81,28 @@ module RubyLLM
       self
     end
 
+    def with_params(**params)
+      @params = params
+      self
+    end
+
+    def with_schema(schema, force: false)
+      unless force || @model.structured_output?
+        raise UnsupportedStructuredOutputError, "Model #{@model.id} doesn't support structured output"
+      end
+
+      schema_instance = schema.is_a?(Class) ? schema.new : schema
+
+      # Accept both RubyLLM::Schema instances and plain JSON schemas
+      @schema = if schema_instance.respond_to?(:to_json_schema)
+                  schema_instance.to_json_schema[:schema]
+                else
+                  schema_instance
+                end
+
+      self
+    end
+
     def on_new_message(&block)
       @on[:new_message] = block
       self
@@ -88,21 +113,38 @@ module RubyLLM
       self
     end
 
+    def on_tool_call(&block)
+      @on[:tool_call] = block
+      self
+    end
+
     def each(&)
       messages.each(&)
     end
 
-    def complete(&)
+    def complete(&) # rubocop:disable Metrics/PerceivedComplexity
       response = @provider.complete(
         messages,
         tools: @tools,
         temperature: @temperature,
         model: @model.id,
         connection: @connection,
+        params: @params,
+        schema: @schema,
         &wrap_streaming_block(&)
       )
 
       @on[:new_message]&.call unless block_given?
+
+      # Parse JSON if schema was set
+      if @schema && response.content.is_a?(String)
+        begin
+          response.content = JSON.parse(response.content)
+        rescue JSON::ParserError
+          # If parsing fails, keep content as string
+        end
+      end
+
       add_message response
       @on[:end_message]&.call(response)
 
@@ -145,6 +187,7 @@ module RubyLLM
     def handle_tool_calls(response, &)
       response.tool_calls.each_value do |tool_call|
         @on[:new_message]&.call
+        @on[:tool_call]&.call(tool_call)
         result = execute_tool tool_call
         message = add_message role: :tool, content: result.to_s, tool_call_id: tool_call.id
         @on[:end_message]&.call(message)

data/lib/ruby_llm/configuration.rb

@@ -24,6 +24,8 @@ module RubyLLM
                   :bedrock_session_token,
                   :openrouter_api_key,
                   :ollama_api_base,
+                  :gpustack_api_base,
+                  :gpustack_api_key,
                   # Default models
                   :default_model,
                   :default_embedding_model,

data/lib/ruby_llm/error.rb

@@ -25,6 +25,7 @@ module RubyLLM
   class ModelNotFoundError < StandardError; end
   class UnsupportedFunctionsError < StandardError; end
   class UnsupportedAttachmentError < StandardError; end
+  class UnsupportedStructuredOutputError < StandardError; end
 
   # Error classes for different HTTP status codes
   class BadRequestError < Error; end

data/lib/ruby_llm/message.rb

@@ -7,7 +7,8 @@ module RubyLLM
   class Message
     ROLES = %i[system user assistant tool].freeze
 
-    attr_reader :role, :tool_calls, :tool_call_id, :input_tokens, :output_tokens, :model_id
+    attr_reader :role, :tool_calls, :tool_call_id, :input_tokens, :output_tokens, :model_id, :raw
+    attr_writer :content
 
     def initialize(options = {})
       @role = options.fetch(:role).to_sym
@@ -17,6 +18,7 @@ module RubyLLM
       @output_tokens = options[:output_tokens]
       @model_id = options[:model_id]
       @tool_call_id = options[:tool_call_id]
+      @raw = options[:raw]
 
       ensure_valid_role
     end