dify_llm 1.9.1 → 1.14.1

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

@@ -53,7 +53,7 @@ module RubyLLM
           return nil unless tool_calls&.any?
 
           tool_calls.map do |_, tc|
-            {
+            call = {
               id: tc.id,
               type: 'function',
               function: {
@@ -61,6 +61,12 @@ module RubyLLM
                 arguments: JSON.generate(tc.arguments)
               }
             }
+            if tc.thought_signature
+              call[:extra_content] = {
+                google: { thought_signature: tc.thought_signature }
+              }
+            end
+            call
           end
         end
 
@@ -87,11 +93,30 @@ module RubyLLM
                              parse_tool_call_arguments(tc)
                            else
                              tc.dig('function', 'arguments')
-                           end
+                           end,
+                thought_signature: extract_tool_call_thought_signature(tc)
               )
             ]
           end
         end
+
+        def build_tool_choice(tool_choice)
+          case tool_choice
+          when :auto, :none, :required
+            tool_choice
+          else
+            {
+              type: 'function',
+              function: {
+                name: tool_choice
+              }
+            }
+          end
+        end
+
+        def extract_tool_call_thought_signature(tool_call)
+          tool_call.dig('extra_content', 'google', 'thought_signature')
+        end
       end
     end
   end

data/lib/ruby_llm/providers/openai.rb

@@ -27,7 +27,7 @@ module RubyLLM
       end
 
       def maybe_normalize_temperature(temperature, model)
-        OpenAI::Capabilities.normalize_temperature(temperature, model.id)
+        OpenAI::Temperature.normalize(temperature, model.id)
       end
 
       class << self
@@ -35,6 +35,16 @@ module RubyLLM
           OpenAI::Capabilities
         end
 
