ruby_llm 0.1.0.pre30 → 0.1.0.pre33

data/lib/ruby_llm/providers/deepseek/capabilites.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    module DeepSeek
+      # Determines capabilities and pricing for DeepSeek models
+      module Capabilities
+        module_function
+
+        def context_window_for(model_id)
+          case model_id
+          when /deepseek-(?:chat|reasoner)/ then 64_000
+          else 32_768 # Sensible default
+          end
+        end
+
+        def max_tokens_for(model_id)
+          case model_id
+          when /deepseek-(?:chat|reasoner)/ then 8_192
+          else 4_096 # Default if max_tokens not specified
+          end
+        end
+
+        def input_price_for(model_id)
+          PRICES.dig(model_family(model_id), :input_miss) || default_input_price
+        end
+
+        def output_price_for(model_id)
+          PRICES.dig(model_family(model_id), :output) || default_output_price
+        end
+
+        def cache_hit_price_for(model_id)
+          PRICES.dig(model_family(model_id), :input_hit) || default_cache_hit_price
+        end
+
+        def supports_vision?(_model_id)
+          false # DeepSeek models don't currently support vision
+        end
+
+        def supports_functions?(model_id)
+          model_id.match?(/deepseek-chat/) # Only deepseek-chat supports function calling
+        end
+
+        def supports_json_mode?(model_id)
+          model_id.match?(/deepseek-chat/) # Only deepseek-chat supports JSON mode
+        end
+
+        def format_display_name(model_id)
+          case model_id
+          when 'deepseek-chat' then 'DeepSeek V3'
+          when 'deepseek-reasoner' then 'DeepSeek R1'
+          else
+            model_id.split('-')
+                    .map(&:capitalize)
+                    .join(' ')
+          end
+        end
+
+        def model_type(_model_id)
+          'chat' # All DeepSeek models are chat models
+        end
+
+        def model_family(model_id)
+          case model_id
+          when /deepseek-chat/ then :chat
+          when /deepseek-reasoner/ then :reasoner
+          else :chat # Default to chat family
+          end
+        end
+
+        # Pricing information for DeepSeek models (USD per 1M tokens)
+        PRICES = {
+          chat: {
+            input_hit: 0.07,   # $0.07 per million tokens on cache hit
+            input_miss: 0.27,  # $0.27 per million tokens on cache miss
+            output: 1.10       # $1.10 per million tokens output
+          },
+          reasoner: {
+            input_hit: 0.14,   # $0.14 per million tokens on cache hit
+            input_miss: 0.55,  # $0.55 per million tokens on cache miss
+            output: 2.19       # $2.19 per million tokens output
+          }
+        }.freeze
+
+        private
+
+        def default_input_price
+          0.27 # Default to chat cache miss price
+        end
+
+        def default_output_price
+          1.10 # Default to chat output price
+        end
+
+        def default_cache_hit_price
+          0.07 # Default to chat cache hit price
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/deepseek.rb

@@ -3,8 +3,10 @@
 module RubyLLM
   module Providers
     # DeepSeek API integration.
-    class DeepSeek < OpenAI
-      private
+    module DeepSeek
+      extend OpenAI
+
+      module_function
 
       def api_base
         'https://api.deepseek.com'

