ruby_llm 0.1.0.pre → 0.1.0.pre2

data/lib/ruby_llm/model_capabilities/openai.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module ModelCapabilities
+    class OpenAI < Base
+      def determine_context_window(model_id)
+        case model_id
+        when /gpt-4o/, /o1/, /gpt-4-turbo/
+          128_000
+        when /gpt-4-0[0-9]{3}/
+          8_192
+        when /gpt-3.5-turbo-instruct/
+          4_096
+        when /gpt-3.5/
+          16_385
+        else
+          4_096
+        end
+      end
+
+      def determine_max_tokens(model_id)
+        case model_id
+        when /o1-2024-12-17/
+          100_000
+        when /o1-mini-2024-09-12/
+          65_536
+        when /o1-preview-2024-09-12/
+          32_768
+        when /gpt-4o/, /gpt-4-turbo/
+          16_384
+        when /gpt-4-0[0-9]{3}/
+          8_192
+        when /gpt-3.5-turbo/
+          4_096
+        else
+          4_096
+        end
+      end
+
+      def get_input_price(model_id)
+        case model_id
+        when /o1-2024/
+          15.0    # $15.00 per million tokens
+        when /o1-mini/
+          3.0     # $3.00 per million tokens
+        when /gpt-4o-realtime-preview/
+          5.0     # $5.00 per million tokens
+        when /gpt-4o-mini-realtime-preview/
+          0.60    # $0.60 per million tokens
+        when /gpt-4o-mini/
+          0.15    # $0.15 per million tokens
+        when /gpt-4o/
+          2.50    # $2.50 per million tokens
+        when /gpt-4-turbo/
+          10.0    # $10.00 per million tokens
+        when /gpt-3.5/
+          0.50    # $0.50 per million tokens
+        else
+          0.50    # Default to GPT-3.5 pricing
+        end
+      end
+
+      def get_output_price(model_id)
+        case model_id
+        when /o1-2024/
+          60.0    # $60.00 per million tokens
+        when /o1-mini/
+          12.0    # $12.00 per million tokens
+        when /gpt-4o-realtime-preview/
+          20.0    # $20.00 per million tokens
+        when /gpt-4o-mini-realtime-preview/
+          2.40    # $2.40 per million tokens
+        when /gpt-4o-mini/
+          0.60    # $0.60 per million tokens
+        when /gpt-4o/
+          10.0    # $10.00 per million tokens
+        when /gpt-4-turbo/
+          30.0    # $30.00 per million tokens
+        when /gpt-3.5/
+          1.50    # $1.50 per million tokens
+        else
+          1.50    # Default to GPT-3.5 pricing
+        end
+      end
+
+      def supports_functions?(model_id)
+        !model_id.include?('instruct')
+      end
+
+      def supports_vision?(model_id)
+        model_id.include?('vision') || model_id.match?(/gpt-4-(?!0314|0613)/)
+      end
+
+      def supports_json_mode?(model_id)
+        model_id.match?(/gpt-4-\d{4}-preview/) ||
+          model_id.include?('turbo') ||
+          model_id.match?(/gpt-3.5-turbo-(?!0301|0613)/)
+      end
+
+      def format_display_name(model_id)
+        # First replace hyphens with spaces
+        name = model_id.tr('-', ' ')
+
+        # Capitalize each word
+        name = name.split(' ').map { |word| word.capitalize }.join(' ')
+
+        # Apply specific formatting rules
+        name.gsub(/(\d{4}) (\d{2}) (\d{2})/, '\1\2\3') # Convert dates to YYYYMMDD
+            .gsub(/^Gpt /, 'GPT-')
+            .gsub(/^O1 /, 'O1-')
+            .gsub(/^Chatgpt /, 'ChatGPT-')
+            .gsub(/^Tts /, 'TTS-')
+            .gsub(/^Dall E /, 'DALL-E-')
+            .gsub(/3\.5 /, '3.5-')
+            .gsub(/4 /, '4-')
+            .gsub(/4o (?=Mini|Preview|Turbo)/, '4o-')
+            .gsub(/\bHd\b/, 'HD')
+      end
+    end
+  end
+end