+        def configuration_options
+          %i[
+            openai_api_key
+            openai_api_base
+            openai_organization_id
+            openai_project_id
+            openai_use_system_role
+          ]
+        end
+
         def configuration_requirements
           %i[openai_api_key]
         end

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

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class OpenRouter
+      # Chat methods of the OpenRouter API integration
+      module Chat
+        module_function
+
+        # rubocop:disable Metrics/ParameterLists,Metrics/PerceivedComplexity
+        def render_payload(messages, tools:, temperature:, model:, stream: false, schema: nil,
+                           thinking: nil, tool_prefs: nil)
+          tool_prefs ||= {}
+          payload = {
+            model: model.id,
+            messages: format_messages(messages),
+            stream: stream
+          }
+
+          payload[:temperature] = temperature unless temperature.nil?
+          if tools.any?
+            payload[:tools] = tools.map { |_, tool| OpenAI::Tools.tool_for(tool) }
+            payload[:tool_choice] = OpenAI::Tools.build_tool_choice(tool_prefs[:choice]) unless tool_prefs[:choice].nil?
+            payload[:parallel_tool_calls] = tool_prefs[:calls] == :many unless tool_prefs[:calls].nil?
+          end
+
+          if schema
+            schema_name = schema[:name]
+            schema_def = RubyLLM::Utils.deep_dup(schema[:schema])
+            if schema_def.is_a?(Hash)
+              schema_def.delete(:strict)
+              schema_def.delete('strict')
+            end
+            strict = schema[:strict]
+            payload[:response_format] = {
+              type: 'json_schema',
+              json_schema: {
+                name: schema_name,
+                schema: schema_def,
+                strict: strict
+              }
+            }
+          end
+
+          reasoning = build_reasoning(thinking)
+          payload[:reasoning] = reasoning if reasoning
+
+          payload[:stream_options] = { include_usage: true } if stream
+          payload
+        end
+        # rubocop:enable Metrics/ParameterLists,Metrics/PerceivedComplexity
+
+        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
+
+          usage = data['usage'] || {}
+          cached_tokens = usage.dig('prompt_tokens_details', 'cached_tokens')
+          thinking_tokens = usage.dig('completion_tokens_details', 'reasoning_tokens')
+          thinking_text = extract_thinking_text(message_data)
+          thinking_signature = extract_thinking_signature(message_data)
+
+          Message.new(
+            role: :assistant,
+            content: message_data['content'],
+            thinking: Thinking.build(text: thinking_text, signature: thinking_signature),
+            tool_calls: OpenAI::Tools.parse_tool_calls(message_data['tool_calls']),
+            input_tokens: usage['prompt_tokens'],
+            output_tokens: usage['completion_tokens'],
+            cached_tokens: cached_tokens,
+            cache_creation_tokens: 0,
+            thinking_tokens: thinking_tokens,
+            model_id: data['model'],
+            raw: response
+          )
+        end
+
+        def format_messages(messages)
+          messages.map do |msg|
+            {
+              role: format_role(msg.role),
+              content: OpenAI::Media.format_content(msg.content),
+              tool_calls: OpenAI::Tools.format_tool_calls(msg.tool_calls),
+              tool_call_id: msg.tool_call_id
+            }.compact.merge(format_thinking(msg))
+          end
+        end
+
+        def format_role(role)
+          case role
+          when :system
+            @config.openai_use_system_role ? 'system' : 'developer'
+          else
+            role.to_s
+          end
+        end
+
+        def build_reasoning(thinking)
+          return nil unless thinking&.enabled?
+
+          reasoning = {}
+          reasoning[:effort] = thinking.effort if thinking.respond_to?(:effort) && thinking.effort
+          reasoning[:max_tokens] = thinking.budget if thinking.respond_to?(:budget) && thinking.budget
+          reasoning[:enabled] = true if reasoning.empty?
+          reasoning
+        end
+
+        def format_thinking(msg)
+          thinking = msg.thinking
+          return {} unless thinking && msg.role == :assistant
+
+          details = []
+          if thinking.text
+            details << {
+              type: 'reasoning.text',
+              text: thinking.text,
+              signature: thinking.signature
+            }.compact
+          elsif thinking.signature
+            details << {
+              type: 'reasoning.encrypted',
+              data: thinking.signature
+            }
+          end
+
+          details.empty? ? {} : { reasoning_details: details }
+        end
+
+        def extract_thinking_text(message_data)
+          candidate = message_data['reasoning']
+          return candidate if candidate.is_a?(String)
+
+          details = message_data['reasoning_details']
+          return nil unless details.is_a?(Array)
+
+          text = details.filter_map do |detail|
+            case detail['type']
+            when 'reasoning.text'
+              detail['text']
+            when 'reasoning.summary'
+              detail['summary']
+            end
+          end.join
+
+          text.empty? ? nil : text
+        end
+
+        def extract_thinking_signature(message_data)
+          details = message_data['reasoning_details']
+          return nil unless details.is_a?(Array)
+
+          signature = details.filter_map do |detail|
+            detail['signature'] if detail['signature'].is_a?(String)
+          end.first
+          return signature if signature
+
+          encrypted = details.find { |detail| detail['type'] == 'reasoning.encrypted' && detail['data'].is_a?(String) }
+          encrypted&.dig('data')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class OpenRouter
+      # Image generation methods for the OpenRouter API integration.
+      # OpenRouter uses the chat completions endpoint for image generation
+      # instead of a dedicated images endpoint.
+      module Images
+        module_function
+
+        def images_url
+          'chat/completions'
+        end
+
+        def render_image_payload(prompt, model:, size:)
+          RubyLLM.logger.debug { "Ignoring size #{size}. OpenRouter image generation does not support size parameter." }
+          {
+            model: model,
+            messages: [
+              {
+                role: 'user',
+                content: prompt
+              }
+            ],
+            modalities: %w[image text]
+          }
+        end
+
+        def parse_image_response(response, model:)
+          data = response.body
+          message = data.dig('choices', 0, 'message')
+
+          unless message&.key?('images') && message['images']&.any?
+            raise Error.new(nil, 'Unexpected response format from OpenRouter image generation API')
+          end
+
+          image_data = message['images'].first
+          image_url = image_data.dig('image_url', 'url') || image_data['url']
+
+          raise Error.new(nil, 'No image URL found in OpenRouter response') unless image_url
+
+          build_image_from_url(image_url, model)
+        end
+
+        def build_image_from_url(image_url, model)
+          if image_url.start_with?('data:')
+            # Parse data URL format: data:image/png;base64,<data>
+            match = image_url.match(/^data:([^;]+);base64,(.+)$/)
+            raise Error.new(nil, 'Invalid data URL format from OpenRouter') unless match
+
+            Image.new(
+              data: match[2],
+              mime_type: match[1],
+              model_id: model
+            )
+          else
+            # Regular URL
+            Image.new(
+              url: image_url,
+              mime_type: 'image/png',
+              model_id: model
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class OpenRouter
+      # Streaming methods of the OpenRouter API integration
+      module Streaming
+        module_function
+
+        def stream_url
+          completion_url
+        end
+
+        def build_chunk(data)
+          usage = data['usage'] || {}
+          cached_tokens = usage.dig('prompt_tokens_details', 'cached_tokens')
+          delta = data.dig('choices', 0, 'delta') || {}
+
+          Chunk.new(
+            role: :assistant,
+            model_id: data['model'],
+            content: delta['content'],
+            thinking: Thinking.build(
+              text: extract_thinking_text(delta),
+              signature: extract_thinking_signature(delta)
+            ),
+            tool_calls: OpenAI::Tools.parse_tool_calls(delta['tool_calls'], parse_arguments: false),
+            input_tokens: usage['prompt_tokens'],
+            output_tokens: usage['completion_tokens'],
+            cached_tokens: cached_tokens,
+            cache_creation_tokens: 0,
+            thinking_tokens: usage.dig('completion_tokens_details', 'reasoning_tokens')
+          )
+        end
+
+        def parse_streaming_error(data)
+          OpenAI::Streaming.parse_streaming_error(data)
+        end
+
+        def extract_thinking_text(delta)
+          candidate = delta['reasoning']
+          return candidate if candidate.is_a?(String)
+
+          details = delta['reasoning_details']
+          return nil unless details.is_a?(Array)
+
+          text = details.filter_map do |detail|
+            case detail['type']
+            when 'reasoning.text'
+              detail['text']
+            when 'reasoning.summary'
+              detail['summary']
+            end
+          end.join
+
+          text.empty? ? nil : text
+        end
+
+        def extract_thinking_signature(delta)
+          details = delta['reasoning_details']
+          return nil unless details.is_a?(Array)
+
+          signature = details.filter_map do |detail|
+            detail['signature'] if detail['signature'].is_a?(String)
+          end.first
+          return signature if signature
+
+          encrypted = details.find { |detail| detail['type'] == 'reasoning.encrypted' && detail['data'].is_a?(String) }
+          encrypted&.dig('data')
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/openrouter.rb

@@ -4,10 +4,13 @@ module RubyLLM
   module Providers
     # OpenRouter API integration.
     class OpenRouter < OpenAI
+      include OpenRouter::Chat
       include OpenRouter::Models
+      include OpenRouter::Streaming
+      include OpenRouter::Images
 
       def api_base
-        'https://openrouter.ai/api/v1'
+        @config.openrouter_api_base || 'https://openrouter.ai/api/v1'
       end
 
       def headers
@@ -16,7 +19,40 @@ module RubyLLM
         }
       end
 