data/lib/ruby_llm/providers/gemini/capabilities.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    module Gemini
+      # Determines capabilities and pricing for Google Gemini models
+      module Capabilities # rubocop:disable Metrics/ModuleLength
+        module_function
+
+        def context_window_for(model_id)
+          case model_id
+          when /gemini-2\.0-flash/, /gemini-1\.5-flash/ then 1_048_576
+          when /gemini-1\.5-pro/ then 2_097_152
+          when /text-embedding/, /embedding-001/ then 2_048
+          when /aqa/ then 7_168
+          else 32_768 # Sensible default for unknown models
+          end
+        end
+
+        def max_tokens_for(model_id)
+          case model_id
+          when /gemini-2\.0-flash/, /gemini-1\.5/ then 8_192
+          when /text-embedding/, /embedding-001/ then 768 # Output dimension size for embeddings
+          when /aqa/ then 1_024
+          else 4_096 # Sensible default
+          end
+        end
+
+        def input_price_for(model_id)
+          base_price = PRICES.dig(pricing_family(model_id), :input) || default_input_price
+          return base_price unless long_context_model?(model_id)
+
+          # Double the price for prompts longer than 128k tokens
+          context_length(model_id) > 128_000 ? base_price * 2 : base_price
+        end
+
+        def output_price_for(model_id)
+          base_price = PRICES.dig(pricing_family(model_id), :output) || default_output_price
+          return base_price unless long_context_model?(model_id)
+
+          # Double the price for prompts longer than 128k tokens
+          context_length(model_id) > 128_000 ? base_price * 2 : base_price
+        end
+
+        def supports_vision?(model_id)
+          return false if model_id.match?(/text-embedding|embedding-001|aqa/)
+          return false if model_id.match?(/gemini-1\.0/)
+
+          model_id.match?(/gemini-[12]\.[05]/)
+        end
+
+        def supports_functions?(model_id)
+          return false if model_id.match?(/text-embedding|embedding-001|aqa/)
+          return false if model_id.match?(/flash-lite/)
+          return false if model_id.match?(/gemini-1\.0/)
+
+          model_id.match?(/gemini-[12]\.[05]-(?:pro|flash)(?!-lite)/)
+        end
+
+        def supports_json_mode?(model_id)
+          return false if model_id.match?(/text-embedding|embedding-001|aqa/)
+          return false if model_id.match?(/gemini-1\.0/)
+
+          model_id.match?(/gemini-\d/)
+        end
+
+        def format_display_name(model_id)
+          model_id
+            .delete_prefix('models/')
+            .split('-')
+            .map(&:capitalize)
+            .join(' ')
+            .gsub(/(\d+\.\d+)/, ' \1') # Add space before version numbers
+            .gsub(/\s+/, ' ')          # Clean up multiple spaces
+            .gsub(/Aqa/, 'AQA')        # Special case for AQA
+            .strip
+        end
+
+        def supports_caching?(model_id)
+          return false if model_id.match?(/flash-lite|gemini-1\.0/)
+
+          model_id.match?(/gemini-[12]\.[05]/)
+        end
+
+        def supports_tuning?(model_id)
+          model_id.match?(/gemini-1\.5-flash/)
+        end
+
+        def supports_audio?(model_id)
+          model_id.match?(/gemini-[12]\.[05]/)
+        end
+
+        def model_type(model_id)
+          case model_id
+          when /text-embedding|embedding/ then 'embedding'
+          when /imagen/ then 'image'
+          else 'chat'
+          end
+        end
+
+        def model_family(model_id) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength
+          case model_id
+          when /gemini-2\.0-flash-lite/ then 'gemini20_flash_lite'
+          when /gemini-2\.0-flash/ then 'gemini20_flash'
+          when /gemini-1\.5-flash-8b/ then 'gemini15_flash_8b'
+          when /gemini-1\.5-flash/ then 'gemini15_flash'
+          when /gemini-1\.5-pro/ then 'gemini15_pro'
+          when /gemini-1\.0-pro/ then 'gemini10_pro'
+          when /text-embedding-004/ then 'embedding4'
+          when /embedding-001/ then 'embedding1'
+          when /aqa/ then 'aqa'
+          else 'other'
+          end
+        end
+
+        def pricing_family(model_id) # rubocop:disable Metrics/CyclomaticComplexity
+          case model_id
+          when /gemini-2\.0-flash-lite/ then :flash_lite_2 # rubocop:disable Naming/VariableNumber
+          when /gemini-2\.0-flash/ then :flash_2 # rubocop:disable Naming/VariableNumber
+          when /gemini-1\.5-flash-8b/ then :flash_8b
+          when /gemini-1\.5-flash/ then :flash
+          when /gemini-1\.5-pro/ then :pro
+          when /gemini-1\.0-pro/ then :pro_1_0 # rubocop:disable Naming/VariableNumber
+          when /text-embedding|embedding/ then :embedding
+          else :base
+          end
+        end
+
+        private
+
+        def long_context_model?(model_id)
+          model_id.match?(/gemini-1\.5-(?:pro|flash)/)
+        end
+
+        def context_length(model_id)
+          context_window_for(model_id)
+        end
+
+        PRICES = {
+          flash_2: { # Gemini 2.0 Flash # rubocop:disable Naming/VariableNumber
+            input: 0.10,
+            output: 0.40,
+            audio_input: 0.70,
+            cache: 0.025,
+            cache_storage: 1.00
+          },
+          flash_lite_2: { # Gemini 2.0 Flash Lite # rubocop:disable Naming/VariableNumber
+            input: 0.075,
+            output: 0.30,
+            cache: 0.01875,
+            cache_storage: 1.00
+          },
+          flash: { # Gemini 1.5 Flash
+            input: 0.075,
+            output: 0.30,
+            cache: 0.01875,
+            cache_storage: 1.00
+          },
+          flash_8b: { # Gemini 1.5 Flash 8B
+            input: 0.0375,
+            output: 0.15,
+            cache: 0.01,
+            cache_storage: 0.25
+          },
+          pro: { # Gemini 1.5 Pro
+            input: 1.25,
+            output: 5.0,
+            cache: 0.3125,
+            cache_storage: 4.50
+          },
+          pro_1_0: { # Gemini 1.0 Pro # rubocop:disable Naming/VariableNumber
+            input: 0.50,
+            output: 1.50
+          },
+          embedding: { # Text Embedding models
+            input: 0.00,
+            output: 0.00
+          }
+        }.freeze
+
+        def default_input_price
+          0.075 # Default to Flash pricing
+        end
+
+        def default_output_price
+          0.30  # Default to Flash pricing
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/gemini/models.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    module Gemini
+      # Models methods of the Gemini API integration
+      module Models
+        module_function
+
+        def parse_list_models_response(response)
+          response.body['data']&.each do |model|
+            model['id'] = model['id'].delete_prefix('models/')
+          end
+
+          OpenAI::Models.parse_list_models_response(response)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/gemini.rb

