dify_llm 1.8.2 → 1.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7643dffaaba8bee51ea9d5929f3665be99f4e56fb84f5474fca20f8b8fd71fd5
-  data.tar.gz: 1a5db0333d2df1e09d1b1841e209677d57401137908e58426626844a5e9a11d9
+  metadata.gz: d85ea7861e7fdc76f629a92f9aa4768d61d8ad6ad069d540c35943356ab622cc
+  data.tar.gz: f684857d9908d597c2f913e0f57fad58e71bab4be9698e29dee95ec49c571f74
 SHA512:
-  metadata.gz: 305089c41bb76bf36aca07dfd95776b182debe2e059ce75dd34a77627516b2b95603de73780363cf5a9a2096df0109e433fdb420416067761daed700fad7c0b3
-  data.tar.gz: e7478c5771d9d00046d77a2965b801a705e63734360c1871e8865ac9ed634882e529bcf5b241cfeed103e38c87dd009730e6cab92075074b915525525525802e
+  metadata.gz: 71a889822eeb0a384e5dd9639eb92db1dc1d9da7d6da02fcc97000596affdb023ae32d9bebc341bf6810050b2146198fdb90af544d99a8d70a2b84be05dfe87e
+  data.tar.gz: 912691efa352436b5cc6ba1d1b5fbf0890e48591399b5c6e98f44a7d6c2721f2164ae1acebe906d48f987ce0f4cb90ff261cef66c35e7f8982133c31c9bfebfb

data/README.md