+      def parse_error(response)
+        return if response.body.empty?
+
+        body = try_parse_json(response.body)
+        case body
+        when Hash
+          parse_error_part_message body
+        when Array
+          body.map do |part|
+            parse_error_part_message part
+          end.join('. ')
+        else
+          body
+        end
+      end
+
+      private
+
+      def parse_error_part_message(part)
+        message = part.dig('error', 'message')
+        raw = try_parse_json(part.dig('error', 'metadata', 'raw'))
+        return message unless raw.is_a?(Hash)
+
+        raw_message = raw.dig('error', 'message')
+        return [message, raw_message].compact.join(' - ') if raw_message
+
+        message
+      end
+
       class << self
+        def configuration_options
+          %i[openrouter_api_key openrouter_api_base]
+        end
+
         def configuration_requirements
           %i[openrouter_api_key]
         end

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

@@ -3,63 +3,55 @@
 module RubyLLM
   module Providers
     class Perplexity
-      # Determines capabilities and pricing for Perplexity models
+      # Provider-level capability checks and narrow registry fallbacks.
       module Capabilities
         module_function
 
-        def context_window_for(model_id)
-          case model_id
-          when /sonar-pro/ then 200_000
-          else 128_000
-          end
-        end
+        PRICES = {
+          sonar: { input: 1.0, output: 1.0 },
+          sonar_pro: { input: 3.0, output: 15.0 },
+          sonar_reasoning: { input: 1.0, output: 5.0 },
+          sonar_reasoning_pro: { input: 2.0, output: 8.0 },
+          sonar_deep_research: {
+            input: 2.0,
+            output: 8.0,
+            reasoning_output: 3.0
+          }
+        }.freeze
 