data/lib/ruby_llm/model_info.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  class ModelInfo
+    attr_reader :id, :created_at, :display_name, :provider, :metadata,
+                :context_window, :max_tokens, :supports_vision, :supports_functions,
+                :supports_json_mode, :input_price_per_million, :output_price_per_million
+
+    def initialize(id:, created_at:, display_name:, provider:, context_window:, max_tokens:, supports_vision:,
+                   supports_functions:, supports_json_mode:, input_price_per_million:, output_price_per_million:, metadata: {})
+      @id = id
+      @created_at = created_at
+      @display_name = display_name
+      @provider = provider
+      @metadata = metadata
+      @context_window = context_window
+      @max_tokens = max_tokens
+      @supports_vision = supports_vision
+      @supports_functions = supports_functions
+      @supports_json_mode = supports_json_mode
+      @input_price_per_million = input_price_per_million
+      @output_price_per_million = output_price_per_million
+    end
+
+    def to_h
+      {
+        id: id,
+        created_at: created_at,
+        display_name: display_name,
+        provider: provider,
+        metadata: metadata,
+        context_window: context_window,
+        max_tokens: max_tokens,
+        supports_vision: supports_vision,
+        supports_functions: supports_functions,
+        supports_json_mode: supports_json_mode,
+        input_price_per_million: input_price_per_million,
+        output_price_per_million: output_price_per_million
+      }
+    end
+  end
+end