@@ -18,7 +18,7 @@ Battle tested at [<picture><source media="(prefers-color-scheme: dark)" srcset="
 </div>
 
 > [!NOTE]
-> Using RubyLLM in production? [Share your story](https://tally.so/r/3Na02p)! Takes 5 minutes.
+> Using RubyLLM? [Share your story](https://tally.so/r/3Na02p)! Takes 5 minutes.
 
 ---
 
@@ -69,6 +69,11 @@ RubyLLM.paint "a sunset over mountains in watercolor style"
 RubyLLM.embed "Ruby is elegant and expressive"
 ```
 
+```ruby
+# Transcribe audio to text
+RubyLLM.transcribe "meeting.wav"
+```
+
 ```ruby
 # Moderate content for safety
 RubyLLM.moderate "Check if this text is safe"
@@ -107,10 +112,10 @@ response = chat.with_schema(ProductSchema).ask "Analyze this product", with: "pr
 
 * **Chat:** Conversational AI with `RubyLLM.chat`
 * **Vision:** Analyze images and videos
-* **Audio:** Transcribe and understand speech
+* **Audio:** Transcribe and understand speech with `RubyLLM.transcribe`
 * **Documents:** Extract from PDFs, CSVs, JSON, any file type
 * **Image generation:** Create images with `RubyLLM.paint`
-* **Embeddings:** Vector search with `RubyLLM.embed`
+* **Embeddings:** Generate embeddings with `RubyLLM.embed`
 * **Moderation:** Content safety with `RubyLLM.moderate`
 * **Tools:** Let AI call your Ruby methods
 * **Structured output:** JSON schemas that just work

data/lib/generators/ruby_llm/generator_helpers.rb

@@ -52,8 +52,10 @@ module RubyLLM
       def acts_as_chat_declaration
         params = []
 
-        add_association_params(params, :messages, message_table_name, message_model_name, plural: true)
-        add_association_params(params, :model, model_table_name, model_model_name)
+        add_association_params(params, :messages, message_table_name, message_model_name,
+                               owner_table: chat_table_name, plural: true)
+        add_association_params(params, :model, model_table_name, model_model_name,
+                               owner_table: chat_table_name)
 
         "acts_as_chat#{" #{params.join(', ')}" if params.any?}"
       end
@@ -61,9 +63,12 @@ module RubyLLM
       def acts_as_message_declaration
         params = []
 
-        add_association_params(params, :chat, chat_table_name, chat_model_name)
-        add_association_params(params, :tool_calls, tool_call_table_name, tool_call_model_name, plural: true)
-        add_association_params(params, :model, model_table_name, model_model_name)
+        add_association_params(params, :chat, chat_table_name, chat_model_name,
+                               owner_table: message_table_name)
+        add_association_params(params, :tool_calls, tool_call_table_name, tool_call_model_name,
+                               owner_table: message_table_name, plural: true)
+        add_association_params(params, :model, model_table_name, model_model_name,
+                               owner_table: message_table_name)
 
         "acts_as_message#{" #{params.join(', ')}" if params.any?}"
       end
@@ -71,7 +76,8 @@ module RubyLLM
       def acts_as_model_declaration
         params = []
 
-        add_association_params(params, :chats, chat_table_name, chat_model_name, plural: true)
+        add_association_params(params, :chats, chat_table_name, chat_model_name,
+                               owner_table: model_table_name, plural: true)
 
         "acts_as_model#{" #{params.join(', ')}" if params.any?}"
       end
@@ -79,7 +85,8 @@ module RubyLLM
       def acts_as_tool_call_declaration
         params = []
 
-        add_association_params(params, :message, message_table_name, message_model_name)
+        add_association_params(params, :message, message_table_name, message_model_name,
+                               owner_table: tool_call_table_name)
 
         "acts_as_tool_call#{" #{params.join(', ')}" if params.any?}"
       end
@@ -120,6 +127,12 @@ module RubyLLM
         false
       end
 
+      def mysql?
+        ::ActiveRecord::Base.connection.adapter_name.downcase.include?('mysql')
+      rescue StandardError
+        false
+      end
+
       def table_exists?(table_name)
         ::ActiveRecord::Base.connection.table_exists?(table_name)
       rescue StandardError
@@ -128,13 +141,21 @@ module RubyLLM
 
       private
 
-      def add_association_params(params, default_assoc, table_name, model_name, plural: false)
+      def add_association_params(params, default_assoc, table_name, model_name, owner_table:, plural: false) # rubocop:disable Metrics/ParameterLists
         assoc = plural ? table_name.to_sym : table_name.singularize.to_sym
 
-        return if assoc == default_assoc
+        default_foreign_key = "#{default_assoc}_id"
+        # has_many/has_one: foreign key is on the associated table pointing back to owner
+        # belongs_to:       foreign key is on the owner table pointing to associated table
+        foreign_key = if plural || default_assoc.to_s.pluralize == default_assoc.to_s # has_many or has_one
+                        "#{owner_table.singularize}_id"
+                      else # belongs_to
+                        "#{table_name.singularize}_id"
+                      end
 
-        params << "#{default_assoc}: :#{assoc}"
+        params << "#{default_assoc}: :#{assoc}" if assoc != default_assoc
         params << "#{default_assoc.to_s.singularize}_class: '#{model_name}'" if model_name != assoc.to_s.classify
+        params << "#{default_assoc}_foreign_key: :#{foreign_key}" if foreign_key != default_foreign_key
       end
 
       # Convert namespaced model names to proper table names

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

@@ -3,8 +3,11 @@ class Create<%= message_model_name.gsub('::', '').pluralize %> < ActiveRecord::M
     create_table :<%= message_table_name %> do |t|
       t.string :role, null: false
       t.text :content
+      t.json :content_raw
       t.integer :input_tokens
       t.integer :output_tokens
+      t.integer :cached_tokens
+      t.integer :cache_creation_tokens
       t.timestamps
     end
 

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

@@ -14,6 +14,11 @@ class Create<%= model_model_name.gsub('::', '').pluralize %> < ActiveRecord::Mig
       t.jsonb :capabilities, default: []
       t.jsonb :pricing, default: {}
       t.jsonb :metadata, default: {}
+<% elsif mysql? %>
+      t.json :modalities
+      t.json :capabilities
+      t.json :pricing
+      t.json :metadata
 <% else %>
       t.json :modalities, default: {}
       t.json :capabilities, default: []

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

@@ -4,7 +4,13 @@ class Create<%= tool_call_model_name.gsub('::', '').pluralize %> < ActiveRecord:
     create_table :<%= tool_call_table_name %> do |t|
       t.string :tool_call_id, null: false
       t.string :name, null: false
-      t.<%= postgresql? ? 'jsonb' : 'json' %> :arguments, default: {}
+<% if postgresql? %>
+      t.jsonb :arguments, default: {}
+<% elsif mysql? %>
+      t.json :arguments
+<% else %>
+      t.json :arguments, default: {}
+<% end %>
       t.timestamps
     end
 

data/lib/generators/ruby_llm/upgrade_to_v1_7/upgrade_to_v1_7_generator.rb

@@ -9,7 +9,7 @@ module RubyLLM
     # Generator to upgrade existing RubyLLM apps to v1.7 with new Rails-like API
     class UpgradeToV17Generator < Rails::Generators::Base
       include Rails::Generators::Migration
-      include RubyLLM::GeneratorHelpers
+      include RubyLLM::Generators::GeneratorHelpers
 
       namespace 'ruby_llm:upgrade_to_v1_7'
       source_root File.expand_path('templates', __dir__)

data/lib/generators/ruby_llm/upgrade_to_v1_9/templates/add_v1_9_message_columns.rb.tt

@@ -0,0 +1,15 @@
+class AddRubyLlmV19Columns < ActiveRecord::Migration<%= migration_version %>
+  def change
+    unless column_exists?(:<%= message_table_name %>, :cached_tokens)
+      add_column :<%= message_table_name %>, :cached_tokens, :integer
+    end
+
+    unless column_exists?(:<%= message_table_name %>, :cache_creation_tokens)
+      add_column :<%= message_table_name %>, :cache_creation_tokens, :integer
+    end
+
+    unless column_exists?(:<%= message_table_name %>, :content_raw)
+      add_column :<%= message_table_name %>, :content_raw, :json
+    end
+  end
+end

data/lib/generators/ruby_llm/upgrade_to_v1_9/upgrade_to_v1_9_generator.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+require 'rails/generators/active_record'
+require_relative '../generator_helpers'
+
+module RubyLLM
+  module Generators
+    # Generator to add v1.9 columns (cached tokens + raw content support) to existing apps.
+    class UpgradeToV19Generator < Rails::Generators::Base
+      include Rails::Generators::Migration
+      include RubyLLM::Generators::GeneratorHelpers
+
+      namespace 'ruby_llm:upgrade_to_v1_9'
+      source_root File.expand_path('templates', __dir__)
+
+      argument :model_mappings, type: :array, default: [], banner: 'message:MessageName'
+
+      desc 'Adds cached token columns and raw content storage fields introduced in v1.9.0'
+
+      def self.next_migration_number(dirname)
+        ::ActiveRecord::Generators::Base.next_migration_number(dirname)
+      end
+
+      def create_migration_file
+        parse_model_mappings
+
+        migration_template 'add_v1_9_message_columns.rb.tt',
+                           'db/migrate/add_ruby_llm_v1_9_columns.rb',
+                           migration_version: migration_version,
+                           message_table_name: message_table_name
+      end
+
+      def show_next_steps
+        say_status :success, 'Upgrade prepared!', :green
+        say <<~INSTRUCTIONS
+
+          Next steps:
+          1. Review the generated migration
+          2. Run: rails db:migrate
+          3. Restart your application server
+
+          📚 See the v1.9.0 release notes for details on cached token tracking and raw content support.
+
+        INSTRUCTIONS
+      end
+    end
+  end
+end

data/lib/ruby_llm/active_record/acts_as.rb

@@ -11,28 +11,28 @@ module RubyLLM
         super
         # Monkey-patch Models to use database when ActsAs is active
         RubyLLM::Models.class_eval do
-          def load_models
+          def self.load_models
             read_from_database
           rescue StandardError => e
             RubyLLM.logger.debug "Failed to load models from database: #{e.message}, falling back to JSON"
             read_from_json
           end
 
-          def load_from_database!
-            @models = read_from_database
-          end
-
-          def read_from_database
+          def self.read_from_database
             model_class = RubyLLM.config.model_registry_class
             model_class = model_class.constantize if model_class.is_a?(String)
             model_class.all.map(&:to_llm)
           end
+
+          def load_from_database!
+            @models = self.class.read_from_database
+          end
         end
       end
 
       class_methods do # rubocop:disable Metrics/BlockLength
-        def acts_as_chat(messages: :messages, message_class: nil,
-                         model: :model, model_class: nil)
+        def acts_as_chat(messages: :messages, message_class: nil, messages_foreign_key: nil, # rubocop:disable Metrics/ParameterLists
+                         model: :model, model_class: nil, model_foreign_key: nil)
           include RubyLLM::ActiveRecord::ChatMethods
 
           class_attribute :messages_association_name, :model_association_name, :message_class, :model_class
@@ -45,12 +45,12 @@ module RubyLLM
           has_many messages,
                    -> { order(created_at: :asc) },
                    class_name: self.message_class,
-                   foreign_key: ActiveSupport::Inflector.foreign_key(table_name.singularize),
+                   foreign_key: messages_foreign_key,
                    dependent: :destroy
 
           belongs_to model,
                      class_name: self.model_class,
-                     foreign_key: ActiveSupport::Inflector.foreign_key(model.to_s.singularize),
+                     foreign_key: model_foreign_key,
                      optional: true
 
           delegate :add_message, to: :to_llm
@@ -68,7 +68,7 @@ module RubyLLM
           end
         end
 
-        def acts_as_model(chats: :chats, chat_class: nil)
+        def acts_as_model(chats: :chats, chat_class: nil, chats_foreign_key: nil)
           include RubyLLM::ActiveRecord::ModelMethods
 
           class_attribute :chats_association_name, :chat_class
@@ -80,18 +80,16 @@ module RubyLLM
           validates :provider, presence: true
           validates :name, presence: true
 
-          has_many chats,
-                   class_name: self.chat_class,
-                   foreign_key: ActiveSupport::Inflector.foreign_key(table_name.singularize)
+          has_many chats, class_name: self.chat_class, foreign_key: chats_foreign_key
 
           define_method :chats_association do
             send(chats_association_name)
           end
         end
 
-        def acts_as_message(chat: :chat, chat_class: nil, touch_chat: false, # rubocop:disable Metrics/ParameterLists
-                            tool_calls: :tool_calls, tool_call_class: nil,
-                            model: :model, model_class: nil)
+        def acts_as_message(chat: :chat, chat_class: nil, chat_foreign_key: nil, touch_chat: false, # rubocop:disable Metrics/ParameterLists
+                            tool_calls: :tool_calls, tool_call_class: nil, tool_calls_foreign_key: nil,
+                            model: :model, model_class: nil, model_foreign_key: nil)
           include RubyLLM::ActiveRecord::MessageMethods
 
           class_attribute :chat_association_name, :tool_calls_association_name, :model_association_name,
@@ -106,12 +104,12 @@ module RubyLLM
 
           belongs_to chat,
                      class_name: self.chat_class,
-                     foreign_key: ActiveSupport::Inflector.foreign_key(chat.to_s.singularize),
+                     foreign_key: chat_foreign_key,
                      touch: touch_chat
 
           has_many tool_calls,
                    class_name: self.tool_call_class,
-                   foreign_key: ActiveSupport::Inflector.foreign_key(table_name.singularize),
+                   foreign_key: tool_calls_foreign_key,
                    dependent: :destroy
 
           belongs_to :parent_tool_call,
@@ -126,7 +124,7 @@ module RubyLLM
 
           belongs_to model,
                      class_name: self.model_class,
-                     foreign_key: ActiveSupport::Inflector.foreign_key(model.to_s.singularize),
+                     foreign_key: model_foreign_key,
                      optional: true
 
           delegate :tool_call?, :tool_result?, to: :to_llm
@@ -144,8 +142,8 @@ module RubyLLM
           end
         end
 
-        def acts_as_tool_call(message: :message, message_class: nil,
-                              result: :result, result_class: nil)
+        def acts_as_tool_call(message: :message, message_class: nil, message_foreign_key: nil, # rubocop:disable Metrics/ParameterLists
+                              result: :result, result_class: nil, result_foreign_key: nil)
           class_attribute :message_association_name, :result_association_name, :message_class, :result_class
 
           self.message_association_name = message
@@ -155,11 +153,11 @@ module RubyLLM
 
           belongs_to message,
                      class_name: self.message_class,
-                     foreign_key: ActiveSupport::Inflector.foreign_key(message.to_s.singularize)
+                     foreign_key: message_foreign_key
 
           has_one result,
                   class_name: self.result_class,
-                  foreign_key: ActiveSupport::Inflector.foreign_key(table_name.singularize),
+                  foreign_key: result_foreign_key,
                   dependent: :nullify
 
           define_method :message_association do

data/lib/ruby_llm/active_record/chat_methods.rb

@@ -174,8 +174,16 @@ module RubyLLM
       end
 
       def create_user_message(content, with: nil)
-        message_record = messages_association.create!(role: :user, content: content)
+        content_text, attachments, content_raw = prepare_content_for_storage(content)
+
+        message_record = messages_association.build(role: :user)
+        message_record.content = content_text
+        message_record.content_raw = content_raw if message_record.respond_to?(:content_raw=)
+        message_record.save!
+
         persist_content(message_record, with) if with.present?
+        persist_content(message_record, attachments) if attachments.present?
+
         message_record
       end
 
@@ -235,28 +243,25 @@ module RubyLLM
         @message = messages_association.create!(role: :assistant, content: '')
       end
 
-      def persist_message_completion(message) # rubocop:disable Metrics/PerceivedComplexity
+      # rubocop:disable Metrics/PerceivedComplexity
+      def persist_message_completion(message)
         return unless message
 
         tool_call_id = find_tool_call_id(message.tool_call_id) if message.tool_call_id
 
         transaction do
-          content = message.content
-          attachments_to_persist = nil
-
-          if content.is_a?(RubyLLM::Content)
-            attachments_to_persist = content.attachments if content.attachments.any?
-            content = content.text
-          elsif content.is_a?(Hash) || content.is_a?(Array)
-            content = content.to_json
-          end
+          content_text, attachments_to_persist, content_raw = prepare_content_for_storage(message.content)
 
           attrs = {
             role: message.role,
-            content: content,
+            content: content_text,
             input_tokens: message.input_tokens,
             output_tokens: message.output_tokens
           }
+          attrs[:cached_tokens] = message.cached_tokens if @message.has_attribute?(:cached_tokens)
+          if @message.has_attribute?(:cache_creation_tokens)
+            attrs[:cache_creation_tokens] = message.cache_creation_tokens
+          end
 
           # Add model association dynamically
           attrs[self.class.model_association_name] = model_association
@@ -266,12 +271,15 @@ module RubyLLM
             attrs[parent_tool_call_assoc.foreign_key] = tool_call_id
           end
 
-          @message.update!(attrs)
+          @message.assign_attributes(attrs)
+          @message.content_raw = content_raw if @message.respond_to?(:content_raw=)
+          @message.save!
 
           persist_content(@message, attachments_to_persist) if attachments_to_persist
           persist_tool_calls(message.tool_calls) if message.tool_calls.present?
         end
       end
+      # rubocop:enable Metrics/PerceivedComplexity
 
       def persist_tool_calls(tool_calls)
         tool_calls.each_value do |tool_call|
@@ -331,6 +339,26 @@ module RubyLLM
         RubyLLM.logger.warn "Failed to process attachment #{source}: #{e.message}"
         nil
       end
+
+      def prepare_content_for_storage(content)
+        attachments = nil
+        content_raw = nil
+        content_text = content
+
+        case content
+        when RubyLLM::Content::Raw
+          content_raw = content.value
+          content_text = nil
+        when RubyLLM::Content
+          attachments = content.attachments if content.attachments.any?
+          content_text = content.text
+        when Hash, Array
+          content_raw = content
+          content_text = nil
+        end
+
+        [content_text, attachments, content_raw]
+      end
     end
   end
 end

data/lib/ruby_llm/active_record/message_methods.rb

@@ -11,6 +11,9 @@ module RubyLLM
       end
 
       def to_llm
+        cached = has_attribute?(:cached_tokens) ? self[:cached_tokens] : nil
+        cache_creation = has_attribute?(:cache_creation_tokens) ? self[:cache_creation_tokens] : nil
+
         RubyLLM::Message.new(
           role: role.to_sym,
           content: extract_content,
@@ -18,6 +21,8 @@ module RubyLLM
           tool_call_id: extract_tool_call_id,
           input_tokens: input_tokens,
           output_tokens: output_tokens,
+          cached_tokens: cached,
+          cache_creation_tokens: cache_creation,
           model_id: model_association&.model_id
         )
       end
@@ -42,9 +47,13 @@ module RubyLLM
       end
 
       def extract_content
-        return content unless respond_to?(:attachments) && attachments.attached?
+        return RubyLLM::Content::Raw.new(content_raw) if has_attribute?(:content_raw) && content_raw.present?
+
+        content_value = self[:content]
+
+        return content_value unless respond_to?(:attachments) && attachments.attached?
 
-        RubyLLM::Content.new(content).tap do |content_obj|
+        RubyLLM::Content.new(content_value).tap do |content_obj|
           @_tempfiles = []
 
           attachments.each do |attachment|

data/lib/ruby_llm/active_record/model_methods.rb

@@ -77,7 +77,7 @@ module RubyLLM
       delegate :supports?, :supports_vision?, :supports_functions?, :type,
                :input_price_per_million, :output_price_per_million,
                :function_calling?, :structured_output?, :batch?,
-               :reasoning?, :citations?, :streaming?,
+               :reasoning?, :citations?, :streaming?, :provider_class,
                to: :to_llm
     end
   end