ruby_llm 0.1.0.pre3 → 0.1.0.pre5

data/lib/ruby_llm/providers/openai.rb

@@ -2,187 +2,170 @@
 
 module RubyLLM
   module Providers
-    class OpenAI < Base
-      def chat(messages, model: nil, temperature: 0.7, stream: false, tools: nil, &block)
-        payload = {
-          model: model || RubyLLM.configuration.default_model,
-          messages: messages.map(&:to_h),
-          temperature: temperature,
-          stream: stream
+    class OpenAI
+      include Provider
+
+      private
+
+      def api_base
+        'https://api.openai.com'
+      end
+
+      def headers
+        {
+          'Authorization' => "Bearer #{RubyLLM.config.openai_api_key}"
         }
+      end
 
-        if tools&.any?
-          payload[:functions] = tools.map { |tool| tool_to_function(tool) }
-          payload[:function_call] = 'auto'
-        end
+      def completion_url
+        '/v1/chat/completions'
+      end
 
-        puts 'Sending payload to OpenAI:' if ENV['RUBY_LLM_DEBUG']
-        puts JSON.pretty_generate(payload) if ENV['RUBY_LLM_DEBUG']
+      def models_url
+        '/v1/models'
+      end
 
-        if stream && block_given?
-          stream_chat_completion(payload, tools, &block)
-        else
-          create_chat_completion(payload, tools)
+      def build_payload(messages, tools, model:, temperature: 0.7, stream: false)
+        {
+          model: model,
+          messages: format_messages(messages),
+          temperature: temperature,
+          stream: stream
+        }.tap do |payload|
+          if tools.any?
+            payload[:tools] = tools.map { |t| tool_for(t) }
+            payload[:tool_choice] = 'auto'
+          end
         end
-      rescue Faraday::TimeoutError
-        raise RubyLLM::Error, 'Request timed out'
-      rescue Faraday::ConnectionFailed
-        raise RubyLLM::Error, 'Connection failed'
-      rescue Faraday::ClientError => e
-        raise RubyLLM::Error, 'Client error' unless e.response
-
-        error_msg = e.response[:body]['error']&.fetch('message', nil) || "HTTP #{e.response[:status]}"
-        raise RubyLLM::Error, "API error: #{error_msg}"
       end
 
-      def list_models
-        response = @connection.get('/v1/models') do |req|
-          req.headers['Authorization'] = "Bearer #{RubyLLM.configuration.openai_api_key}"
+      def format_messages(messages)
+        messages.map do |msg|
+          {
+            role: msg.role.to_s,
+            content: msg.content,
+            tool_calls: format_tool_calls(msg.tool_calls)
+          }.compact
         end
+      end
 
-        raise RubyLLM::Error, "API error: #{parse_error_message(response)}" if response.status >= 400
-
-        capabilities = RubyLLM::ModelCapabilities::OpenAI.new
-        (response.body['data'] || []).map do |model|
-          ModelInfo.new(
-            id: model['id'],
-            created_at: Time.at(model['created']),
-            display_name: capabilities.format_display_name(model['id']),
-            provider: 'openai',
-            metadata: {
-              object: model['object'],
-              owned_by: model['owned_by']
-            },
-            context_window: capabilities.determine_context_window(model['id']),
-            max_tokens: capabilities.determine_max_tokens(model['id']),
-            supports_vision: capabilities.supports_vision?(model['id']),
-            supports_functions: capabilities.supports_functions?(model['id']),
-            supports_json_mode: capabilities.supports_json_mode?(model['id']),
-            input_price_per_million: capabilities.get_input_price(model['id']),
-            output_price_per_million: capabilities.get_output_price(model['id'])
-          )
+      def format_tool_calls(tool_calls)
+        return nil unless tool_calls
+
+        tool_calls.map do |tc|
+          {
+            id: tc[:id],
+            type: 'function',
+            function: {
+              name: tc[:name],
+              arguments: tc[:arguments]
+            }
+          }
         end
-      rescue Faraday::Error => e
-        handle_error(e)
       end
 
-      private
-
-      def tool_to_function(tool)
+      def tool_for(tool)
         {
-          name: tool.name,
-          description: tool.description,
-          parameters: {
-            type: 'object',
-            properties: tool.parameters.transform_values { |v| v.reject { |k, _| k == :required } },
-            required: tool.parameters.select { |_, v| v[:required] }.keys
+          type: 'function',
+          function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: {
+              type: 'object',
+              properties: tool.parameters.transform_values { |param| param_schema(param) },
+              required: tool.parameters.select { |_, p| p.required }.keys
+            }
           }
         }
       end
 
-      def create_chat_completion(payload, tools = nil)
-        response = connection.post('/v1/chat/completions') do |req|
-          req.headers['Authorization'] = "Bearer #{RubyLLM.configuration.openai_api_key}"
-          req.headers['Content-Type'] = 'application/json'
-          req.body = payload
-        end
-
-        puts 'Response from OpenAI:' if ENV['RUBY_LLM_DEBUG']
-        puts JSON.pretty_generate(response.body) if ENV['RUBY_LLM_DEBUG']
-
-        if response.status >= 400
-          error_msg = response.body['error']&.fetch('message', nil) || "HTTP #{response.status}"
-          raise RubyLLM::Error, "API error: #{error_msg}"
-        end
-
-        handle_response(response, tools, payload)
+      def param_schema(param)
+        {
+          type: param.type,
+          description: param.description
+        }.compact
       end
 
-      def handle_response(response, tools, payload)
+      def parse_completion_response(response)
         data = response.body
-        message_data = data.dig('choices', 0, 'message')
-        return Message.new(role: :assistant, content: '') unless message_data
+        return if data.empty?
 
-        if message_data['function_call'] && tools
-          result = handle_function_call(message_data['function_call'], tools)
-          puts "Function result: #{result}" if ENV['RUBY_LLM_DEBUG']
-
-          # Create a new chat completion with the function results
-          new_messages = payload[:messages] + [
-            { role: 'assistant', content: message_data['content'], function_call: message_data['function_call'] },
-            { role: 'function', name: message_data['function_call']['name'], content: result }
-          ]
-
-          return create_chat_completion(payload.merge(messages: new_messages), tools)
-        end
-
-        # Extract token usage from response
-        token_usage = if data['usage']
-                        {
-                          input_tokens: data['usage']['prompt_tokens'],
-                          output_tokens: data['usage']['completion_tokens'],
-                          total_tokens: data['usage']['total_tokens']
-                        }
-                      end
+        message_data = data.dig('choices', 0, 'message')
+        return unless message_data
 
         Message.new(
           role: :assistant,
           content: message_data['content'],
-          token_usage: token_usage,
+          tool_calls: parse_tool_calls(message_data['tool_calls']),
+          input_tokens: data['usage']['prompt_tokens'],
+          output_tokens: data['usage']['completion_tokens'],
           model_id: data['model']
         )
       end
 
-      def handle_function_call(function_call, tools)
-        return unless function_call && tools
+      def parse_tool_calls(tool_calls)
+        return nil unless tool_calls&.any?
 
-        tool = tools.find { |t| t.name == function_call['name'] }
-        return unless tool
-
-        begin
-          args = JSON.parse(function_call['arguments'])
-          tool.call(args)
-        rescue JSON::ParserError, ArgumentError => e
-          "Error executing function #{tool.name}: #{e.message}"
+        tool_calls.map do |tc|
+          {
+            id: tc['id'],
+            name: tc.dig('function', 'name'),
+            arguments: tc.dig('function', 'arguments')
+          }
         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
-          raise RubyLLM::Error, 'Client error' unless error.response
-
-          error_msg = error.response[:body]['error']&.fetch('message', nil) || "HTTP #{error.response[:status]}"
-          raise RubyLLM::Error, "API error: #{error_msg}"
+      def parse_models_response(response)
+        (response.body['data'] || []).map do |model|
+          model_info = begin
+            Models.find(model['id'])
+          rescue StandardError
+            nil
+          end
+          next unless model_info
 
-        else
-          raise error
-        end
+          model_info.tap do |info|
+            info.metadata.merge!(
+              object: model['object'],
+              owned_by: model['owned_by']
+            )
+          end
+        end.compact
       end
 
-      def handle_api_error(error)
-        response_body = error.response[:body]
-        if response_body.is_a?(String)
-          begin
-            error_data = JSON.parse(response_body)
-            message = error_data.dig('error', 'message')
-            raise RubyLLM::Error, "API error: #{message}" if message
-          rescue JSON::ParserError
-            raise RubyLLM::Error, "API error: #{error.response[:status]}"
-          end
-        elsif response_body['error']
-          raise RubyLLM::Error, "API error: #{response_body['error']['message']}"
-        else
-          raise RubyLLM::Error, "API error: #{error.response[:status]}"
+      def handle_stream(&block)
+        to_json_stream do |data|
+          block.call(
+            Chunk.new(
+              role: :assistant,
+              model_id: data['model'],
+              content: data.dig('choices', 0, 'delta', 'content')
+            )
+          )
         end
       end
 
-      def api_base
-        'https://api.openai.com'
+      def parse_list_models_response(response)
+        capabilities = ModelCapabilities::OpenAI
+        (response.body['data'] || []).map do |model|
+          ModelInfo.new(
+            id: model['id'],
+            created_at: Time.at(model['created']),
+            display_name: capabilities.format_display_name(model['id']),
+            provider: 'openai',
+            metadata: {
+              object: model['object'],
+              owned_by: model['owned_by']
+            },
+            context_window: capabilities.context_window_for(model['id']),
+            max_tokens: capabilities.max_tokens_for(model['id']),
+            supports_vision: capabilities.supports_vision?(model['id']),
+            supports_functions: capabilities.supports_functions?(model['id']),
+            supports_json_mode: capabilities.supports_json_mode?(model['id']),
+            input_price_per_million: capabilities.input_price_for(model['id']),
+            output_price_per_million: capabilities.output_price_for(model['id'])
+          )
+        end
       end
     end
   end

data/lib/ruby_llm/tool.rb

@@ -1,75 +1,96 @@
 # frozen_string_literal: true
 
 module RubyLLM
-  # Represents a tool/function that can be called by an LLM
   class Tool
-    attr_reader :name, :description, :parameters, :handler
+    class Parameter
+      attr_reader :name, :type, :description, :required
+
+      def initialize(name, type: 'string', description: nil, required: true)
+        @name = name
+        @type = type
+        @description = description
+        @required = required
+      end
 
-    def self.from_method(method_object, description: nil, parameter_descriptions: {})
-      method_params = {}
-      method_object.parameters.each do |param_type, param_name|
-        next unless %i[req opt key keyreq].include?(param_type)
+      def to_h
+        {
+          type: type,
+          description: description,
+          required: required
+        }.compact
+      end
+    end
 
-        method_params[param_name] = {
-          type: 'string',
-          description: parameter_descriptions[param_name] || param_name.to_s.tr('_', ' '),
-          required: %i[req keyreq].include?(param_type)
-        }
+    class Builder
+      def initialize(tool)
+        @tool = tool
       end
 
-      new(
-        name: method_object.name.to_s,
-        description: description || "Executes the #{method_object.name} operation",
-        parameters: method_params
-      ) do |args|
-        # Create an instance if it's an instance method
-        instance = if method_object.owner.instance_methods.include?(method_object.name)
-                     method_object.owner.new
-                   else
-                     method_object.owner
-                   end
-
-        # Call the method with the arguments
-        if args.is_a?(Hash)
-          instance.method(method_object.name).call(**args)
-        else
-          instance.method(method_object.name).call(args)
-        end
+      def description(text)
+        @tool.instance_variable_set(:@description, text)
+        self
+      end
+
+      def param(name, type: 'string', description: nil, required: true)
+        @tool.parameters[name] = Parameter.new(name, type: type, description: description, required: required)
+        self
+      end
+
+      def handler(&block)
+        @tool.instance_variable_set(:@handler, block)
+        @tool
       end
     end
 
-    def initialize(name:, description:, parameters: {}, &block)
-      @name = name
-      @description = description
-      @parameters = parameters
-      @handler = block
+    attr_reader :name, :description, :parameters, :handler
 
-      validate!
+    def self.define(name, &block)
+      tool = new(name)
+      builder = Builder.new(tool)
+      builder.instance_eval(&block)
+      tool
     end
 
-    def call(args)
-      validated_args = validate_args!(args)
-      handler.call(validated_args)
+    def initialize(name)
+      @name = name
+      @parameters = {}
     end
 
-    private
+    def call(args)
+      raise Error, "No handler defined for tool #{name}" unless @handler
 
-    def validate!
-      raise ArgumentError, 'Name must be a string' unless name.is_a?(String)
-      raise ArgumentError, 'Description must be a string' unless description.is_a?(String)
-      raise ArgumentError, 'Parameters must be a hash' unless parameters.is_a?(Hash)
-      raise ArgumentError, 'Block must be provided' unless handler.respond_to?(:call)
+      begin
+        args = symbolize_keys(args)
+        @handler.call(args)
+      rescue StandardError => e
+        { error: e.message }
+      end
     end
 
-    def validate_args!(args)
-      args = args.transform_keys(&:to_sym)
-      required_params = parameters.select { |_, v| v[:required] }.keys
+    class << self
+      def from_method(method, description: nil)
+        define(method.name.to_s) do
+          description description if description
+
+          method.parameters.each do |type, name|
+            param name, required: (type == :req)
+          end
 
-      required_params.each do |param|
-        raise ArgumentError, "Missing required parameter: #{param}" unless args.key?(param.to_sym)
+          handler do |args|
+            method.owner.new.public_send(method.name, **args)
+          end
+        end
       end
+    end
 
-      args
+    private
+
+    def symbolize_keys(hash)
+      hash.transform_keys do |key|
+        key.to_sym
+      rescue StandardError
+        key
+      end
     end
   end
 end

data/lib/ruby_llm/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RubyLLM
-  VERSION = '0.1.0.pre3'
+  VERSION = '0.1.0.pre5'
 end

data/lib/ruby_llm.rb

@@ -3,66 +3,64 @@
 require 'zeitwerk'
 require 'faraday'
 require 'json'
-require 'securerandom'
 require 'logger'
+require 'event_stream_parser'
+require 'securerandom'
 
-# Main module for RubyLLM functionality
 module RubyLLM
   class Error < StandardError; end
 
   class << self
-    attr_writer :configuration
+    def chat(model: nil)
+      Chat.new(model: model)
+    end
 
-    def configuration
-      @configuration ||= Configuration.new
+    def models
+      Models
     end
 
     def configure
-      yield(configuration) if block_given?
+      yield config
+    end
+
+    def config
+      @config ||= Configuration.new
     end
 
-    def client
-      @client ||= Client.new
+    def logger
+      @logger ||= Logger.new($stdout)
     end
+  end
+end
 
-    def loader
-      @loader ||= begin
-        loader = Zeitwerk::Loader.for_gem
+loader = Zeitwerk::Loader.for_gem
 
-        # Add lib directory to the load path
-        loader.push_dir(File.expand_path('..', __dir__))
+# Add lib directory to the load path
+loader.push_dir(File.expand_path('..', __dir__))
 
-        # Configure custom inflections
-        loader.inflector.inflect(
-          'ruby_llm' => 'RubyLLM',
-          'llm' => 'LLM',
-          'openai' => 'OpenAI',
-          'api' => 'API'
-        )
+# Configure custom inflections
+loader.inflector.inflect(
+  'ruby_llm' => 'RubyLLM',
+  'llm' => 'LLM',
+  'openai' => 'OpenAI',
+  'api' => 'API'
+)
 
-        # Ignore Rails-specific files and specs
-        loader.ignore("#{__dir__}/ruby_llm/railtie.rb")
-        loader.ignore("#{__dir__}/ruby_llm/active_record")
-        loader.ignore(File.expand_path('../spec', __dir__).to_s)
+# Ignore Rails-specific files and specs
+loader.ignore("#{__dir__}/ruby_llm/railtie.rb")
+loader.ignore("#{__dir__}/ruby_llm/active_record")
+loader.ignore(File.expand_path('../spec', __dir__).to_s)
 
-        # Log autoloading in debug mode
-        loader.logger = Logger.new($stdout) if ENV['RUBY_LLM_DEBUG']
-        loader.enable_reloading if ENV['RUBY_LLM_DEBUG']
+loader.enable_reloading if ENV['RUBY_LLM_DEBUG']
 
-        loader.setup
-        loader.eager_load
-        loader
-      end
-    end
-  end
-end
+loader.setup
+loader.eager_load if ENV['RUBY_LLM_DEBUG']
 
-# Initialize loader
-RubyLLM.loader
+RubyLLM::Provider.register :openai, RubyLLM::Providers::OpenAI
+RubyLLM::Provider.register :anthropic, RubyLLM::Providers::Anthropic
 
 # Load Rails integration if Rails is defined
 if defined?(Rails)
-  require 'active_support'
   require 'ruby_llm/railtie'
   require 'ruby_llm/active_record/acts_as'
 end

data/lib/tasks/models.rake

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+namespace :ruby_llm do
+  desc 'Update available models from providers'
+  task :update_models do
+    require 'ruby_llm'
+
+    # Configure API keys
+    RubyLLM.configure do |config|
+      config.openai_api_key = ENV.fetch('OPENAI_API_KEY')
+      config.anthropic_api_key = ENV.fetch('ANTHROPIC_API_KEY')
+    end
+
+    # Get all models
+    models = RubyLLM.models.refresh
+
+    # Write to models.json
+    models_file = File.expand_path('../../lib/ruby_llm/models.json', __dir__)
+    File.write(models_file, JSON.pretty_generate(models.map(&:to_h)))
+
+    puts "Updated models.json with #{models.size} models:"
+    puts "OpenAI models: #{models.count { |m| m.provider == 'openai' }}"
+    puts "Anthropic models: #{models.count { |m| m.provider == 'anthropic' }}"
+  end
+end

data/ruby_llm.gemspec

@@ -32,6 +32,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   # Runtime dependencies
+  spec.add_dependency 'event_stream_parser', '>= 0.3.0', '< 2.0.0'
   spec.add_dependency 'faraday', '>= 2.0'
   spec.add_dependency 'faraday-multipart', '>= 1.0'
   spec.add_dependency 'zeitwerk', '>= 2.6'