ruby_llm 1.2.0 → 1.3.0rc1

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

@@ -3,7 +3,8 @@
 module RubyLLM
   module Providers
     module OpenAI
-      module Capabilities # rubocop:disable Metrics/ModuleLength,Style/Documentation
+      # Determines capabilities and pricing for OpenAI models
+      module Capabilities
         module_function
 
         MODEL_PATTERNS = {
@@ -40,7 +41,7 @@ module RubyLLM
           moderation: /^(?:omni|text)-moderation/
         }.freeze
 
-        def context_window_for(model_id) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength
+        def context_window_for(model_id)
           case model_family(model_id)
           when 'gpt41', 'gpt41_mini', 'gpt41_nano' then 1_047_576
           when 'chatgpt4o', 'gpt4_turbo', 'gpt4o', 'gpt4o_audio', 'gpt4o_mini',
@@ -56,7 +57,7 @@ module RubyLLM
           end
         end
 
-        def max_tokens_for(model_id) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength
+        def max_tokens_for(model_id)
           case model_family(model_id)
           when 'gpt41', 'gpt41_mini', 'gpt41_nano' then 32_768
           when 'chatgpt4o', 'gpt4o', 'gpt4o_mini', 'gpt4o_mini_search' then 16_384
@@ -222,6 +223,80 @@ module RubyLLM
             temperature
           end
         end
+
+        def modalities_for(model_id)
+          modalities = {
+            input: ['text'],
+            output: ['text']
+          }
+
+          # Vision support
+          modalities[:input] << 'image' if supports_vision?(model_id)
+
+          # Audio support
+          modalities[:input] << 'audio' if model_id.match?(/whisper|audio|tts|transcribe/)
+
+          # PDF support
+          modalities[:input] << 'pdf' if supports_vision?(model_id)
+
+          # Output modalities
+          modalities[:output] << 'audio' if model_id.match?(/tts|audio/)
+
+          modalities[:output] << 'image' if model_id.match?(/dall-e|image/)
+
+          modalities[:output] << 'embeddings' if model_id.match?(/embedding/)
+
+          modalities[:output] << 'moderation' if model_id.match?(/moderation/)
+
+          modalities
+        end
+
+        def capabilities_for(model_id) # rubocop:disable Metrics/PerceivedComplexity
+          capabilities = []
+
+          # Common capabilities
+          capabilities << 'streaming' unless model_id.match?(/moderation|embedding/)
+          capabilities << 'function_calling' if supports_functions?(model_id)
+          capabilities << 'structured_output' if supports_json_mode?(model_id)
+          capabilities << 'batch' if model_id.match?(/embedding|batch/)
+
+          # Advanced capabilities
+          capabilities << 'reasoning' if model_id.match?(/o1/)
+
+          if model_id.match?(/gpt-4-turbo|gpt-4o|claude/)
+            capabilities << 'image_generation' if model_id.match?(/vision/)
+            capabilities << 'speech_generation' if model_id.match?(/audio/)
+            capabilities << 'transcription' if model_id.match?(/audio/)
+          end
+
+          capabilities
+        end
+
+        def pricing_for(model_id)
+          standard_pricing = {
+            input_per_million: input_price_for(model_id),
+            output_per_million: output_price_for(model_id)
+          }
+
+          # Add cached pricing if available
+          if respond_to?(:cached_input_price_for)
+            cached_price = cached_input_price_for(model_id)
+            standard_pricing[:cached_input_per_million] = cached_price if cached_price
+          end
+
+          # Pricing structure
+          pricing = { text_tokens: { standard: standard_pricing } }
+
+          # Add batch pricing if applicable
+          if model_id.match?(/embedding|batch/)
+            pricing[:text_tokens][:batch] = {
+              input_per_million: standard_pricing[:input_per_million] * 0.5,
+              output_per_million: standard_pricing[:output_per_million] * 0.5
+            }
+          end
+
+          pricing
+        end
       end
     end
   end

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

@@ -5,13 +5,13 @@ module RubyLLM
     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
+        module_function
+
+        def render_payload(messages, tools:, temperature:, model:, stream: false)
           {
             model: model,
             messages: format_messages(messages),
@@ -26,10 +26,12 @@ module RubyLLM
           end
         end
 
-        def parse_completion_response(response) # rubocop:disable Metrics/MethodLength
+        def parse_completion_response(response)
           data = response.body
           return if data.empty?
 
+          raise Error.new(response, data.dig('error', 'message')) if data.dig('error', 'message')
+
           message_data = data.dig('choices', 0, 'message')
           return unless message_data
 

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

@@ -7,31 +7,27 @@ module RubyLLM
       module Embeddings
         module_function
 
-        def embedding_url
+        def embedding_url(...)
           'embeddings'
         end
 
-        def render_embedding_payload(text, model:)
+        def render_embedding_payload(text, model:, dimensions:)
           {
             model: model,
-            input: text
-          }
+            input: text,
+            dimensions: dimensions
+          }.compact
         end
 
