ruby_llm-mongoid 0.1.0

data/lib/ruby_llm/mongoid/grid_fs_attachment.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+require "tmpdir"
+
+module RubyLLM
+  module Mongoid
+    # Optional concern for message models that want GridFS-backed file attachments
+    # instead of Active Storage.
+    #
+    # Usage:
+    #   class Message
+    #     include Mongoid::Document
+    #     include RubyLLM::Mongoid::GridFsAttachment
+    #     acts_as_message
+    #   end
+    #
+    # Each uploaded file is stored in a MongoDB GridFS bucket (default: "attachments").
+    # Metadata is tracked in the +gridfs_file_ids+ array field on the document.
+    #
+    # To use a different bucket name:
+    #   class Message
+    #     include RubyLLM::Mongoid::GridFsAttachment
+    #     use_gridfs_bucket :llm_files
+    #   end
+    module GridFsAttachment
+      extend ActiveSupport::Concern
+
+      included do
+        # Array of { "id" => BSON::ObjectId, "filename" => String, "content_type" => String }
+        field :gridfs_file_ids, type: Array, default: []
+
+        before_destroy :delete_gridfs_files
+        after_find :cleanup_gridfs_tempfiles
+        after_save :cleanup_gridfs_tempfiles
+      end
+
+      # Cleanup tempfiles created during download
+      def cleanup_gridfs_tempfiles
+        return unless defined?(@_gridfs_tempfiles) && @_gridfs_tempfiles
+
+        @_gridfs_tempfiles.each do |f|
+          f.close
+          f.unlink
+        rescue StandardError => e
+          RubyLLM.logger.warn "RubyLLM: Failed to cleanup GridFS tempfile #{f.path}: #{e.message}"
+        end
+        @_gridfs_tempfiles = []
+      end
+
+      # Builds a RubyLLM::Content that streams each stored file back from GridFS.
+      # Called by message_methods#extract_content when gridfs_file_ids is non-empty.
+      def gridfs_content(text)
+        sources = gridfs_file_ids.filter_map { |meta| download_gridfs_file(meta) }
+        return text if sources.empty?
+
+        if text.present?
+          RubyLLM::Content.new(text).tap { |c| sources.each { |f, name| c.add_attachment(f, filename: name) } }
+        else
+          RubyLLM::Content.new(nil, sources.map(&:first))
+        end
+      end
+
+      module ClassMethods
+        def use_gridfs_bucket(name)
+          @gridfs_bucket_name = name.to_s
+          @_gridfs_bucket = nil
+        end
+
+        def gridfs_bucket_name
+          @gridfs_bucket_name ||= "attachments"
+        end
+
+        def gridfs_bucket
+          @gridfs_bucket ||= ::Mongo::Grid::FSBucket.new(
+            ::Mongoid.default_client.database,
+            fs_name: gridfs_bucket_name
+          )
+        end
+      end
+
+      private
+
+      def delete_gridfs_files
+        gridfs_file_ids.each do |meta|
+          self.class.gridfs_bucket.delete(coerce_object_id(meta["id"]))
+        rescue ::Mongo::Error => e
+          RubyLLM.logger.warn "RubyLLM: GridFS delete failed for #{meta.inspect}: #{e.message}"
+        end
+      end
+
+      def download_gridfs_file(meta)
+        filename = meta["filename"].to_s
+        io       = fetch_gridfs_stream(meta["id"])
+        tmpfile  = stream_to_tempfile(io, filename)
+        (@_gridfs_tempfiles ||= []) << tmpfile
+        [tmpfile, filename]
+      rescue ::Mongo::Error => e
+        RubyLLM.logger.warn "RubyLLM: GridFS download failed for #{meta.inspect}: #{e.message}"
+        nil
+      end
+
+      def fetch_gridfs_stream(id)
+        io = StringIO.new("".b)
+        self.class.gridfs_bucket.download_to_stream(coerce_object_id(id), io)
+        io.tap(&:rewind)
+      end
+
+      def stream_to_tempfile(io, filename)
+        ext  = File.extname(filename)
+        base = File.basename(filename, ext)
+        Tempfile.new([base, ext], Dir.tmpdir, encoding: "BINARY").tap do |f|
+          f.write(io.read)
+          f.rewind
+        end
+      end
+
+      def coerce_object_id(id)
+        return id if id.is_a?(BSON::ObjectId)
+
+        BSON::ObjectId.from_string(id.to_s)
+      end
+    end
+  end
+end