data/lib/ruby_llm/providers/anthropic.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+require 'time'
+
+module RubyLLM
+  module Providers
+    class Anthropic < Base
+      def chat(messages, model: nil, temperature: 0.7, stream: false, tools: nil, &block)
+        payload = {
+          model: model || 'claude-3-5-sonnet-20241022',
+          messages: format_messages(messages),
+          temperature: temperature,
+          stream: stream,
+          max_tokens: 4096
+        }
+
+        payload[:tools] = tools.map { |tool| tool_to_anthropic(tool) } if tools&.any?
+
+        puts 'Sending payload to Anthropic:' if ENV['RUBY_LLM_DEBUG']
+        puts JSON.pretty_generate(payload) if ENV['RUBY_LLM_DEBUG']
+
+        if stream && block_given?
+          stream_chat_completion(payload, tools, &block)
+        else
+          create_chat_completion(payload, tools)
+        end
+      end
+
+      def list_models
+        response = @connection.get('/v1/models') do |req|
+          req.headers['x-api-key'] = RubyLLM.configuration.anthropic_api_key
+          req.headers['anthropic-version'] = '2023-06-01'
+        end
+
+        raise RubyLLM::Error, "API error: #{parse_error_message(response)}" if response.status >= 400
+
+        capabilities = RubyLLM::ModelCapabilities::Anthropic.new
+        models_data = response.body['data'] || []
+
+        models_data.map do |model|
+          ModelInfo.new(
+            id: model['id'],
+            created_at: Time.parse(model['created_at']),
+            display_name: model['display_name'],
+            provider: 'anthropic',
+            metadata: {
+              type: model['type']
+            },
+            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'])
+          )
+        end
+      rescue Faraday::Error => e
+        handle_error(e)
+      end
+
+      private
+
+      def tool_to_anthropic(tool)
+        {
+          name: tool.name,
+          description: tool.description,
+          input_schema: {
+            type: 'object',
+            properties: tool.parameters,
+            required: tool.parameters.select { |_, v| v[:required] }.keys
+          }
+        }
+      end
+
+      def format_messages(messages)
+        messages.map do |msg|
+          message = { role: msg.role == :user ? 'user' : 'assistant' }
+
+          message[:content] = if msg.tool_results
+                                [
+                                  {
+                                    type: 'tool_result',
+                                    tool_use_id: msg.tool_results[:tool_use_id],
+                                    content: msg.tool_results[:content],
+                                    is_error: msg.tool_results[:is_error]
+                                  }.compact
+                                ]
+                              else
+                                msg.content
+                              end
+
+          message
+        end
+      end
+
+      def create_chat_completion(payload, tools = nil)
+        response = @connection.post('/v1/messages') do |req|
+          req.headers['x-api-key'] = RubyLLM.configuration.anthropic_api_key
+          req.headers['anthropic-version'] = '2023-06-01'
+          req.headers['Content-Type'] = 'application/json'
+          req.body = payload
+        end
+
+        puts 'Response from Anthropic:' if ENV['RUBY_LLM_DEBUG']
+        puts JSON.pretty_generate(response.body) if ENV['RUBY_LLM_DEBUG']
+
+        handle_response(response, tools, payload)
+      rescue Faraday::Error => e
+        handle_error(e)
+      end
+
+      def stream_chat_completion(payload, tools = nil)
+        response = @connection.post('/v1/messages') do |req|
+          req.headers['x-api-key'] = RubyLLM.configuration.anthropic_api_key
+          req.headers['anthropic-version'] = '2023-06-01'
+          req.body = payload
+        end
+
+        response.body.each_line do |line|
+          next if line.strip.empty?
+          next if line == 'data: [DONE]'
+
+          begin
+            data = JSON.parse(line.sub(/^data: /, ''))
+
+            if data['type'] == 'content_block_delta'
+              content = data['delta']['text']
+              yield Message.new(role: :assistant, content: content) if content
+            elsif data['type'] == 'tool_call'
+              handle_tool_calls(data['tool_calls'], tools) do |result|
+                yield Message.new(role: :assistant, content: result)
+              end
+            end
+          rescue JSON::ParserError
+            next
+          end
+        end
+      rescue Faraday::Error => e
+        handle_error(e)
+      end
+
+      def handle_response(response, tools, payload)
+        data = response.body
+        return Message.new(role: :assistant, content: '') if data['type'] == 'error'
+
+        # Extract text content and tool use from response
+        content_parts = data['content'] || []
+        text_content = content_parts.find { |c| c['type'] == 'text' }&.fetch('text', '')
+        tool_use = content_parts.find { |c| c['type'] == 'tool_use' }
+
+        if tool_use && tools
+          tool = tools.find { |t| t.name == tool_use['name'] }
+          result = if tool
+                     begin
+                       tool_result = tool.call(tool_use['input'] || {})
+                       {
+                         tool_use_id: tool_use['id'],
+                         content: tool_result.to_s
+                       }
+                     rescue StandardError => e
+                       {
+                         tool_use_id: tool_use['id'],
+                         content: "Error executing tool #{tool.name}: #{e.message}",
+                         is_error: true
+                       }
+                     end
+                   end
+
+          # Create a new message with the tool result
+          new_messages = payload[:messages] + [
+            { role: 'assistant', content: data['content'] },
+            {
+              role: 'user',
+              content: [
+                {
+                  type: 'tool_result',
+                  tool_use_id: result[:tool_use_id],
+                  content: result[:content],
+                  is_error: result[:is_error]
+                }.compact
+              ]
+            }
+          ]
+
+          return create_chat_completion(payload.merge(messages: new_messages), tools)
+        end
+
+        Message.new(
+          role: :assistant,
+          content: text_content
+        )
+      end
+
+      def handle_tool_calls(tool_calls, tools)
+        return [] unless tool_calls && tools
+
+        tool_calls.map do |tool_call|
+          tool = tools.find { |t| t.name == tool_call['name'] }
+          next unless tool
+
+          begin
+            args = JSON.parse(tool_call['arguments'])
+            result = tool.call(args)
+            puts "Tool result: #{result}" if ENV['RUBY_LLM_DEBUG']
+            {
+              tool_use_id: tool_call['id'],
+              content: result.to_s
+            }
+          rescue JSON::ParserError, ArgumentError => e
+            puts "Error executing tool: #{e.message}" if ENV['RUBY_LLM_DEBUG']
+            {
+              tool_use_id: tool_call['id'],
+              content: "Error executing tool #{tool.name}: #{e.message}",
+              is_error: true
+            }
+          end
+        end.compact
+      end
+
+      def api_base
+        'https://api.anthropic.com'
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/base.rb

