ruby_llm_community 0.0.1 → 0.0.2

data/lib/ruby_llm/active_record/acts_as.rb

@@ -0,0 +1,382 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module ActiveRecord
+    # Adds chat and message persistence capabilities to ActiveRecord models.
+    # Provides a clean interface for storing chat history, message metadata,
+    # and attachments in your database.
+    module ActsAs
+      extend ActiveSupport::Concern
+
+      class_methods do # rubocop:disable Metrics/BlockLength
+        def acts_as_chat(message_class: 'Message', tool_call_class: 'ToolCall')
+          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,
+                   inverse_of: :chat,
+                   dependent: :destroy
+
+          delegate :add_message, to: :to_llm
+        end
+
+        def acts_as_message(chat_class: 'Chat',
+                            chat_foreign_key: nil,
+                            tool_call_class: 'ToolCall',
+                            tool_call_foreign_key: nil,
+                            touch_chat: false)
+          include MessageMethods
+
+          @chat_class = chat_class.to_s
+          @chat_foreign_key = chat_foreign_key || ActiveSupport::Inflector.foreign_key(@chat_class)
+
+          @tool_call_class = tool_call_class.to_s
+          @tool_call_foreign_key = tool_call_foreign_key || ActiveSupport::Inflector.foreign_key(@tool_call_class)
+
+          belongs_to :chat,
+                     class_name: @chat_class,
+                     foreign_key: @chat_foreign_key,
+                     inverse_of: :messages,
+                     touch: touch_chat
+
+          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_foreign_key,
+                     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_foreign_key: nil, result_foreign_key: nil)
+          @message_class = message_class.to_s
+          @message_foreign_key = message_foreign_key || ActiveSupport::Inflector.foreign_key(@message_class)
+          @result_foreign_key = result_foreign_key || ActiveSupport::Inflector.foreign_key(name)
+
+          belongs_to :message,
+                     class_name: @message_class,
+                     foreign_key: @message_foreign_key,
+                     inverse_of: :tool_calls
+
+          has_one :result,
+                  class_name: @message_class,
+                  foreign_key: @result_foreign_key,
+                  inverse_of: :parent_tool_call,
+                  dependent: :nullify
+        end
+      end
+    end
+
+    # Methods mixed into chat models to handle message persistence and
+    # provide a conversation interface.
+    module ChatMethods
+      extend ActiveSupport::Concern
+
+      class_methods do
+        attr_reader :tool_call_class
+      end
+
+      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|
+          @chat.add_message(msg.to_llm)
+        end
+
+        setup_persistence_callbacks
+      end
+
+      def with_instructions(instructions, replace: false)
+        transaction do
+          messages.where(role: :system).destroy_all if replace
+          messages.create!(role: :system, content: instructions)
+        end
+        to_llm.with_instructions(instructions)
+        self
+      end
+
+      def with_tool(...)
+        to_llm.with_tool(...)
+        self
+      end
+
+      def with_tools(...)
+        to_llm.with_tools(...)
+        self
+      end
+
+      def with_model(...)
+        update(model_id: to_llm.with_model(...).model.id)
+        self
+      end
+
+      def with_temperature(...)
+        to_llm.with_temperature(...)
+        self
+      end
+
+      def with_context(context)
+        to_llm(context: context)
+        self
+      end
+
+      def with_params(...)
+        to_llm.with_params(...)
+        self
+      end
+
+      def with_headers(...)
+        to_llm.with_headers(...)
+        self
+      end
+
+      def with_schema(...)
+        to_llm.with_schema(...)
+        self
+      end
+
+      def on_new_message(&block)
+        to_llm
+
+        existing_callback = @chat.instance_variable_get(:@on)[:new_message]
+
+        @chat.on_new_message do
+          existing_callback&.call
+          block&.call
+        end
+        self
+      end
+
+      def on_end_message(&block)
+        to_llm
+
+        existing_callback = @chat.instance_variable_get(:@on)[:end_message]
+
+        @chat.on_end_message do |msg|
+          existing_callback&.call(msg)
+          block&.call(msg)
+        end
+        self
+      end
+
+      def on_tool_call(...)
+        to_llm.on_tool_call(...)
+        self
+      end
+
+      def on_tool_result(...)
+        to_llm.on_tool_result(...)
+        self
+      end
+
+      def create_user_message(content, with: nil)
+        message_record = messages.create!(role: :user, content: content)
+        persist_content(message_record, with) if with.present?
+        message_record
+      end
+
+      def ask(message, with: nil, &)
+        create_user_message(message, with:)
+        complete(&)
+      end
+
+      alias say ask
+
+      def complete(...)
+        to_llm.complete(...)
+      rescue RubyLLM::Error => e
+        cleanup_failed_messages if @message&.persisted? && @message.content.blank?
+        cleanup_orphaned_tool_results
+        raise e
+      end
+
+      private
+
+      def cleanup_failed_messages
+        RubyLLM.logger.debug "RubyLLM: API call failed, destroying message: #{@message.id}"
+        @message.destroy
+      end
+
+      def cleanup_orphaned_tool_results
+        loop do
+          messages.reload
+          last = messages.order(:id).last
+
+          break unless last&.tool_call? || last&.tool_result?
+
+          last.destroy
+        end
+      end
+
+      def setup_persistence_callbacks
+        # Only set up once per chat instance
+        return @chat if @chat.instance_variable_get(:@_persistence_callbacks_setup)
+
+        # Set up persistence callbacks (user callbacks will be chained via on_new_message/on_end_message methods)
+        @chat.on_new_message { persist_new_message }
+        @chat.on_end_message { |msg| persist_message_completion(msg) }
+
+        @chat.instance_variable_set(:@_persistence_callbacks_setup, true)
+        @chat
+      end
+
+      def persist_new_message
+        @message = messages.create!(role: :assistant, content: '')
+      end
+
+      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
+          # 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: content,
+            model_id: message.model_id,
+            input_tokens: message.input_tokens,
+            output_tokens: message.output_tokens
+          )
+          @message.write_attribute(@message.class.tool_call_foreign_key, tool_call_id) if tool_call_id
+          @message.save!
+          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)
+          @message.tool_calls.create!(**attributes)
+        end
+      end
+
+      def find_tool_call_id(tool_call_id)
+        self.class.tool_call_class.constantize.find_by(tool_call_id: tool_call_id)&.id
+      end
+
+      def persist_content(message_record, attachments)
+        return unless message_record.respond_to?(:attachments)
+
+        attachables = prepare_for_active_storage(attachments)
+        message_record.attachments.attach(attachables) if attachables.any?
+      end
+
+      def prepare_for_active_storage(attachments)
+        Utils.to_safe_array(attachments).filter_map do |attachment|
+          case attachment
+          when ActionDispatch::Http::UploadedFile, ActiveStorage::Blob
+            attachment
+          when ActiveStorage::Attached::One, ActiveStorage::Attached::Many
+            attachment.blobs
+          when Hash
+            attachment.values.map { |v| prepare_for_active_storage(v) }
+          else
+            convert_to_active_storage_format(attachment)
+          end
+        end.flatten.compact
+      end
+
+      def convert_to_active_storage_format(source)
+        return if source.blank?
+
+        # Let RubyLLM::Attachment handle the heavy lifting
+        attachment = RubyLLM::Attachment.new(source)
+
+        {
+          io: StringIO.new(attachment.content),
+          filename: attachment.filename,
+          content_type: attachment.mime_type
+        }
+      rescue StandardError => e
+        RubyLLM.logger.warn "Failed to process attachment #{source}: #{e.message}"
+        nil
+      end
+    end
+
+    # Methods mixed into message models to handle serialization and
+    # provide a clean interface to the underlying message data.
+    module MessageMethods
+      extend ActiveSupport::Concern
+
+      class_methods do
+        attr_reader :chat_class, :tool_call_class, :chat_foreign_key, :tool_call_foreign_key
+      end
+
+      def to_llm
+        RubyLLM::Message.new(
+          role: role.to_sym,
+          content: extract_content,
+          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
+
+      private
+
+      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
+
+      def extract_content
+        return content unless respond_to?(:attachments) && attachments.attached?
+
+        RubyLLM::Content.new(content).tap do |content_obj|
+          @_tempfiles = []
+
+          attachments.each do |attachment|
+            tempfile = download_attachment(attachment)
+            content_obj.add_attachment(tempfile, filename: attachment.filename.to_s)
+          end
+        end
+      end
+
+      def download_attachment(attachment)
+        ext = File.extname(attachment.filename.to_s)
+        basename = File.basename(attachment.filename.to_s, ext)
+        tempfile = Tempfile.new([basename, ext])
+        tempfile.binmode
+
+        attachment.download { |chunk| tempfile.write(chunk) }
+
+        tempfile.flush
+        tempfile.rewind
+        @_tempfiles << tempfile
+        tempfile
+      end
+    end
+  end
+end

data/lib/ruby_llm/aliases.json

@@ -0,0 +1,217 @@
+{
+  "chatgpt-4o": {
+    "openai": "chatgpt-4o-latest",
+    "openrouter": "openai/chatgpt-4o-latest"
+  },
+  "claude-3-5-haiku": {
+    "anthropic": "claude-3-5-haiku-20241022",
+    "openrouter": "anthropic/claude-3.5-haiku",
+    "bedrock": "anthropic.claude-3-5-haiku-20241022-v1:0"
+  },
+  "claude-3-5-sonnet": {
+    "anthropic": "claude-3-5-sonnet-20241022",
+    "openrouter": "anthropic/claude-3.5-sonnet",
+    "bedrock": "anthropic.claude-3-5-sonnet-20240620-v1:0:200k"
+  },
+  "claude-3-7-sonnet": {
+    "anthropic": "claude-3-7-sonnet-20250219",
+    "openrouter": "anthropic/claude-3.7-sonnet",
+    "bedrock": "us.anthropic.claude-3-7-sonnet-20250219-v1:0"
+  },
+  "claude-3-haiku": {
+    "anthropic": "claude-3-haiku-20240307",
+    "openrouter": "anthropic/claude-3-haiku",
+    "bedrock": "anthropic.claude-3-haiku-20240307-v1:0:200k"
+  },
+  "claude-3-opus": {
+    "anthropic": "claude-3-opus-20240229",
+    "openrouter": "anthropic/claude-3-opus",
+    "bedrock": "anthropic.claude-3-opus-20240229-v1:0:200k"
+  },
+  "claude-3-sonnet": {
+    "bedrock": "anthropic.claude-3-sonnet-20240229-v1:0"
+  },
+  "claude-opus-4": {
+    "anthropic": "claude-opus-4-20250514",
+    "openrouter": "anthropic/claude-opus-4",
+    "bedrock": "us.anthropic.claude-opus-4-1-20250805-v1:0"
+  },
+  "claude-opus-4-1": {
+    "anthropic": "claude-opus-4-1-20250805",
+    "openrouter": "anthropic/claude-opus-4.1",
+    "bedrock": "us.anthropic.claude-opus-4-1-20250805-v1:0"
+  },
+  "claude-sonnet-4": {
+    "anthropic": "claude-sonnet-4-20250514",
+    "openrouter": "anthropic/claude-sonnet-4",
+    "bedrock": "us.anthropic.claude-sonnet-4-20250514-v1:0"
+  },
+  "deepseek-chat": {
+    "deepseek": "deepseek-chat",
+    "openrouter": "deepseek/deepseek-chat"
+  },
+  "gemini-2.0-flash-001": {
+    "gemini": "gemini-2.0-flash-001",
+    "openrouter": "google/gemini-2.0-flash-001"
+  },
+  "gemini-2.0-flash-lite-001": {
+    "gemini": "gemini-2.0-flash-lite-001",
+    "openrouter": "google/gemini-2.0-flash-lite-001"
+  },
+  "gemini-2.5-flash": {
+    "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"
+  },
+  "gemini-2.5-pro": {
+    "gemini": "gemini-2.5-pro",
+    "openrouter": "google/gemini-2.5-pro"
+  },
+  "gemini-2.5-pro-preview-05-06": {
+    "gemini": "gemini-2.5-pro-preview-05-06",
+    "openrouter": "google/gemini-2.5-pro-preview-05-06"
+  },
+  "gemma-3-12b-it": {
+    "gemini": "gemma-3-12b-it",
+    "openrouter": "google/gemma-3-12b-it"
+  },
+  "gemma-3-27b-it": {
+    "gemini": "gemma-3-27b-it",
+    "openrouter": "google/gemma-3-27b-it"
+  },
+  "gemma-3-4b-it": {
+    "gemini": "gemma-3-4b-it",
+    "openrouter": "google/gemma-3-4b-it"
+  },
+  "gemma-3n-e4b-it": {
+    "gemini": "gemma-3n-e4b-it",
+    "openrouter": "google/gemma-3n-e4b-it"
+  },
+  "gpt-3.5-turbo": {
+    "openai": "gpt-3.5-turbo",
+    "openrouter": "openai/gpt-3.5-turbo"
+  },
+  "gpt-3.5-turbo-16k": {
+    "openai": "gpt-3.5-turbo-16k",
+    "openrouter": "openai/gpt-3.5-turbo-16k"
+  },
+  "gpt-3.5-turbo-instruct": {
+    "openai": "gpt-3.5-turbo-instruct",
+    "openrouter": "openai/gpt-3.5-turbo-instruct"
+  },
+  "gpt-4": {
+    "openai": "gpt-4",
+    "openrouter": "openai/gpt-4"
+  },
+  "gpt-4-1106-preview": {
+    "openai": "gpt-4-1106-preview",
+    "openrouter": "openai/gpt-4-1106-preview"
+  },
+  "gpt-4-turbo": {
+    "openai": "gpt-4-turbo",
+    "openrouter": "openai/gpt-4-turbo"
+  },
+  "gpt-4-turbo-preview": {
+    "openai": "gpt-4-turbo-preview",
+    "openrouter": "openai/gpt-4-turbo-preview"
+  },
+  "gpt-4.1": {
+    "openai": "gpt-4.1",
+    "openrouter": "openai/gpt-4.1"
+  },
+  "gpt-4.1-mini": {
+    "openai": "gpt-4.1-mini",
+    "openrouter": "openai/gpt-4.1-mini"
+  },
+  "gpt-4.1-nano": {
+    "openai": "gpt-4.1-nano",
+    "openrouter": "openai/gpt-4.1-nano"
+  },
+  "gpt-4o": {
+    "openai": "gpt-4o",
+    "openrouter": "openai/gpt-4o"
+  },
+  "gpt-4o-2024-05-13": {
+    "openai": "gpt-4o-2024-05-13",
+    "openrouter": "openai/gpt-4o-2024-05-13"
+  },
+  "gpt-4o-2024-08-06": {
+    "openai": "gpt-4o-2024-08-06",
+    "openrouter": "openai/gpt-4o-2024-08-06"
+  },
+  "gpt-4o-2024-11-20": {
+    "openai": "gpt-4o-2024-11-20",
+    "openrouter": "openai/gpt-4o-2024-11-20"
+  },
+  "gpt-4o-mini": {
+    "openai": "gpt-4o-mini",
+    "openrouter": "openai/gpt-4o-mini"
+  },
+  "gpt-4o-mini-2024-07-18": {
+    "openai": "gpt-4o-mini-2024-07-18",
+    "openrouter": "openai/gpt-4o-mini-2024-07-18"
+  },
+  "gpt-4o-mini-search-preview": {
+    "openai": "gpt-4o-mini-search-preview",
+    "openrouter": "openai/gpt-4o-mini-search-preview"
+  },
+  "gpt-4o-search-preview": {
+    "openai": "gpt-4o-search-preview",
+    "openrouter": "openai/gpt-4o-search-preview"
+  },
+  "gpt-5": {
+    "openai": "gpt-5",
+    "openrouter": "openai/gpt-5"
+  },
+  "gpt-5-mini": {
+    "openai": "gpt-5-mini",
+    "openrouter": "openai/gpt-5-mini"
+  },
+  "gpt-5-nano": {
+    "openai": "gpt-5-nano",
+    "openrouter": "openai/gpt-5-nano"
+  },
+  "gpt-oss-120b": {
+    "openai": "gpt-oss-120b",
+    "openrouter": "openai/gpt-oss-120b"
+  },
+  "o1": {
+    "openai": "o1",
+    "openrouter": "openai/o1"
+  },
+  "o1-mini": {
+    "openai": "o1-mini",
+    "openrouter": "openai/o1-mini"
+  },
+  "o1-mini-2024-09-12": {
+    "openai": "o1-mini-2024-09-12",
+    "openrouter": "openai/o1-mini-2024-09-12"
+  },
+  "o1-pro": {
+    "openai": "o1-pro",
+    "openrouter": "openai/o1-pro"
+  },
+  "o3": {
+    "openai": "o3",
+    "openrouter": "openai/o3"
+  },
+  "o3-mini": {
+    "openai": "o3-mini",
+    "openrouter": "openai/o3-mini"
+  },
+  "o3-pro": {
+    "openai": "o3-pro",
+    "openrouter": "openai/o3-pro"
+  },
+  "o4-mini": {
+    "openai": "o4-mini",
+    "openrouter": "openai/o4-mini"
+  }
+}

data/lib/ruby_llm/aliases.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  # Manages model aliases, allowing users to reference models by simpler names
+  # that map to specific model versions across different providers.
+  #
+  # Aliases are defined in aliases.json and follow the format:
+  #   {
+  #     "simple-name": {
+  #       "provider1": "specific-version-for-provider1",
+  #       "provider2": "specific-version-for-provider2"
+  #     }
+  #   }
+  class Aliases
+    class << self
+      # Resolves a model ID to its provider-specific version
+      #
+      # @param model_id [String] the model identifier or alias
+      # @param provider_slug [String, Symbol, nil] optional provider to resolve for
+      # @return [String] the resolved model ID or the original if no alias exists
+      def resolve(model_id, provider = nil)
+        return model_id unless aliases[model_id]
+
+        if provider
+          aliases[model_id][provider.to_s] || model_id
+        else
+          # Get native provider's version
+          aliases[model_id].values.first || model_id
+        end
+      end
+
+      # Returns the loaded aliases mapping
+      # @return [Hash] the aliases mapping
+      def aliases
+        @aliases ||= load_aliases
+      end
+
+      # Loads aliases from the JSON file
+      # @return [Hash] the loaded aliases
+      def load_aliases
+        file_path = File.expand_path('aliases.json', __dir__)
+        if File.exist?(file_path)
+          JSON.parse(File.read(file_path))
+        else
+          {}
+        end
+      end
+
+      # Reloads aliases from disk
+      # @return [Hash] the reloaded aliases
+      def reload!
+        @aliases = load_aliases
+      end
+    end
+  end
+end