ruby_llm 0.1.0.pre4 → 0.1.0.pre6

metadata

@@ -1,14 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: ruby_llm
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre4
+  version: 0.1.0.pre6
 platform: ruby
 authors:
 - Carmine Paolino
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-01-30 00:00:00.000000000 Z
+date: 2025-02-01 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: event_stream_parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 2.0.0
 - !ruby/object:Gem::Dependency
   name: faraday
   requirement: !ruby/object:Gem::Requirement
@@ -301,9 +322,10 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0.9'
-description: Complete Ruby library for working with Large Language Models (LLMs).
-  Supports OpenAI, Anthropic, and others with a consistent interface. Features include
-  tool usage, token tracking, and seamless Rails integration.
+description: A delightful Ruby way to work with AI language models. Provides a unified
+  interface to OpenAI and Anthropic models with automatic token counting, proper streaming
+  support, and a focus on developer happiness. No wrapping your head around multiple
+  APIs - just clean Ruby code that works.
 email:
 - carmine@paolino.me
 executables: []
@@ -322,21 +344,22 @@ files:
 - bin/console
 - bin/setup
 - lib/ruby_llm.rb
-- lib/ruby_llm/active_record/acts_as.rb
-- lib/ruby_llm/client.rb
+- lib/ruby_llm/chat.rb
+- lib/ruby_llm/chunk.rb
 - lib/ruby_llm/configuration.rb
-- lib/ruby_llm/conversation.rb
 - lib/ruby_llm/message.rb
 - lib/ruby_llm/model_capabilities/anthropic.rb
-- lib/ruby_llm/model_capabilities/base.rb
 - lib/ruby_llm/model_capabilities/openai.rb
 - lib/ruby_llm/model_info.rb
+- lib/ruby_llm/models.json
+- lib/ruby_llm/models.rb
+- lib/ruby_llm/provider.rb
 - lib/ruby_llm/providers/anthropic.rb
-- lib/ruby_llm/providers/base.rb
 - lib/ruby_llm/providers/openai.rb
 - lib/ruby_llm/railtie.rb
 - lib/ruby_llm/tool.rb
 - lib/ruby_llm/version.rb
+- lib/tasks/models.rake
 - ruby_llm.gemspec
 homepage: https://github.com/crmne/ruby_llm
 licenses:
@@ -344,9 +367,10 @@ licenses:
 metadata:
   homepage_uri: https://github.com/crmne/ruby_llm
   source_code_uri: https://github.com/crmne/ruby_llm
-  changelog_uri: https://github.com/crmne/ruby_llm/blob/main/CHANGELOG.md
-  documentation_uri: https://rubydoc.info/gems/ruby_llm
+  changelog_uri: https://github.com/crmne/ruby_llm/commits/main
+  documentation_uri: https://github.com/crmne/ruby_llm
   bug_tracker_uri: https://github.com/crmne/ruby_llm/issues
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -361,8 +385,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
-summary: The Ruby LLM client library - unified interface for OpenAI, Anthropic, and
-  other LLM providers
+summary: Clean Ruby interface to modern AI language models
 test_files: []

data/lib/ruby_llm/active_record/acts_as.rb

@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module ActiveRecord
-    # Provides ActsAs functionality for LLM-related models
-    module ActsAs
-      def acts_as_llm_model(_options = {})
-        include ModelMethods
-      end
-
-      def acts_as_llm_conversation(_options = {})
-        include ConversationMethods
-        has_many :messages, -> { order(created_at: :asc) }
-      end
-
-      def acts_as_llm_message(_options = {})
-        include MessageMethods
-        belongs_to :conversation
-      end
-    end
-
-    # Methods for LLM model functionality
-    module ModelMethods
-      extend ActiveSupport::Concern
-
-      included do
-        validates :name, presence: true
-        validates :provider, presence: true
-      end
-
-      class_methods do
-        def sync_models
-          # Logic to sync models from providers
-        end
-      end
-    end
-
-    # Methods for LLM conversation handling
-    module ConversationMethods
-      extend ActiveSupport::Concern
-
-      included do
-        before_create :set_default_model
-      end
-
-      def send_message(content, model: nil)
-        transaction do
-          create_user_message(content)
-          create_assistant_response(model)
-        end
-      end
-
-      private
-
-      def create_user_message(content)
-        messages.create!(
-          role: :user,
-          content: content
-        )
-      end
-
-      def create_assistant_response(model)
-        response = RubyLLM.client.chat(
-          conversation_messages,
-          model: model || current_model
-        )
-
-        messages.create!(
-          role: :assistant,
-          content: response.content,
-          token_count: response.token_count
-        )
-      end
-
-      def conversation_messages
-        messages.map(&:to_llm_format)
-      end
-
-      def set_default_model
-        self.current_model ||= RubyLLM.configuration.default_model
-      end
-    end
-
-    # Methods for LLM message handling
-    module MessageMethods
-      extend ActiveSupport::Concern
-
-      included do
-        validates :role, presence: true, inclusion: { in: RubyLLM::Message::VALID_ROLES.map(&:to_s) }
-        validates :content, presence: true, unless: :tool_call?
-
-        before_save :calculate_tokens
-      end
-
-      def to_llm_format
-        RubyLLM::Message.new(
-          role: role.to_sym,
-          content: content,
-          tool_calls: tool_calls,
-          tool_results: tool_results
-        )
-      end
-
-      private
-
-      def calculate_tokens
-        # Logic to calculate tokens
-      end
-
-      def tool_call?
-        tool_calls.present? || tool_results.present?
-      end
-    end
-  end
-end

