ruby_llm_community 0.0.1 → 0.0.3

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

@@ -0,0 +1,66 @@
+# 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),
+            cached_tokens: extract_cached_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 extract_cached_tokens(data)
+          data.dig('usageMetadata', 'cachedContentTokenCount')
+        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,82 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Gemini
+      # Tools methods for the Gemini API implementation
+      module Tools
+        # Format tools for Gemini API
+        def format_tools(tools)
+          return [] if tools.empty?
+
+          [{
+            functionDeclarations: tools.values.map { |tool| function_declaration_for(tool) }
+          }]
+        end
+
+        # Extract tool calls from response data
+        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
+
+        # Format a single tool for Gemini API
+        def function_declaration_for(tool)
+          {
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.parameters.any? ? format_parameters(tool.parameters) : nil
+          }.compact
+        end
+
+        # Format tool parameters for Gemini API
+        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
+
+        # Convert RubyLLM param types to Gemini API types
+        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,17 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class GPUStack
+      # Chat methods of the GPUStack API integration
+      module Chat
+        module_function
+
+        def format_role(role)
+          # GPUStack doesn't use the new OpenAI convention for system prompts
+          role.to_s
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# 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'],
+              created_at: model['created_at'] ? Time.parse(model['created_at']) : nil,
+              display_name: "#{model['source']}/#{model['name']}",
+              provider: slug,
+              type: determine_model_type(model),
+              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'),
+              # Using context window as max tokens since it's not explicitly provided
+              max_tokens: model.dig('meta', 'n_ctx'),
+              supports_vision: model.dig('meta', 'support_vision') || false,
+              supports_functions: model.dig('meta', 'support_tool_calls') || false,
+              supports_json_mode: true, # Assuming all models support JSON mode
+              input_price_per_million: 0.0,  # Price information not available in new format
+              output_price_per_million: 0.0  # Price information not available in new format
+            )
+          end
+        end
+
+        private
+
+        def determine_model_type(model)
+          return 'embedding' if model['categories']&.include?('embedding')
+          return 'chat' if model['categories']&.include?('llm')
+
+          'other'
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/gpustack.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    # GPUStack API integration based on Ollama.
+    class GPUStack < OpenAIBase
+      include GPUStack::Chat
+      include GPUStack::Models
+
+      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,163 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Mistral
+      # Determines capabilities for Mistral models
+      module Capabilities
+        module_function
+
+        def supports_streaming?(model_id)
+          # All chat models support streaming, but not embedding/moderation/OCR/transcription
+          !model_id.match?(/embed|moderation|ocr|transcriptions/)
+        end
+
+        def supports_tools?(model_id)
+          # Most chat models support tools except embedding/moderation/OCR/voxtral/transcription
+          !model_id.match?(/embed|moderation|ocr|voxtral|transcriptions|mistral-(tiny|small)-(2312|2402)/)
+        end
+
+        def supports_vision?(model_id)
+          # Models with vision capabilities
+          model_id.match?(/pixtral|mistral-small-(2503|2506)|mistral-medium/)
+        end
+
+        def supports_json_mode?(model_id)
+          # Most chat models support JSON mode (structured output)
+          !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 # Default for most Mistral models
+        end
+
+        def max_tokens_for(_model_id)
+          8192 # Default for most Mistral models
+        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)
+
+            # Model-specific capabilities
+            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
+          # 2023 releases
+          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'
+
+          # 2024 releases
+          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'
+
+          # 2025 releases
+          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,26 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Mistral
+      # Chat methods for Mistral API
+      module Chat
+        module_function
+
+        def format_role(role)
+          # Mistral doesn't use the new OpenAI convention for system prompts
+          role.to_s
+        end
+
+        # rubocop:disable Metrics/ParameterLists
+        def render_payload(messages, tools:, temperature:, model:, stream: false, schema: nil, cache_prompts: {}) # rubocop:disable Metrics/ParameterLists
+          payload = super
+          # Mistral doesn't support stream_options
+          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,36 @@
+# 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
+          # Mistral doesn't support dimensions parameter
+          {
+            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'] }
+
+          # If we only got one embedding AND the input was a single string (not an array),
+          # return it as a single vector
+          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,49 @@
+# 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']
+
+            # Use fixed release date for Mistral models
+            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

data/lib/ruby_llm/providers/mistral.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    # Mistral API integration.
+    class Mistral < OpenAIBase
+      include Mistral::Chat
+      include Mistral::Models
+      include Mistral::Embeddings
+
+      def api_base
+        'https://api.mistral.ai/v1'
+      end
+
+      def headers
+        {
+          'Authorization' => "Bearer #{@config.mistral_api_key}"
+        }
+      end
+
+      class << self
+        def capabilities
+          Mistral::Capabilities
+        end
+
+        def configuration_requirements
+          %i[mistral_api_key]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Ollama
+      # Chat methods of the Ollama API integration
+      module Chat
+        module_function
+
+        def format_messages(messages)
+          messages.map do |msg|
+            {
+              role: format_role(msg.role),
+              content: Ollama::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)
+          # Ollama doesn't use the new OpenAI convention for system prompts
+          role.to_s
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Ollama
+      # Handles formatting of media content (images, audio) for OpenAI APIs
+      module Media
+        extend OpenAI::Media
+
+        module_function
+
+        def format_content(content)
+          # Convert Hash/Array back to JSON string for API
+          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 << Ollama::Media.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.mime_type
+            end
+          end
+
+          parts
+        end
+
+        def format_image(image)
+          {
+            type: 'image_url',
+            image_url: {
+              url: "data:#{image.mime_type};base64,#{image.encoded}",
+              detail: 'auto'
+            }
+          }
+        end
+      end
+    end
+  end
+end