@@ -1,6 +1,11 @@
+# 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
@@ -23,9 +28,9 @@ module RubyLLM
       def handle_error(error)
         case error
         when Faraday::TimeoutError
-          raise RubyLLM::Error, "Request timed out"
+          raise RubyLLM::Error, 'Request timed out'
         when Faraday::ConnectionFailed
-          raise RubyLLM::Error, "Connection failed"
+          raise RubyLLM::Error, 'Connection failed'
         when Faraday::ClientError
           handle_api_error(error)
         else
@@ -36,6 +41,20 @@ module RubyLLM
       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

data/lib/ruby_llm/providers/openai.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+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
+        }
+
+        if tools&.any?
+          payload[:functions] = tools.map { |tool| tool_to_function(tool) }
+          payload[:function_call] = 'auto'
+        end
+
+        puts 'Sending payload to OpenAI:' if ENV['RUBY_LLM_DEBUG']
+        puts JSON.pretty_generate(payload) if ENV['RUBY_LLM_DEBUG']
+
+        if stream && block_given?
+          stream_chat_completion(payload, tools, &block)
+        else
+          create_chat_completion(payload, tools)
+        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}"
+        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'])
+          )
+        end
+      rescue Faraday::Error => e
+        handle_error(e)
+      end
+
+      private
+
+      def tool_to_function(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
+          }
+        }
+      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)
+      end
+
+      def handle_response(response, tools, payload)
+        data = response.body
+        message_data = data.dig('choices', 0, 'message')
+        return Message.new(role: :assistant, content: '') unless message_data
+
+        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
+
+        Message.new(
+          role: :assistant,
+          content: message_data['content']
+        )
+      end
+
+      def handle_function_call(function_call, tools)
+        return unless function_call && tools
+
+        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}"
+        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}"
+
+        else
+          raise error
+        end
+      end
+
+      def api_base
+        'https://api.openai.com'
+      end
+    end
+  end
+end

data/lib/ruby_llm/railtie.rb

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 module RubyLLM
+  # Rails integration for RubyLLM
   class Railtie < Rails::Railtie
     initializer 'ruby_llm.initialize' do
       ActiveSupport.on_load(:active_record) do

data/lib/ruby_llm/tool.rb

@@ -0,0 +1,75 @@
+# 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
+
+    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)
+
+        method_params[param_name] = {
+          type: 'string',
+          description: parameter_descriptions[param_name] || param_name.to_s.tr('_', ' '),
+          required: %i[req keyreq].include?(param_type)
+        }
+      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
+      end
+    end
+
+    def initialize(name:, description:, parameters: {}, &block)
+      @name = name
+      @description = description
+      @parameters = parameters
+      @handler = block
+
+      validate!
+    end
+
+    def call(args)
+      validated_args = validate_args!(args)
+      handler.call(validated_args)
+    end
+
+    private
+
+    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)
+    end
+
+    def validate_args!(args)
+      args = args.transform_keys(&:to_sym)
+      required_params = parameters.select { |_, v| v[:required] }.keys
+
+      required_params.each do |param|
+        raise ArgumentError, "Missing required parameter: #{param}" unless args.key?(param.to_sym)
+      end
+
+      args
+    end
+  end
+end

data/lib/ruby_llm/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RubyLLM
-  VERSION = "0.1.0.pre"
+  VERSION = '0.1.0.pre2'
 end