data/lib/ruby_llm/mongoid/message_methods.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+require "ruby_llm/mongoid/payload_helpers"
+
+module RubyLLM
+  module Mongoid
+    # Mixes into a Mongoid document that represents a persisted chat message.
+    # Mirrors RubyLLM::ActiveRecord::MessageMethods but replaces AR-specific
+    # introspection with Mongoid equivalents.
+    module MessageMethods
+      extend ActiveSupport::Concern
+      include PayloadHelpers
+
+      def to_llm
+        RubyLLM::Message.new(
+          role: role.to_sym,
+          content: extract_content,
+          thinking: thinking,
+          tokens: tokens,
+          tool_calls: extract_tool_calls,
+          tool_call_id: extract_tool_call_id,
+          model_id: model_association&.model_id
+        )
+      end
+
+      def thinking
+        RubyLLM::Thinking.build(
+          text: field_value(:thinking_text),
+          signature: field_value(:thinking_signature)
+        )
+      end
+
+      def tokens
+        RubyLLM::Tokens.build(
+          input: field_value(:input_tokens),
+          output: field_value(:output_tokens),
+          cached: field_value(:cached_tokens),
+          cache_creation: field_value(:cache_creation_tokens),
+          thinking: field_value(:thinking_tokens)
+        )
+      end
+
+      def cost
+        RubyLLM::Cost.new(tokens: tokens, model: model_association)
+      end
+
+      def cache_read_tokens
+        field_value(:cached_tokens)
+      end
+
+      def cache_write_tokens
+        field_value(:cache_creation_tokens)
+      end
+
+      def to_partial_path
+        partial_prefix = self.class.name.underscore.pluralize
+        role_partial = if to_llm.tool_call?
+                         "tool_calls"
+                       elsif role.to_s == "tool"
+                         "tool"
+                       else
+                         role.to_s.presence || "assistant"
+                       end
+        "#{partial_prefix}/#{role_partial}"
+      end
+
+      def tool_error_message
+        payload_error_message(content)
+      end
+
+      private
+
+      # Safely reads a field only if it is declared on this document class.
+      def field_value(name)
+        self.class.fields.key?(name.to_s) ? self[name] : nil
+      end
+
+      def extract_tool_calls
+        tool_calls_association.to_h do |tc|
+          [
+            tc.tool_call_id,
+            RubyLLM::ToolCall.new(
+              id: tc.tool_call_id,
+              name: tc.name,
+              arguments: tc.arguments,
+              thought_signature: tc.try(:thought_signature)
+            )
+          ]
+        end
+      end
+
+      def extract_tool_call_id
+        parent_tool_call&.tool_call_id
+      end
+
+      def extract_content
+        return RubyLLM::Content::Raw.new(self[:content_raw]) if field_value(:content_raw).present?
+        return gridfs_content(content) if respond_to?(:gridfs_file_ids) && gridfs_file_ids.present?
+
+        content
+      end
+    end
+  end
+end