-        def max_tokens_for(model_id)
-          case model_id
-          when /sonar-(?:pro|reasoning-pro)/ then 8_192
-          else 4_096
-          end
+        def supports_tool_choice?(_model_id)
+          false
         end
 
-        def input_price_for(model_id)
-          PRICES.dig(model_family(model_id), :input) || 1.0
+        def supports_tool_parallel_control?(_model_id)
+          false
         end
 
-        def output_price_for(model_id)
-          PRICES.dig(model_family(model_id), :output) || 1.0
+        def context_window_for(model_id)
+          model_id.match?(/sonar-pro/) ? 200_000 : 128_000
         end
 
-        def supports_vision?(model_id)
-          case model_id
-          when /sonar-reasoning-pro/, /sonar-reasoning/, /sonar-pro/, /sonar/ then true
-          else false
-          end
+        def max_tokens_for(model_id)
+          model_id.match?(/sonar-(?:pro|reasoning-pro)/) ? 8_192 : 4_096
         end
 
-        def supports_functions?(_model_id)
-          false
+        def critical_capabilities_for(model_id)
+          capabilities = []
+          capabilities << 'vision' if model_id.match?(/sonar(?:-pro|-reasoning(?:-pro)?)?$/)
+          capabilities << 'reasoning' if model_id.match?(/reasoning|deep-research/)
+          capabilities
         end
 
-        def supports_json_mode?(_model_id)
-          true
-        end
+        def pricing_for(model_id)
+          prices = PRICES.fetch(model_family(model_id), { input: 1.0, output: 1.0 })
 
-        def format_display_name(model_id)
-          case model_id
-          when 'sonar' then 'Sonar'
-          when 'sonar-pro' then 'Sonar Pro'
-          when 'sonar-reasoning' then 'Sonar Reasoning'
-          when 'sonar-reasoning-pro' then 'Sonar Reasoning Pro'
-          when 'sonar-deep-research' then 'Sonar Deep Research'
-          else
-            model_id.split('-')
-                    .map(&:capitalize)
-                    .join(' ')
-          end
-        end
+          standard = {
+            input_per_million: prices[:input],
+            output_per_million: prices[:output]
+          }
+          standard[:reasoning_output_per_million] = prices[:reasoning_output] if prices[:reasoning_output]
 
-        def model_type(_model_id)
-          'chat'
+          { text_tokens: { standard: standard } }
         end
 
         def model_family(model_id)
@@ -73,64 +65,7 @@ module RubyLLM
           end
         end
 