-        def parse_embedding_response(response)
+        def parse_embedding_response(response, model:)
           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.first if vectors.size == 1
+          vectors in [vectors]
 
-          Embedding.new(
-            vectors: vectors,
-            model: model_id,
-            input_tokens: input_tokens
-          )
+          Embedding.new(vectors:, model:, input_tokens:)
         end
       end
     end

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

@@ -7,44 +7,61 @@ module RubyLLM
       module Media
         module_function
 
-        def format_content(content) # rubocop:disable Metrics/MethodLength
-          return content unless content.is_a?(Array)
-
-          content.map do |part|
-            case part[:type]
-            when 'image'
-              format_image(part)
-            when 'input_audio'
-              format_audio(part)
-            else
-              part
+        def format_content(content)
+          return content unless content.is_a?(Content)
+
+          parts = []
+          parts << format_text(content.text) if content.text
+
+          content.attachments.each do |attachment|
+            case attachment
+            when Attachments::Image
+              parts << format_image(attachment)
+            when Attachments::PDF
+              parts << format_pdf(attachment)
+            when Attachments::Audio
+              parts << format_audio(attachment)
             end
           end
+
+          parts
         end
 
-        def format_image(part)
+        def format_image(image)
           {
             type: 'image_url',
             image_url: {
-              url: format_data_url(part[:source]),
+              url: image.url? ? image.source : "data:#{image.mime_type};base64,#{image.encoded}",
               detail: 'auto'
             }
           }
         end
 
-        def format_audio(part)
+        def format_pdf(pdf)
+          {
+            type: 'file',
+            file: {
+              filename: File.basename(pdf.source),
+              file_data: "data:#{pdf.mime_type};base64,#{pdf.encoded}"
+            }
+          }
+        end
+
+        def format_audio(audio)
           {
             type: 'input_audio',
-            input_audio: part[:input_audio]
+            input_audio: {
+              data: audio.encoded,
+              format: audio.format
+            }
           }
         end
 
-        def format_data_url(source)
-          if source[:type] == 'base64'
-            "data:#{source[:media_type]};base64,#{source[:data]}"
-          else
-            source[:url]
-          end
+        def format_text(text)
+          {
+            type: 'text',
+            text: text
+          }
         end
       end
     end

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

@@ -11,26 +11,25 @@ module RubyLLM
           'models'
         end
 
-        def parse_list_models_response(response, slug, capabilities) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-          (response.body['data'] || []).map do |model|
+        def parse_list_models_response(response, slug, capabilities)
+          Array(response.body['data']).map do |model_data|
+            model_id = model_data['id']
+
             ModelInfo.new(
-              id: model['id'],
-              created_at: model['created'] ? Time.at(model['created']) : nil,
-              display_name: capabilities.format_display_name(model['id']),
+              id: model_id,
+              name: capabilities.format_display_name(model_id),
               provider: slug,
-              type: capabilities.model_type(model['id']),
-              family: capabilities.model_family(model['id']),
+              family: capabilities.model_family(model_id),
+              created_at: model_data['created'] ? Time.at(model_data['created']) : nil,
+              context_window: capabilities.context_window_for(model_id),
+              max_output_tokens: capabilities.max_tokens_for(model_id),
+              modalities: capabilities.modalities_for(model_id),
+              capabilities: capabilities.capabilities_for(model_id),
+              pricing: capabilities.pricing_for(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'])
+                object: model_data['object'],
+                owned_by: model_data['owned_by']
+              }
             )
           end
         end

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

@@ -7,7 +7,7 @@ module RubyLLM
       module Tools
         module_function
 