data/lib/ruby_llm/mongoid/model_methods.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+require "active_support/core_ext/module/delegation"
+
+module RubyLLM
+  module Mongoid
+    # Mixes into a Mongoid document that represents a persisted LLM model record.
+    # Mirrors RubyLLM::ActiveRecord::ModelMethods.
+    module ModelMethods
+      extend ActiveSupport::Concern
+
+      class_methods do # rubocop:disable Metrics/BlockLength
+        def refresh!
+          RubyLLM.models.refresh!
+          save_to_database
+        end
+
+        def save_to_database
+          RubyLLM.models.all.each do |model_info|
+            model = find_or_initialize_by(
+              model_id: model_info.id,
+              provider: model_info.provider
+            )
+            model.assign_attributes(from_llm_attributes(model_info))
+            model.save!
+          end
+        end
+
+        def from_llm(model_info)
+          new(from_llm_attributes(model_info))
+        end
+
+        private
+
+        def from_llm_attributes(model_info)
+          {
+            model_id: model_info.id,
+            name: model_info.name,
+            provider: model_info.provider,
+            family: model_info.family,
+            model_created_at: model_info.created_at,
+            context_window: model_info.context_window,
+            max_output_tokens: model_info.max_output_tokens,
+            knowledge_cutoff: model_info.knowledge_cutoff,
+            modalities: model_info.modalities.to_h,
+            capabilities: model_info.capabilities,
+            pricing: model_info.pricing.to_h,
+            metadata: model_info.metadata
+          }
+        end
+      end
+
+      def to_llm
+        RubyLLM::Model::Info.new(
+          id: model_id,
+          name: name,
+          provider: provider,
+          family: family,
+          created_at: model_created_at,
+          context_window: context_window,
+          max_output_tokens: max_output_tokens,
+          knowledge_cutoff: knowledge_cutoff,
+          modalities: modalities&.deep_symbolize_keys || {},
+          capabilities: capabilities,
+          pricing: pricing&.deep_symbolize_keys || {},
+          metadata: metadata&.deep_symbolize_keys || {}
+        )
+      end
+
+      delegate :supports?, :supports_vision?, :supports_functions?, :type,
+               :input_price_per_million, :output_price_per_million,
+               :cache_read_input_price_per_million, :cache_write_input_price_per_million,
+               :cached_input_price_per_million, :cache_creation_input_price_per_million,
+               :function_calling?, :structured_output?, :batch?,
+               :reasoning?, :citations?, :streaming?, :provider_class, :label,
+               :cost_for,
+               to: :to_llm
+    end
+  end
+end

data/lib/ruby_llm/mongoid/payload_helpers.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/blank"
+require "json"
+
+module RubyLLM
+  module Mongoid
+    module PayloadHelpers
+      private
+
+      def payload_error_message(value)
+        payload = parse_payload(value)
+        return unless payload.is_a?(Hash)
+
+        payload["error"] || payload[:error]
+      end
+
+      def parse_payload(value)
+        return value if value.is_a?(Hash) || value.is_a?(Array)
+        return if value.blank?
+
+        JSON.parse(value)
+      rescue JSON::ParserError
+        nil
+      end
+    end
+  end
+end

data/lib/ruby_llm/mongoid/railtie.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "rails/railtie"
+
+module RubyLLM
+  module Mongoid
+    class Railtie < Rails::Railtie
+      initializer "ruby_llm.mongoid.acts_as" do
+        ActiveSupport.on_load(:mongoid) do
+          ::Mongoid::Document::ClassMethods.include(RubyLLM::Mongoid::ActsAs::ClassMethods)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/mongoid/tool_call_methods.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+require "ruby_llm/mongoid/payload_helpers"
+
+module RubyLLM
+  module Mongoid
+    # Mixes into a Mongoid document that represents a persisted tool call.
+    # Mirrors RubyLLM::ActiveRecord::ToolCallMethods.
+    module ToolCallMethods
+      extend ActiveSupport::Concern
+      include PayloadHelpers
+
+      def tool_error_message
+        payload_error_message(arguments)
+      end
+    end
+  end
+end

