ruby_llm 0.1.0.pre30 → 0.1.0.pre31

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: 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/models.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    module OpenAI
+      # Models methods of the OpenAI API integration
+      module Models
+        module_function
+
+        def models_url
+          'models'
+        end
+
+        def parse_list_models_response(response) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          (response.body['data'] || []).map do |model|
+            ModelInfo.new(
+              id: model['id'],
+              created_at: model['created'] ? Time.at(model['created']) : nil,
+              display_name: capabilities.format_display_name(model['id']),
+              provider: slug,
+              type: capabilities.model_type(model['id']),
+              family: capabilities.model_family(model['id']),
+              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
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    module OpenAI
+      # Streaming methods of the OpenAI API integration
+      module Streaming
+        module_function
+
+        def stream_url
+          completion_url
+        end
+
+        def handle_stream(&block) # rubocop:disable Metrics/MethodLength
+          to_json_stream do |data|
+            block.call(
+              Chunk.new(
+                role: :assistant,
+                model_id: data['model'],
+                content: data.dig('choices', 0, 'delta', 'content'),
+                tool_calls: parse_tool_calls(data.dig('choices', 0, 'delta', 'tool_calls'), parse_arguments: false),
+                input_tokens: data.dig('usage', 'prompt_tokens'),
+                output_tokens: data.dig('usage', 'completion_tokens')
+              )
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    module OpenAI
+      # Tools methods of the OpenAI API integration
+      module Tools
+        module_function
+
+        def tool_for(tool) # rubocop:disable Metrics/MethodLength
+          {
+            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 param_schema(param)
+          {
+            type: param.type,
+            description: param.description
+          }.compact
+        end
+
+        def format_tool_calls(tool_calls) # rubocop:disable Metrics/MethodLength
+          return nil unless tool_calls&.any?
+
+          tool_calls.map do |_, tc|
+            {
+              id: tc.id,
+              type: 'function',
+              function: {
+                name: tc.name,
+                arguments: JSON.generate(tc.arguments)
+              }
+            }
+          end
+        end
+
+        def parse_tool_calls(tool_calls, parse_arguments: true) # rubocop:disable Metrics/MethodLength
+          return nil unless tool_calls&.any?
+
+          tool_calls.to_h do |tc|
+            [
+              tc['id'],
+              ToolCall.new(
+                id: tc['id'],
+                name: tc.dig('function', 'name'),
+                arguments: if parse_arguments
+                             JSON.parse(tc.dig('function',
+                                               'arguments'))
+                           else
+                             tc.dig('function', 'arguments')
+                           end
+              )
+            ]
+          end
+        end
+      end
+    end
+  end
+end