data/lib/ruby_llm/client.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  # Client class for handling LLM provider interactions
-  class Client
-    def initialize
-      @providers = {}
-    end
-
-    def chat(messages, model: nil, temperature: 0.7, stream: false, tools: nil, &block)
-      # Convert any hash messages to Message objects
-      formatted_messages = messages.map do |msg|
-        msg.is_a?(Message) ? msg : Message.new(**msg)
-      end
-
-      provider = provider_for(model)
-      response_messages = provider.chat(
-        formatted_messages,
-        model: model,
-        temperature: temperature,
-        stream: stream,
-        tools: tools,
-        &block
-      )
-
-      # Always return an array of messages, even for single responses
-      response_messages.is_a?(Array) ? response_messages : [response_messages]
-    end
-
-    def list_models(provider = nil)
-      if provider
-        provider_for(nil, provider).list_models
-      else
-        all_providers.flat_map(&:list_models)
-      end
-    end
-
-    private
-
-    def all_providers
-      [
-        provider_for(nil, :openai),
-        provider_for(nil, :anthropic)
-      ]
-    end
-
-    def provider_for(model, specific_provider = nil)
-      provider_name = specific_provider || detect_provider(model)
-      @providers[provider_name] ||= case provider_name
-                                    when :openai then Providers::OpenAI.new
-                                    when :anthropic then Providers::Anthropic.new
-                                    else
-                                      raise Error, "Unsupported provider: #{provider_name}"
-                                    end
-    end
-
-    def detect_provider(model)
-      return RubyLLM.configuration.default_provider unless model
-
-      case model
-      when /^gpt-/, /^text-davinci/
-        :openai
-      when /^claude/
-        :anthropic
-      else
-        RubyLLM.configuration.default_provider
-      end
-    end
-  end
-end

data/lib/ruby_llm/conversation.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  # Represents a conversation with an LLM
-  class Conversation
-    attr_reader :id, :messages, :tools
-
-    def initialize(tools: [])
-      @id = SecureRandom.uuid
-      @messages = []
-      @tools = tools
-    end
-
-    def add_message(message)
-      @messages << message
-      message
-    end
-  end
-end

data/lib/ruby_llm/model_capabilities/base.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module ModelCapabilities
-    class Base
-      def determine_context_window(_model_id)
-        raise NotImplementedError
-      end
-
-      def determine_max_tokens(_model_id)
-        raise NotImplementedError
-      end
-
-      def get_input_price(_model_id)
-        raise NotImplementedError
-      end
-
-      def get_output_price(_model_id)
-        raise NotImplementedError
-      end
-
-      def supports_vision?(_model_id)
-        raise NotImplementedError
-      end
-
-      def supports_functions?(_model_id)
-        raise NotImplementedError
-      end
-
-      def supports_json_mode?(_model_id)
-        raise NotImplementedError
-      end
-    end
-  end
-end

data/lib/ruby_llm/providers/base.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module Providers
-    # Base provider class for LLM interactions
-    class Base
-      attr_reader :connection
-
-      def initialize
-        @connection = build_connection
-      end
-
-      def chat(messages, **options, &block)
-        raise NotImplementedError
-      end
-
-      protected
-
-      def check_for_api_error(response)
-        return unless response.body.is_a?(Hash) && response.body['type'] == 'error'
-
-        error_msg = response.body.dig('error', 'message') || 'Unknown API error'
-        raise RubyLLM::Error, "API error: #{error_msg}"
-      end
-
-      def build_connection
-        Faraday.new(url: api_base) do |f|
-          f.options.timeout = RubyLLM.configuration.request_timeout
-          f.request :json
-          f.response :json
-          f.adapter Faraday.default_adapter
-        end
-      end
-
-      def handle_error(error)
-        case error
-        when Faraday::TimeoutError
-          raise RubyLLM::Error, 'Request timed out'
-        when Faraday::ConnectionFailed
-          raise RubyLLM::Error, 'Connection failed'
-        when Faraday::ClientError
-          handle_api_error(error)
-        else
-          raise error
-        end
-      end
-
-      def handle_api_error(error)
-        raise RubyLLM::Error, "API error: #{error.response[:status]}"
-      end
-
-      def parse_error_message(response)
-        return "HTTP #{response.status}" unless response.body
-
-        if response.body.is_a?(String)
-          begin
-            JSON.parse(response.body).dig('error', 'message')
-          rescue StandardError
-            "HTTP #{response.status}"
-          end
-        else
-          response.body.dig('error', 'message') || "HTTP #{response.status}"
-        end
-      end
-    end
-  end
-end