data/lib/ruby_llm/mongoid/transaction.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Mongoid
+    # Wraps a block in a MongoDB multi-document transaction when a replica set is
+    # available. Falls back to a plain yield on standalone mongod so tests and
+    # single-node dev setups still work without errors.
+    module Transaction
+      def with_transaction(&)
+        _run_transaction(&)
+      rescue ::Mongoid::Errors::TransactionsNotSupported, ::Mongo::Error::TransactionsNotSupported
+        yield
+      rescue ::Mongo::Error::OperationFailure => e
+        raise unless standalone_mongod_error?(e)
+
+        yield
+      rescue NotImplementedError, NoMethodError # rubocop:disable Lint/DuplicateBranch
+        yield
+      end
+
+      private
+
+      def _run_transaction(&block)
+        if ::Mongoid.respond_to?(:with_session)
+          ::Mongoid.with_session do |session|
+            session.with_transaction(&block)
+          end
+        else
+          yield
+        end
+      end
+
+      def standalone_mongod_error?(error)
+        # Error code 20 is "IllegalOperation" which is returned when transactions
+        # are used on a standalone mongod.
+        return true if error.respond_to?(:code) && error.code == 20
+
+        msg = error.message
+        msg.include?("Transaction numbers are only allowed") ||
+          msg.include?("no such command: 'startTransaction'")
+      end
+    end
+  end
+end

data/lib/ruby_llm/mongoid/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Mongoid
+    VERSION = "0.1.0"
+  end
+end

data/lib/ruby_llm/mongoid.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "ruby_llm"
+require "mongoid"
+require "active_support"
+require_relative "mongoid/version"
+require_relative "mongoid/payload_helpers"
+require_relative "mongoid/transaction"
+require_relative "mongoid/grid_fs_attachment"
+require_relative "mongoid/model_methods"
+require_relative "mongoid/tool_call_methods"
+require_relative "mongoid/message_methods"
+require_relative "mongoid/chat_methods"
+require_relative "mongoid/acts_as"
+
+module RubyLLM
+  module Mongoid
+    class Error < StandardError; end
+  end
+end
+
+if defined?(Rails)
+  require_relative "mongoid/railtie"
+else
+  # In non-Rails environments (tests, scripts) auto-install the macros
+  # immediately after Mongoid is loaded.
+  RubyLLM::Mongoid::ActsAs.install!
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: ruby_llm-mongoid
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- washu
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '8.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '8.0'
+- !ruby/object:Gem::Dependency
+  name: ruby_llm
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.16'
+description: Drop-in Mongoid replacement for ruby_llm's ActiveRecord integration.
+  Provides acts_as_chat, acts_as_message, acts_as_tool_call, and acts_as_model macros
+  backed by MongoDB via Mongoid.
+email:
+- sal.scotto@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- ".ruby-version"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- build_release.sh
+- lib/generators/ruby_llm/mongoid/install/install_generator.rb
+- lib/generators/ruby_llm/mongoid/install/templates/chat_model.rb.tt
+- lib/generators/ruby_llm/mongoid/install/templates/initializer.rb.tt
+- lib/generators/ruby_llm/mongoid/install/templates/message_model.rb.tt
+- lib/generators/ruby_llm/mongoid/install/templates/model_model.rb.tt
+- lib/generators/ruby_llm/mongoid/install/templates/tool_call_model.rb.tt
+- lib/ruby_llm/mongoid.rb
+- lib/ruby_llm/mongoid/acts_as.rb
+- lib/ruby_llm/mongoid/chat_methods.rb
+- lib/ruby_llm/mongoid/grid_fs_attachment.rb
+- lib/ruby_llm/mongoid/message_methods.rb
+- lib/ruby_llm/mongoid/model_methods.rb
+- lib/ruby_llm/mongoid/payload_helpers.rb
+- lib/ruby_llm/mongoid/railtie.rb
+- lib/ruby_llm/mongoid/tool_call_methods.rb
+- lib/ruby_llm/mongoid/transaction.rb
+- lib/ruby_llm/mongoid/version.rb
+homepage: https://github.com/washu/ruby_llm-mongoid
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/washu/ruby_llm-mongoid
+  source_code_uri: https://github.com/washu/ruby_llm-mongoid
+  changelog_uri: https://github.com/washu/ruby_llm-mongoid/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Mongoid persistence for ruby_llm (acts_as_chat, acts_as_message, acts_as_tool_call,
+  acts_as_model)
+test_files: []