-        def tool_for(tool) # rubocop:disable Metrics/MethodLength
+        def tool_for(tool)
           {
             type: 'function',
             function: {
@@ -29,7 +29,7 @@ module RubyLLM
           }.compact
         end
 
-        def format_tool_calls(tool_calls) # rubocop:disable Metrics/MethodLength
+        def format_tool_calls(tool_calls)
           return nil unless tool_calls&.any?
 
           tool_calls.map do |_, tc|
@@ -44,7 +44,7 @@ module RubyLLM
           end
         end
 
-        def parse_tool_calls(tool_calls, parse_arguments: true) # rubocop:disable Metrics/MethodLength
+        def parse_tool_calls(tool_calls, parse_arguments: true)
           return nil unless tool_calls&.any?
 
           tool_calls.to_h do |tc|
@@ -54,8 +54,12 @@ module RubyLLM
                 id: tc['id'],
                 name: tc.dig('function', 'name'),
                 arguments: if parse_arguments
-                             JSON.parse(tc.dig('function',
-                                               'arguments'))
+                             if tc.dig('function', 'arguments').empty?
+                               {}
+                             else
+                               JSON.parse(tc.dig('function',
+                                                 'arguments'))
+                             end
                            else
                              tc.dig('function', 'arguments')
                            end

data/lib/ruby_llm/providers/openai.rb

@@ -28,14 +28,16 @@ module RubyLLM
 
       module_function
 
-      def api_base
-        RubyLLM.config.openai_api_base || 'https://api.openai.com/v1'
+      def api_base(config)
+        config.openai_api_base || 'https://api.openai.com/v1'
       end
 
-      def headers
+      def headers(config)
         {
-          'Authorization' => "Bearer #{RubyLLM.config.openai_api_key}"
-        }
+          'Authorization' => "Bearer #{config.openai_api_key}",
+          'OpenAI-Organization' => config.openai_organization_id,
+          'OpenAI-Project' => config.openai_project_id
+        }.compact
       end
 
       def capabilities

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    module OpenRouter
+      # Models methods of the OpenRouter API integration
+      module Models
+        module_function
+
+        def models_url
+          'models'
+        end
+
+        def parse_list_models_response(response, slug, _capabilities)
+          Array(response.body['data']).map do |model_data| # rubocop:disable Metrics/BlockLength
+            # Extract modalities directly from architecture
+            modalities = {
+              input: Array(model_data.dig('architecture', 'input_modalities')),
+              output: Array(model_data.dig('architecture', 'output_modalities'))
+            }
+
+            # Construct pricing from API data, only adding non-zero values
+            pricing = { text_tokens: { standard: {} } }
+
+            pricing_types = {
+              prompt: :input_per_million,
+              completion: :output_per_million,
+              input_cache_read: :cached_input_per_million,
+              internal_reasoning: :reasoning_output_per_million
+            }
+
+            pricing_types.each do |source_key, target_key|
+              value = model_data.dig('pricing', source_key.to_s).to_f
+              pricing[:text_tokens][:standard][target_key] = value * 1_000_000 if value.positive?
+            end
+
+            # Convert OpenRouter's supported parameters to our capability format
+            capabilities = supported_parameters_to_capabilities(model_data['supported_parameters'])
+
+            ModelInfo.new(
+              id: model_data['id'],
+              name: model_data['name'],
+              provider: slug,
+              family: model_data['id'].split('/').first,
+              created_at: model_data['created'] ? Time.at(model_data['created']) : nil,
+              context_window: model_data['context_length'],
+              max_output_tokens: model_data.dig('top_provider', 'max_completion_tokens'),
+              modalities: modalities,
+              capabilities: capabilities,
+              pricing: pricing,
+              metadata: {
+                description: model_data['description'],
+                architecture: model_data['architecture'],
+                top_provider: model_data['top_provider'],
+                per_request_limits: model_data['per_request_limits'],
+                supported_parameters: model_data['supported_parameters']
+              }
+            )
+          end
+        end
+
+        def supported_parameters_to_capabilities(params)
+          return [] unless params
+
+          capabilities = []
+
+          # Standard capabilities mapping
+          capabilities << 'streaming' # Assume all OpenRouter models support streaming
+
+          # Function calling capability
+          capabilities << 'function_calling' if params.include?('tools') || params.include?('tool_choice')
+
+          # Structured output capability
+          capabilities << 'structured_output' if params.include?('response_format')
+
+          # Batch capability
+          capabilities << 'batch' if params.include?('batch')
+
+          # Additional mappings based on params
+          # Handles advanced model capabilities that might be inferred from supported params
+          capabilities << 'predicted_outputs' if params.include?('logit_bias') && params.include?('top_k')
+
+          capabilities
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/openrouter.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    # OpenRouter API integration.
+    module OpenRouter
+      extend OpenAI
+      extend OpenRouter::Models
+
+      module_function
+
+      def api_base(_config)
+        'https://openrouter.ai/api/v1'
+      end
+
+      def headers(config)
+        {
+          'Authorization' => "Bearer #{config.openrouter_api_key}"
+        }
+      end
+
+      def slug
+        'openrouter'
+      end
+
+      def configuration_requirements
+        %i[openrouter_api_key]
+      end
+    end
+  end
+end

