dify_llm 1.6.4

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class OpenAI
+      # Handles formatting of media content (images, audio) for OpenAI APIs
+      module Media
+        module_function
+
+        def format_content(content)
+          return content.to_json if content.is_a?(Hash) || content.is_a?(Array)
+          return content unless content.is_a?(Content)
+
+          parts = []
+          parts << format_text(content.text) if content.text
+
+          content.attachments.each do |attachment|
+            case attachment.type
+            when :image
+              parts << format_image(attachment)
+            when :pdf
+              parts << format_pdf(attachment)
+            when :audio
+              parts << format_audio(attachment)
+            when :text
+              parts << format_text_file(attachment)
+            else
+              raise UnsupportedAttachmentError, attachment.type
+            end
+          end
+
+          parts
+        end
+
+        def format_image(image)
+          {
+            type: 'image_url',
+            image_url: {
+              url: image.url? ? image.source : image.for_llm
+            }
+          }
+        end
+
+        def format_pdf(pdf)
+          {
+            type: 'file',
+            file: {
+              filename: pdf.filename,
+              file_data: pdf.for_llm
+            }
+          }
+        end
+
+        def format_text_file(text_file)
+          {
+            type: 'text',
+            text: text_file.for_llm
+          }
+        end
+
+        def format_audio(audio)
+          {
+            type: 'input_audio',
+            input_audio: {
+              data: audio.encoded,
+              format: audio.format
+            }
+          }
+        end
+
+        def format_text(text)
+          {
+            type: 'text',
+            text: text
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class OpenAI
+      # Models methods of the OpenAI 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|
+            model_id = model_data['id']
+
+            Model::Info.new(
+              id: model_id,
+              name: capabilities.format_display_name(model_id),
+              provider: slug,
+              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_data['object'],
+                owned_by: model_data['owned_by']
+              }
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class OpenAI
+      # Streaming methods of the OpenAI API integration
+      module Streaming
+        module_function
+
+        def stream_url
+          completion_url
+        end
+
+        def build_chunk(data)
+          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
+
+        def parse_streaming_error(data)
+          error_data = JSON.parse(data)
+          return unless error_data['error']
+
+          case error_data.dig('error', 'type')
+          when 'server_error'
+            [500, error_data['error']['message']]
+          when 'rate_limit_exceeded', 'insufficient_quota'
+            [429, error_data['error']['message']]
+          else
+            [400, error_data['error']['message']]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class OpenAI
+      # Tools methods of the OpenAI API integration
+      module Tools
+        module_function
+
+        def tool_for(tool)
+          {
+            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)
+          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_call_arguments(tool_call)
+          arguments = tool_call.dig('function', 'arguments')
+
+          if arguments.nil? || arguments.empty?
+            {}
+          else
+            JSON.parse(arguments)
+          end
+        end
+
+        def parse_tool_calls(tool_calls, parse_arguments: true)
+          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
+                             parse_tool_call_arguments(tc)
+                           else
+                             tc.dig('function', 'arguments')
+                           end
+              )
+            ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/openai.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    # OpenAI API integration.
+    class OpenAI < Provider
+      include OpenAI::Chat
+      include OpenAI::Embeddings
+      include OpenAI::Models
+      include OpenAI::Streaming
+      include OpenAI::Tools
+      include OpenAI::Images
+      include OpenAI::Media
+
+      def api_base
+        @config.openai_api_base || 'https://api.openai.com/v1'
+      end
+
+      def headers
+        {
+          'Authorization' => "Bearer #{@config.openai_api_key}",
+          'OpenAI-Organization' => @config.openai_organization_id,
+          'OpenAI-Project' => @config.openai_project_id
+        }.compact
+      end
+
+      def maybe_normalize_temperature(temperature, model)
+        OpenAI::Capabilities.normalize_temperature(temperature, model.id)
+      end
+
+      class << self
+        def capabilities
+          OpenAI::Capabilities
+        end
+
+        def configuration_requirements
+          %i[openai_api_key]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class 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
+            modalities = {
+              input: Array(model_data.dig('architecture', 'input_modalities')),
+              output: Array(model_data.dig('architecture', 'output_modalities'))
+            }
+
+            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
+
+            capabilities = supported_parameters_to_capabilities(model_data['supported_parameters'])
+
+            Model::Info.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 = []
+          capabilities << 'streaming'
+          capabilities << 'function_calling' if params.include?('tools') || params.include?('tool_choice')
+          capabilities << 'structured_output' if params.include?('response_format')
+          capabilities << 'batch' if params.include?('batch')
+          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,26 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    # OpenRouter API integration.
+    class OpenRouter < OpenAI
+      include OpenRouter::Models
+
+      def api_base
+        'https://openrouter.ai/api/v1'
+      end
+
+      def headers
+        {
+          'Authorization' => "Bearer #{@config.openrouter_api_key}"
+        }
+      end
+
+      class << self
+        def configuration_requirements
+          %i[openrouter_api_key]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Perplexity
+      # Determines capabilities and pricing for Perplexity models
+      module Capabilities
+        module_function
+
+        def context_window_for(model_id)
+          case model_id
+          when /sonar-pro/ then 200_000
+          else 128_000
+          end
+        end
+
+        def max_tokens_for(model_id)
+          case model_id
+          when /sonar-(?:pro|reasoning-pro)/ then 8_192
+          else 4_096
+          end
+        end
+
+        def input_price_for(model_id)
+          PRICES.dig(model_family(model_id), :input) || 1.0
+        end
+
+        def output_price_for(model_id)
+          PRICES.dig(model_family(model_id), :output) || 1.0
+        end
+
+        def supports_vision?(model_id)
+          case model_id
+          when /sonar-reasoning-pro/, /sonar-reasoning/, /sonar-pro/, /sonar/ then true
+          else false
+          end
+        end
+
+        def supports_functions?(_model_id)
+          false
+        end
+
+        def supports_json_mode?(_model_id)
+          true
+        end
+
+        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
+
+        def model_type(_model_id)
+          'chat'
+        end
+
+        def model_family(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 :unknown
+          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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Perplexity
+      # Chat formatting for Perplexity provider
+      module Chat
+        module_function
+
+        def format_role(role)
+          role.to_s
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Perplexity
+      # Models methods of the Perplexity API integration
+      module Models
+        def list_models(**)
+          slug = 'perplexity'
+          capabilities = Perplexity::Capabilities
+          parse_list_models_response(nil, slug, 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)
+          ]
+        end
+
+        def create_model_info(id, slug, capabilities)
+          Model::Info.new(
+            id: id,
+            name: capabilities.format_display_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),
+            pricing: capabilities.pricing_for(id),
+            metadata: {}
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/perplexity.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    # Perplexity API integration.
+    class Perplexity < OpenAI
+      include Perplexity::Chat
+      include Perplexity::Models
+
+      def api_base
+        'https://api.perplexity.ai'
+      end
+
+      def headers
+        {
+          'Authorization' => "Bearer #{@config.perplexity_api_key}",
+          'Content-Type' => 'application/json'
+        }
+      end
+
+      class << self
+        def capabilities
+          Perplexity::Capabilities
+        end
+
+        def configuration_requirements
+          %i[perplexity_api_key]
+        end
+      end
+
+      def parse_error(response)
+        body = response.body
+        return if body.empty?
+
+        # If response is HTML (Perplexity returns HTML for auth errors)
+        if body.include?('<html>') && body.include?('<title>')
+          title_match = body.match(%r{<title>(.+?)</title>})
+          if title_match
+            message = title_match[1]
+            message = message.sub(/^\d+\s+/, '')
+            return message
+          end
+        end
+        super
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class VertexAI
+      # Chat methods for the Vertex AI implementation
+      module Chat
+        def completion_url
+          "projects/#{@config.vertexai_project_id}/locations/#{@config.vertexai_location}/publishers/google/models/#{@model}:generateContent" # rubocop:disable Layout/LineLength
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class VertexAI
+      # Embeddings methods for the Vertex AI implementation
+      module Embeddings
+        module_function
+
+        def embedding_url(model:)
+          "projects/#{@config.vertexai_project_id}/locations/#{@config.vertexai_location}/publishers/google/models/#{model}:predict" # rubocop:disable Layout/LineLength
+        end
+
+        def render_embedding_payload(text, model:, dimensions:) # rubocop:disable Lint/UnusedMethodArgument
+          {
+            instances: [text].flatten.map { |t| { content: t.to_s } }
+          }.tap do |payload|
+            payload[:parameters] = { outputDimensionality: dimensions } if dimensions
+          end
+        end
+
+        def parse_embedding_response(response, model:, text:)
+          predictions = response.body['predictions']
+          vectors = predictions&.map { |p| p.dig('embeddings', 'values') }
+          vectors = vectors.first if vectors&.length == 1 && !text.is_a?(Array)
+
+          Embedding.new(vectors:, model:, input_tokens: 0)
+        end
+      end
+    end
+  end
+end