dify_llm 1.6.4

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Gemini
+      # Models methods for the Gemini API integration
+      module Models
+        module_function
+
+        def models_url
+          'models'
+        end
+
+        def parse_list_models_response(response, slug, capabilities)
+          Array(response.body['models']).map do |model_data|
+            model_id = model_data['name'].gsub('models/', '')
+
+            Model::Info.new(
+              id: model_id,
+              name: model_data['displayName'],
+              provider: slug,
+              family: capabilities.model_family(model_id),
+              created_at: nil,
+              context_window: model_data['inputTokenLimit'] || capabilities.context_window_for(model_id),
+              max_output_tokens: model_data['outputTokenLimit'] || 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: {
+                version: model_data['version'],
+                description: model_data['description'],
+                supported_generation_methods: model_data['supportedGenerationMethods']
+              }
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Gemini
+      # Streaming methods for the Gemini API implementation
+      module Streaming
+        def stream_url
+          "models/#{@model}:streamGenerateContent?alt=sse"
+        end
+
+        def build_chunk(data)
+          Chunk.new(
+            role: :assistant,
+            model_id: extract_model_id(data),
+            content: extract_content(data),
+            input_tokens: extract_input_tokens(data),
+            output_tokens: extract_output_tokens(data),
+            tool_calls: extract_tool_calls(data)
+          )
+        end
+
+        private
+
+        def extract_model_id(data)
+          data['modelVersion']
+        end
+
+        def extract_content(data)
+          return nil unless data['candidates']&.any?
+
+          candidate = data['candidates'][0]
+          parts = candidate.dig('content', 'parts')
+          return nil unless parts
+
+          text_parts = parts.select { |p| p['text'] }
+          text_parts.map { |p| p['text'] }.join if text_parts.any?
+        end
+
+        def extract_input_tokens(data)
+          data.dig('usageMetadata', 'promptTokenCount')
+        end
+
+        def extract_output_tokens(data)
+          candidates = data.dig('usageMetadata', 'candidatesTokenCount') || 0
+          thoughts = data.dig('usageMetadata', 'thoughtsTokenCount') || 0
+          total = candidates + thoughts
+          total.positive? ? total : nil
+        end
+
+        def parse_streaming_error(data)
+          error_data = JSON.parse(data)
+          [error_data['error']['code'], error_data['error']['message']]
+        rescue JSON::ParserError => e
+          RubyLLM.logger.debug "Failed to parse streaming error: #{e.message}"
+          [500, "Failed to parse error: #{data}"]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Gemini
+      # Tools methods for the Gemini API implementation
+      module Tools
+        def format_tools(tools)
+          return [] if tools.empty?
+
+          [{
+            functionDeclarations: tools.values.map { |tool| function_declaration_for(tool) }
+          }]
+        end
+
+        def extract_tool_calls(data)
+          return nil unless data
+
+          candidate = data.is_a?(Hash) ? data.dig('candidates', 0) : nil
+          return nil unless candidate
+
+          parts = candidate.dig('content', 'parts')
+          return nil unless parts.is_a?(Array)
+
+          function_call_part = parts.find { |p| p['functionCall'] }
+          return nil unless function_call_part
+
+          function_data = function_call_part['functionCall']
+          return nil unless function_data
+
+          id = SecureRandom.uuid
+
+          {
+            id => ToolCall.new(
+              id: id,
+              name: function_data['name'],
+              arguments: function_data['args']
+            )
+          }
+        end
+
+        private
+
+        def function_declaration_for(tool)
+          {
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.parameters.any? ? format_parameters(tool.parameters) : nil
+          }.compact
+        end
+
+        def format_parameters(parameters)
+          {
+            type: 'OBJECT',
+            properties: parameters.transform_values do |param|
+              {
+                type: param_type_for_gemini(param.type),
+                description: param.description
+              }.compact
+            end,
+            required: parameters.select { |_, p| p.required }.keys.map(&:to_s)
+          }
+        end
+
+        def param_type_for_gemini(type)
+          case type.to_s.downcase
+          when 'integer', 'number', 'float' then 'NUMBER'
+          when 'boolean' then 'BOOLEAN'
+          when 'array' then 'ARRAY'
+          when 'object' then 'OBJECT'
+          else 'STRING'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/gemini.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    # Native Gemini API implementation
+    class Gemini < Provider
+      include Gemini::Chat
+      include Gemini::Embeddings
+      include Gemini::Images
+      include Gemini::Models
+      include Gemini::Streaming
+      include Gemini::Tools
+      include Gemini::Media
+
+      def api_base
+        'https://generativelanguage.googleapis.com/v1beta'
+      end
+
+      def headers
+        {
+          'x-goog-api-key' => @config.gemini_api_key
+        }
+      end
+
+      class << self
+        def capabilities
+          Gemini::Capabilities
+        end
+
+        def configuration_requirements
+          %i[gemini_api_key]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class GPUStack
+      # Chat methods of the GPUStack API integration
+      module Chat
+        module_function
+
+        def format_messages(messages)
+          messages.map do |msg|
+            {
+              role: format_role(msg.role),
+              content: GPUStack::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)
+          role.to_s
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class GPUStack
+      # Handles formatting of media content (images, audio) for GPUStack APIs
+      module Media
+        extend OpenAI::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 << GPUStack::Media.format_image(attachment)
+            when :text
+              parts << format_text_file(attachment)
+            else
+              raise UnsupportedAttachmentError, attachment.mime_type
+            end
+          end
+
+          parts
+        end
+
+        def format_image(image)
+          {
+            type: 'image_url',
+            image_url: {
+              url: image.for_llm,
+              detail: 'auto'
+            }
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class GPUStack
+      # Models methods of the GPUStack API integration
+      module Models
+        module_function
+
+        def models_url
+          'models'
+        end
+
+        def parse_list_models_response(response, slug, _capabilities)
+          items = response.body['items'] || []
+          items.map do |model|
+            Model::Info.new(
+              id: model['name'],
+              name: model['name'],
+              created_at: model['created_at'] ? Time.parse(model['created_at']) : nil,
+              provider: slug,
+              family: 'gpustack',
+              metadata: {
+                description: model['description'],
+                source: model['source'],
+                huggingface_repo_id: model['huggingface_repo_id'],
+                ollama_library_model_name: model['ollama_library_model_name'],
+                backend: model['backend'],
+                meta: model['meta'],
+                categories: model['categories']
+              },
+              context_window: model.dig('meta', 'n_ctx'),
+              max_output_tokens: model.dig('meta', 'n_ctx'),
+              capabilities: build_capabilities(model),
+              modalities: build_modalities(model),
+              pricing: {}
+            )
+          end
+        end
+
+        private
+
+        def determine_model_type(model)
+          return 'embedding' if model['categories']&.include?('embedding')
+          return 'chat' if model['categories']&.include?('llm')
+
+          'other'
+        end
+
+        def build_capabilities(model) # rubocop:disable Metrics/PerceivedComplexity
+          capabilities = []
+
+          # Add streaming by default for LLM models
+          capabilities << 'streaming' if model['categories']&.include?('llm')
+
+          # Map GPUStack metadata to standard capabilities
+          capabilities << 'function_calling' if model.dig('meta', 'support_tool_calls')
+          capabilities << 'vision' if model.dig('meta', 'support_vision')
+          capabilities << 'reasoning' if model.dig('meta', 'support_reasoning')
+
+          # GPUStack models generally support structured output and json mode
+          capabilities << 'structured_output' if model['categories']&.include?('llm')
+          capabilities << 'json_mode' if model['categories']&.include?('llm')
+
+          capabilities
+        end
+
+        def build_modalities(model)
+          input_modalities = []
+          output_modalities = []
+
+          if model['categories']&.include?('llm')
+            input_modalities << 'text'
+            input_modalities << 'image' if model.dig('meta', 'support_vision')
+            input_modalities << 'audio' if model.dig('meta', 'support_audio')
+            output_modalities << 'text'
+          elsif model['categories']&.include?('embedding')
+            input_modalities << 'text'
+            output_modalities << 'embeddings'
+          end
+
+          {
+            input: input_modalities,
+            output: output_modalities
+          }
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/gpustack.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    # GPUStack API integration based on Ollama.
+    class GPUStack < OpenAI
+      include GPUStack::Chat
+      include GPUStack::Models
+      include GPUStack::Media
+
+      def api_base
+        @config.gpustack_api_base
+      end
+
+      def headers
+        return {} unless @config.gpustack_api_key
+
+        {
+          'Authorization' => "Bearer #{@config.gpustack_api_key}"
+        }
+      end
+
+      class << self
+        def local?
+          true
+        end
+
+        def configuration_requirements
+          %i[gpustack_api_base]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Mistral
+      # Determines capabilities for Mistral models
+      module Capabilities
+        module_function
+
+        def supports_streaming?(model_id)
+          !model_id.match?(/embed|moderation|ocr|transcriptions/)
+        end
+
+        def supports_tools?(model_id)
+          !model_id.match?(/embed|moderation|ocr|voxtral|transcriptions|mistral-(tiny|small)-(2312|2402)/)
+        end
+
+        def supports_vision?(model_id)
+          model_id.match?(/pixtral|mistral-small-(2503|2506)|mistral-medium/)
+        end
+
+        def supports_json_mode?(model_id)
+          !model_id.match?(/embed|moderation|ocr|voxtral|transcriptions/) && supports_tools?(model_id)
+        end
+
+        def format_display_name(model_id)
+          case model_id
+          when /mistral-large/ then 'Mistral Large'
+          when /mistral-medium/ then 'Mistral Medium'
+          when /mistral-small/ then 'Mistral Small'
+          when /ministral-3b/ then 'Ministral 3B'
+          when /ministral-8b/ then 'Ministral 8B'
+          when /codestral/ then 'Codestral'
+          when /pixtral-large/ then 'Pixtral Large'
+          when /pixtral-12b/ then 'Pixtral 12B'
+          when /mistral-embed/ then 'Mistral Embed'
+          when /mistral-moderation/ then 'Mistral Moderation'
+          else model_id.split('-').map(&:capitalize).join(' ')
+          end
+        end
+
+        def model_family(model_id)
+          case model_id
+          when /mistral-large/ then 'mistral-large'
+          when /mistral-medium/ then 'mistral-medium'
+          when /mistral-small/ then 'mistral-small'
+          when /ministral/ then 'ministral'
+          when /codestral/ then 'codestral'
+          when /pixtral/ then 'pixtral'
+          when /mistral-embed/ then 'mistral-embed'
+          when /mistral-moderation/ then 'mistral-moderation'
+          else 'mistral'
+          end
+        end
+
+        def context_window_for(_model_id)
+          32_768
+        end
+
+        def max_tokens_for(_model_id)
+          8192
+        end
+
+        def modalities_for(model_id)
+          case model_id
+          when /pixtral/
+            {
+              input: %w[text image],
+              output: ['text']
+            }
+          when /embed/
+            {
+              input: ['text'],
+              output: ['embeddings']
+            }
+          else
+            {
+              input: ['text'],
+              output: ['text']
+            }
+          end
+        end
+
+        def capabilities_for(model_id) # rubocop:disable Metrics/PerceivedComplexity
+          case model_id
+          when /moderation/ then ['moderation']
+          when /voxtral.*transcribe/ then ['transcription']
+          when /ocr/ then ['vision']
+          else
+            capabilities = []
+            capabilities << 'streaming' if supports_streaming?(model_id)
+            capabilities << 'function_calling' if supports_tools?(model_id)
+            capabilities << 'structured_output' if supports_json_mode?(model_id)
+            capabilities << 'vision' if supports_vision?(model_id)
+
+            capabilities << 'reasoning' if model_id.match?(/magistral/)
+            capabilities << 'batch' unless model_id.match?(/voxtral|ocr|embed|moderation/)
+            capabilities << 'fine_tuning' if model_id.match?(/mistral-(small|medium|large)|devstral/)
+            capabilities << 'distillation' if model_id.match?(/ministral/)
+            capabilities << 'predicted_outputs' if model_id.match?(/codestral/)
+
+            capabilities.uniq
+          end
+        end
+
+        def pricing_for(_model_id)
+          {
+            input: 0.0,
+            output: 0.0
+          }
+        end
+
+        def release_date_for(model_id)
+          case model_id
+          when 'open-mistral-7b', 'mistral-tiny' then '2023-09-27'
+          when 'mistral-medium-2312', 'mistral-small-2312', 'mistral-small',
+               'open-mixtral-8x7b', 'mistral-tiny-2312' then '2023-12-11'
+
+          when 'mistral-embed' then '2024-01-11'
+          when 'mistral-large-2402', 'mistral-small-2402' then '2024-02-26'
+          when 'open-mixtral-8x22b', 'open-mixtral-8x22b-2404' then '2024-04-17'
+          when 'codestral-2405' then '2024-05-22'
+          when 'codestral-mamba-2407', 'codestral-mamba-latest', 'open-codestral-mamba' then '2024-07-16'
+          when 'open-mistral-nemo', 'open-mistral-nemo-2407', 'mistral-tiny-2407',
+               'mistral-tiny-latest' then '2024-07-18'
+          when 'mistral-large-2407' then '2024-07-24'
+          when 'pixtral-12b-2409', 'pixtral-12b-latest', 'pixtral-12b' then '2024-09-17'
+          when 'mistral-small-2409' then '2024-09-18'
+          when 'ministral-3b-2410', 'ministral-3b-latest', 'ministral-8b-2410',
+               'ministral-8b-latest' then '2024-10-16'
+          when 'pixtral-large-2411', 'pixtral-large-latest', 'mistral-large-pixtral-2411' then '2024-11-12'
+          when 'mistral-large-2411', 'mistral-large-latest', 'mistral-large' then '2024-11-20'
+          when 'codestral-2411-rc5', 'mistral-moderation-2411', 'mistral-moderation-latest' then '2024-11-26'
+          when 'codestral-2412' then '2024-12-17'
+
+          when 'mistral-small-2501' then '2025-01-13'
+          when 'codestral-2501' then '2025-01-14'
+          when 'mistral-saba-2502', 'mistral-saba-latest' then '2025-02-18'
+          when 'mistral-small-2503' then '2025-03-03'
+          when 'mistral-ocr-2503' then '2025-03-21'
+          when 'mistral-medium', 'mistral-medium-latest', 'mistral-medium-2505' then '2025-05-06'
+          when 'codestral-embed', 'codestral-embed-2505' then '2025-05-21'
+          when 'mistral-ocr-2505', 'mistral-ocr-latest' then '2025-05-23'
+          when 'devstral-small-2505' then '2025-05-28'
+          when 'mistral-small-2506', 'mistral-small-latest', 'magistral-medium-2506',
+               'magistral-medium-latest' then '2025-06-10'
+          when 'devstral-small-2507', 'devstral-small-latest', 'devstral-medium-2507',
+               'devstral-medium-latest' then '2025-07-09'
+          when 'codestral-2508', 'codestral-latest' then '2025-08-30'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Mistral
+      # Chat methods for Mistral API
+      module Chat
+        module_function
+
+        def format_role(role)
+          role.to_s
+        end
+
+        # rubocop:disable Metrics/ParameterLists
+        def render_payload(messages, tools:, temperature:, model:, stream: false, schema: nil)
+          payload = super
+          payload.delete(:stream_options)
+          payload
+        end
+        # rubocop:enable Metrics/ParameterLists
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Mistral
+      # Embeddings methods for Mistral API
+      module Embeddings
+        module_function
+
+        def embedding_url(...)
+          'embeddings'
+        end
+
+        def render_embedding_payload(text, model:, dimensions:) # rubocop:disable Lint/UnusedMethodArgument
+          {
+            model: model,
+            input: text
+          }
+        end
+
+        def parse_embedding_response(response, model:, text:)
+          data = response.body
+          input_tokens = data.dig('usage', 'prompt_tokens') || 0
+          vectors = data['data'].map { |d| d['embedding'] }
+
+          vectors = vectors.first if vectors.length == 1 && !text.is_a?(Array)
+
+          Embedding.new(vectors:, model:, input_tokens:)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Mistral
+      # Model information for Mistral
+      module Models
+        module_function
+
+        def models_url
+          'models'
+        end
+
+        def headers(config)
+          {
+            'Authorization' => "Bearer #{config.mistral_api_key}"
+          }
+        end
+
+        def parse_list_models_response(response, slug, capabilities)
+          Array(response.body['data']).map do |model_data|
+            model_id = model_data['id']
+
+            release_date = capabilities.release_date_for(model_id)
+            created_at = release_date ? Time.parse(release_date) : nil
+
+            Model::Info.new(
+              id: model_id,
+              name: capabilities.format_display_name(model_id),
+              provider: slug,
+              family: capabilities.model_family(model_id),
+              created_at: created_at,
+              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