data/lib/ruby_llm/stream_accumulator.rb

@@ -42,7 +42,7 @@ module RubyLLM
 
     private
 
-    def tool_calls_from_stream # rubocop:disable Metrics/MethodLength
+    def tool_calls_from_stream
       tool_calls.transform_values do |tc|
         arguments = if tc.arguments.is_a?(String) && !tc.arguments.empty?
                       JSON.parse(tc.arguments)
@@ -60,7 +60,7 @@ module RubyLLM
       end
     end
 
-    def accumulate_tool_calls(new_tool_calls) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+    def accumulate_tool_calls(new_tool_calls)
       RubyLLM.logger.debug "Accumulating tool calls: #{new_tool_calls}"
       new_tool_calls.each_value do |tool_call|
         if tool_call.id
@@ -89,8 +89,8 @@ module RubyLLM
     end
 
     def count_tokens(chunk)
-      @input_tokens += chunk.input_tokens if chunk.input_tokens
-      @output_tokens += chunk.output_tokens if chunk.output_tokens
+      @input_tokens = chunk.input_tokens if chunk.input_tokens
+      @output_tokens = chunk.output_tokens if chunk.output_tokens
     end
   end
 end

data/lib/ruby_llm/streaming.rb

@@ -8,10 +8,10 @@ module RubyLLM
   module Streaming
     module_function
 
-    def stream_response(payload, &block)
+    def stream_response(connection, payload, &block)
       accumulator = StreamAccumulator.new
 
-      post stream_url, payload do |req|
+      connection.post stream_url, payload do |req|
         req.options.on_data = handle_stream do |chunk|
           accumulator.add chunk
           block.call chunk
@@ -29,7 +29,7 @@ module RubyLLM
 
     private
 
-    def to_json_stream(&block) # rubocop:disable Metrics/MethodLength
+    def to_json_stream(&block)
       buffer = String.new
       parser = EventStreamParser::Parser.new
 

data/lib/ruby_llm/utils.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  # Provides utility functions for data manipulation within the RubyLLM library
+  module Utils
+    module_function
+
+    def deep_symbolize_keys(value)
+      case value
+      when Hash
+        value.each_with_object({}) do |(k, v), new_hash|
+          new_key = k.is_a?(String) ? k.to_sym : k
+          new_hash[new_key] = deep_symbolize_keys(v)
+        end
+      when Array
+        value.map { |v| deep_symbolize_keys(v) }
+      else
+        value
+      end
+    end
+  end
+end

data/lib/ruby_llm/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RubyLLM
-  VERSION = '1.2.0'
+  VERSION = '1.3.0rc1'
 end

data/lib/ruby_llm.rb

@@ -16,7 +16,9 @@ loader.inflector.inflect(
   'openai' => 'OpenAI',
   'api' => 'API',
   'deepseek' => 'DeepSeek',
-  'bedrock' => 'Bedrock'
+  'bedrock' => 'Bedrock',
+  'openrouter' => 'OpenRouter',
+  'pdf' => 'PDF'
 )
 loader.ignore("#{__dir__}/tasks")
 loader.ignore("#{__dir__}/ruby_llm/railtie")
@@ -30,8 +32,14 @@ module RubyLLM
   class Error < StandardError; end
 
   class << self
-    def chat(model: nil, provider: nil, assume_model_exists: false)
-      Chat.new(model:, provider:, assume_model_exists:)
+    def context
+      context_config = config.dup
+      yield context_config if block_given?
+      Context.new(context_config)
+    end
+
+    def chat(...)
+      Chat.new(...)
     end
 
     def embed(...)
@@ -60,9 +68,9 @@ module RubyLLM
 
     def logger
       @logger ||= Logger.new(
-        $stdout,
+        config.log_file,
         progname: 'RubyLLM',
-        level: ENV['RUBYLLM_DEBUG'] ? Logger::DEBUG : Logger::INFO
+        level: config.log_level
       )
     end
   end
@@ -73,6 +81,8 @@ RubyLLM::Provider.register :anthropic, RubyLLM::Providers::Anthropic
 RubyLLM::Provider.register :gemini, RubyLLM::Providers::Gemini
 RubyLLM::Provider.register :deepseek, RubyLLM::Providers::DeepSeek
 RubyLLM::Provider.register :bedrock, RubyLLM::Providers::Bedrock
+RubyLLM::Provider.register :openrouter, RubyLLM::Providers::OpenRouter
+RubyLLM::Provider.register :ollama, RubyLLM::Providers::Ollama
 
 if defined?(Rails::Railtie)
   require 'ruby_llm/railtie'