-        def modalities_for(_model_id)
-          {
-            input: ['text'],
-            output: ['text']
-          }
-        end
-
-        def capabilities_for(model_id)
-          capabilities = %w[streaming json_mode]
-          capabilities << 'vision' if supports_vision?(model_id)
-          capabilities
-        end
-
-        def pricing_for(model_id)
-          family = model_family(model_id)
-          prices = PRICES.fetch(family, { input: 1.0, output: 1.0 })
-
-          standard_pricing = {
-            input_per_million: prices[:input],
-            output_per_million: prices[:output]
-          }
-
-          standard_pricing[:citation_per_million] = prices[:citation] if prices[:citation]
-          standard_pricing[:reasoning_per_million] = prices[:reasoning] if prices[:reasoning]
-          standard_pricing[:search_per_thousand] = prices[:search_queries] if prices[:search_queries]
-
-          {
-            text_tokens: {
-              standard: standard_pricing
-            }
-          }
-        end
-
-        PRICES = {
-          sonar: {
-            input: 1.0,
-            output: 1.0
-          },
-          sonar_pro: {
-            input: 3.0,
-            output: 15.0
-          },
-          sonar_reasoning: {
-            input: 1.0,
-            output: 5.0
-          },
-          sonar_reasoning_pro: {
-            input: 2.0,
-            output: 8.0
-          },
-          sonar_deep_research: {
-            input: 2.0,
-            output: 8.0,
-            citation: 2.0,
-            reasoning: 3.0,
-            search_queries: 5.0
-          }
-        }.freeze
+        module_function :context_window_for, :max_tokens_for, :critical_capabilities_for, :pricing_for, :model_family
       end
     end
   end

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

@@ -5,33 +5,31 @@ module RubyLLM
     class Perplexity
       # Models methods of the Perplexity API integration
       module Models
+        MODEL_IDS = %w[
+          sonar
+          sonar-pro
+          sonar-reasoning
+          sonar-reasoning-pro
+          sonar-deep-research
+        ].freeze
+
         def list_models(**)
           slug = 'perplexity'
-          capabilities = Perplexity::Capabilities
-          parse_list_models_response(nil, slug, capabilities)
+          parse_list_models_response(nil, slug, Perplexity::Capabilities)
         end
 
         def parse_list_models_response(_response, slug, capabilities)
-          [
-            create_model_info('sonar', slug, capabilities),
-            create_model_info('sonar-pro', slug, capabilities),
-            create_model_info('sonar-reasoning', slug, capabilities),
-            create_model_info('sonar-reasoning-pro', slug, capabilities),
-            create_model_info('sonar-deep-research', slug, capabilities)
-          ]
+          MODEL_IDS.map { |id| create_model_info(id, slug, capabilities) }
         end
 
         def create_model_info(id, slug, capabilities)
           Model::Info.new(
             id: id,
-            name: capabilities.format_display_name(id),
+            name: id,
             provider: slug,
-            family: capabilities.model_family(id).to_s,
-            created_at: Time.now,
             context_window: capabilities.context_window_for(id),
             max_output_tokens: capabilities.max_tokens_for(id),
-            modalities: capabilities.modalities_for(id),
-            capabilities: capabilities.capabilities_for(id),
+            capabilities: capabilities.critical_capabilities_for(id),
             pricing: capabilities.pricing_for(id),
             metadata: {}
           )

data/lib/ruby_llm/providers/perplexity.rb

@@ -23,6 +23,10 @@ module RubyLLM
           Perplexity::Capabilities
         end
 
+        def configuration_options
+          %i[perplexity_api_key]
+        end
+
         def configuration_requirements
           %i[perplexity_api_key]
         end

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

@@ -56,7 +56,7 @@ module RubyLLM
 
           all_models
         rescue StandardError => e
-          RubyLLM.logger.debug "Error fetching Vertex AI models: #{e.message}"
+          RubyLLM.logger.debug { "Error fetching Vertex AI models: #{e.message}" }
           build_known_models
         end