@@ -3,8 +3,11 @@
 module RubyLLM
   module Providers
     # Gemini API integration.
-    class Gemini < OpenAI
-      private
+    module Gemini
+      extend OpenAI
+      extend Gemini::Models
+
+      module_function
 
       def api_base
         'https://generativelanguage.googleapis.com/v1beta/openai'
@@ -15,14 +18,6 @@ module RubyLLM
           'Authorization' => "Bearer #{RubyLLM.config.gemini_api_key}"
         }
       end
-
-      def parse_list_models_response(response)
-        response.body['data']&.each do |model|
-          model['id'] = model['id'].delete_prefix('models/')
-        end
-
-        super(response)
-      end
     end
   end
 end

data/lib/ruby_llm/providers/openai/capabilities.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    module OpenAI
+      # Determines capabilities and pricing for OpenAI models
+      module Capabilities # rubocop:disable Metrics/ModuleLength
+        module_function
+
+        def context_window_for(model_id)
+          case model_id
+          when /o[13]-mini/, /o3-mini-2025/         then 200_000
+          when /o1-2024/                            then 200_000
+          when /gpt-4o/, /gpt-4-turbo/             then 128_000
+          when /gpt-4-0[0-9]{3}/                   then 8_192
+          when /gpt-3.5-turbo-instruct/            then 4_096
+          when /gpt-3.5/                           then 16_385
+          else 4_096
+          end
+        end
+
+        def max_tokens_for(model_id) # rubocop:disable Metrics/CyclomaticComplexity
+          case model_id
+          when /o1-2024/, /o3-mini/                then 100_000
+          when /o1-mini-2024/                      then 65_536
+          when /gpt-4o-2024-05-13/                then 4_096
+          when /gpt-4o/, /gpt-4o-mini/            then 16_384
+          when /gpt-4o-realtime/                  then 4_096
+          when /gpt-4-0[0-9]{3}/                  then 8_192
+          when /gpt-3.5-turbo/                    then 4_096
+          else 4_096
+          end
+        end
+
+        def input_price_for(model_id)
+          PRICES.dig(model_family(model_id), :input) || default_input_price
+        end
+
+        def output_price_for(model_id)
+          PRICES.dig(model_family(model_id), :output) || default_output_price
+        end
+
+        def supports_vision?(model_id)
+          model_id.match?(/gpt-4o|o1/) || model_id.match?(/gpt-4-(?!0314|0613)/)
+        end
+
+        def supports_functions?(model_id)
+          !model_id.include?('instruct')
+        end
+
+        def supports_audio?(model_id)
+          model_id.match?(/audio-preview|realtime-preview|whisper|tts/)
+        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)
+          model_id.then { |id| humanize(id) }
+                  .then { |name| apply_special_formatting(name) }
+        end
+
+        def model_type(model_id)
+          case model_id
+          when /text-embedding|embedding/ then 'embedding'
+          when /dall-e/ then 'image'
+          when /tts|whisper/ then 'audio'
+          when /omni-moderation/ then 'moderation'
+          else 'chat'
+          end
+        end
+
+        def supports_structured_output?(model_id)
+          model_id.match?(/gpt-4o|o[13]-mini|o1/)
+        end
+
+        def model_family(model_id) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength
+          case model_id
+          when /o3-mini/ then 'o3_mini'
+          when /o1-mini/ then 'o1_mini'
+          when /o1/ then 'o1'
+          when /gpt-4o-audio/ then 'gpt4o_audio'
+          when /gpt-4o-realtime/ then 'gpt4o_realtime'
+          when /gpt-4o-mini-audio/ then 'gpt4o_mini_audio'
+          when /gpt-4o-mini-realtime/ then 'gpt4o_mini_realtime'
+          when /gpt-4o-mini/ then 'gpt4o_mini'
+          when /gpt-4o/ then 'gpt4o'
+          when /gpt-4-turbo/ then 'gpt4_turbo'
+          when /gpt-4/ then 'gpt4'
+          when /gpt-3.5-turbo-instruct/ then 'gpt35_instruct'
+          when /gpt-3.5/ then 'gpt35'
+          when /dall-e-3/ then 'dalle3'
+          when /dall-e-2/ then 'dalle2'
+          when /text-embedding-3-large/ then 'embedding3_large'
+          when /text-embedding-3-small/ then 'embedding3_small'
+          when /text-embedding-ada/ then 'embedding2'
+          when /tts-1-hd/ then 'tts1_hd'
+          when /tts-1/ then 'tts1'
+          when /whisper/ then 'whisper1'
+          when /omni-moderation/ then 'moderation'
+          when /babbage/ then 'babbage'
+          when /davinci/ then 'davinci'
+          else 'other'
+          end
+        end
+
+        private
+
+        PRICES = {
+          o1: { input: 15.0, cached_input: 7.5, output: 60.0 },
+          o1_mini: { input: 1.10, cached_input: 0.55, output: 4.40 },
+          o3_mini: { input: 1.10, cached_input: 0.55, output: 4.40 },
+          gpt4o: { input: 2.50, cached_input: 1.25, output: 10.0 },
+          gpt4o_audio: {
+            text_input: 2.50,
+            audio_input: 40.0,
+            text_output: 10.0,
+            audio_output: 80.0
+          },
+          gpt4o_realtime: {
+            text_input: 5.0,
+            cached_text_input: 2.50,
+            audio_input: 40.0,
+            cached_audio_input: 2.50,
+            text_output: 20.0,
+            audio_output: 80.0
+          },
+          gpt4o_mini: { input: 0.15, cached_input: 0.075, output: 0.60 },
+          gpt4o_mini_audio: {
+            text_input: 0.15,
+            audio_input: 10.0,
+            text_output: 0.60,
+            audio_output: 20.0
+          },
+          gpt4o_mini_realtime: {
+            text_input: 0.60,
+            cached_text_input: 0.30,
+            audio_input: 10.0,
+            cached_audio_input: 0.30,
+            text_output: 2.40,
+            audio_output: 20.0
+          },
+          gpt4_turbo: { input: 10.0, output: 30.0 },
+          gpt4: { input: 30.0, output: 60.0 },
+          gpt35: { input: 0.50, output: 1.50 },
+          gpt35_instruct: { input: 1.50, output: 2.0 },
+          embedding3_large: { price: 0.13 },
+          embedding3_small: { price: 0.02 },
+          embedding2: { price: 0.10 },
+          davinci: { input: 2.0, output: 2.0 },
+          babbage: { input: 0.40, output: 0.40 },
+          tts1: { price: 15.0 },
+          tts1_hd: { price: 30.0 },
+          whisper1: { price: 0.006 }
+        }.freeze
+
+        def default_input_price
+          0.50
+        end
+
+        def default_output_price
+          1.50
+        end
+
+        def humanize(id)
+          id.tr('-', ' ')
+            .split(' ')
+            .map(&:capitalize)
+            .join(' ')
+        end
+
+        def apply_special_formatting(name) # rubocop:disable Metrics/MethodLength
+          name
+            .gsub(/(\d{4}) (\d{2}) (\d{2})/, '\1\2\3')
+            .gsub(/^Gpt /, 'GPT-')
+            .gsub(/^O([13]) /, 'O\1-')
+            .gsub(/^Chatgpt /, 'ChatGPT-')
+            .gsub(/^Tts /, 'TTS-')
+            .gsub(/^Dall E /, 'DALL-E-')
+            .gsub(/3\.5 /, '3.5-')
+            .gsub(/4 /, '4-')
+            .gsub(/4o (?=Mini|Preview|Turbo|Audio)/, '4o-')
+            .gsub(/\bHd\b/, 'HD')
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/openai/chat.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    module OpenAI
+      # Chat methods of the OpenAI API integration
+      module Chat
+        module_function
+
+        def completion_url
+          'chat/completions'
+        end
+
+        def render_payload(messages, tools:, temperature:, model:, stream: false) # rubocop:disable Metrics/MethodLength
+          {
+            model: model,
+            messages: format_messages(messages),
+            temperature: temperature,
+            stream: stream
+          }.tap do |payload|
+            if tools.any?
+              payload[:tools] = tools.map { |_, tool| tool_for(tool) }
+              payload[:tool_choice] = 'auto'
+            end
+            payload[:stream_options] = { include_usage: true } if stream
+          end
+        end
+
+        def parse_completion_response(response) # rubocop:disable Metrics/MethodLength
+          data = response.body
+          return if data.empty?
+
+          message_data = data.dig('choices', 0, 'message')
+          return unless message_data
+
+          Message.new(
+            role: :assistant,
+            content: message_data['content'],
+            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 format_messages(messages)
+          messages.map do |msg|
+            {
+              role: format_role(msg.role),
+              content: Media.format_content(msg.content),
+              tool_calls: format_tool_calls(msg.tool_calls),
+              tool_call_id: msg.tool_call_id
+            }.compact
+          end
+        end
+
+        def format_role(role)
+          case role
+          when :system
+            'developer'
+          else
+            role.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/openai/embeddings.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    module OpenAI
+      # Embeddings methods of the OpenAI API integration
+      module Embeddings
+        module_function
+
+        def embedding_url
+          'embeddings'
+        end
+
+        def render_embedding_payload(text, model:)
+          {
+            model: model,
+            input: text
+          }
+        end
+
+        def parse_embedding_response(response)
+          data = response.body
+          model_id = data['model']
+          input_tokens = data.dig('usage', 'prompt_tokens') || 0
+          vectors = data['data'].map { |d| d['embedding'] }
+
+          # If we only got one embedding, return it as a single vector
+          vectors = vectors.size == 1 ? vectors.first : vectors
+
+          Embedding.new(
+            vectors: vectors,
+            model: model_id,
+            input_tokens: input_tokens
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/openai/images.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    module OpenAI
+      # Image generation methods for the OpenAI API integration
+      module Images
+        module_function
+
+        def images_url
+          'images/generations'
+        end
+
+        def render_image_payload(prompt, model:, size:)
+          {
+            model: model,
+            prompt: prompt,
+            n: 1,
+            size: size
+          }
+        end
+
+        private
+
+        def parse_image_response(response)
+          data = response.body
+          image_data = data['data'].first
+
+          Image.new(
+            url: image_data['url'],
+            revised_prompt: image_data['revised_prompt'],
+            model_id: data['model']
+          )
+        end
+      end
+    end
+  end
+end