ruby_llm_community 0.0.6 → 1.0.0

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

@@ -16,10 +16,10 @@ module RubyLLM
           items.map do |model|
             Model::Info.new(
               id: model['name'],
+              name: 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),
+              family: 'gpustack',
               metadata: {
                 description: model['description'],
                 source: model['source'],
@@ -30,13 +30,10 @@ module RubyLLM
                 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
+              max_output_tokens: model.dig('meta', 'n_ctx'),
+              capabilities: build_capabilities(model),
+              modalities: build_modalities(model),
+              pricing: {}
             )
           end
         end
@@ -49,6 +46,44 @@ module RubyLLM
 
           '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

data/lib/ruby_llm/providers/gpustack.rb

@@ -6,6 +6,7 @@ module RubyLLM
     class GPUStack < OpenAIBase
       include GPUStack::Chat
       include GPUStack::Models
+      include GPUStack::Media
 
       def api_base
         @config.gpustack_api_base

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

@@ -8,22 +8,18 @@ module RubyLLM
         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
 
@@ -58,11 +54,11 @@ module RubyLLM
         end
 
         def context_window_for(_model_id)
-          32_768 # Default for most Mistral models
+          32_768
         end
 
         def max_tokens_for(_model_id)
-          8192 # Default for most Mistral models
+          8192
         end
 
         def modalities_for(model_id)
@@ -97,7 +93,6 @@ module RubyLLM
             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/)
@@ -117,12 +112,10 @@ module RubyLLM
 
         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'
@@ -140,7 +133,6 @@ module RubyLLM
           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'

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

@@ -8,14 +8,12 @@ module RubyLLM
         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

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

@@ -12,7 +12,6 @@ module RubyLLM
         end
 
         def render_embedding_payload(text, model:, dimensions:) # rubocop:disable Lint/UnusedMethodArgument
-          # Mistral doesn't support dimensions parameter
           {
             model: model,
             input: text
@@ -24,8 +23,6 @@ module RubyLLM
           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:)

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

@@ -21,7 +21,6 @@ module RubyLLM
           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
 

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

@@ -19,7 +19,6 @@ module RubyLLM
         end
 
         def format_role(role)
-          # Ollama doesn't use the new OpenAI convention for system prompts
           role.to_s
         end
       end

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

@@ -3,14 +3,13 @@
 module RubyLLM
   module Providers
     class Ollama
-      # Handles formatting of media content (images, audio) for OpenAI APIs
+      # Handles formatting of media content (images, audio) for Ollama 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)
 
@@ -21,10 +20,6 @@ module RubyLLM
             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

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Ollama
+      # Models methods for the Ollama API integration
+      module Models
+        def models_url
+          'models'
+        end
+
+        def parse_list_models_response(response, slug, _capabilities)
+          data = response.body['data'] || []
+          data.map do |model|
+            Model::Info.new(
+              id: model['id'],
+              name: model['id'],
+              provider: slug,
+              family: 'ollama',
+              created_at: model['created'] ? Time.at(model['created']) : nil,
+              modalities: {
+                input: %w[text image],
+                output: %w[text]
+              },
+              capabilities: %w[streaming function_calling structured_output vision],
+              pricing: {},
+              metadata: {
+                owned_by: model['owned_by']
+              }
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/ollama.rb

@@ -6,6 +6,7 @@ module RubyLLM
     class Ollama < OpenAIBase
       include Ollama::Chat
       include Ollama::Media
+      include Ollama::Models
 
       def api_base
         @config.ollama_api_base

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

@@ -10,6 +10,7 @@ module RubyLLM
         MODEL_PATTERNS = {
           dall_e: /^dall-e/,
           chatgpt4o: /^chatgpt-4o/,
+          gpt_image: /^gpt-image/,
           gpt41: /^gpt-4\.1(?!-(?:mini|nano))/,
           gpt41_mini: /^gpt-4\.1-mini/,
           gpt41_nano: /^gpt-4\.1-nano/,
@@ -105,6 +106,7 @@ module RubyLLM
         end
 
         PRICES = {
+          gpt_image_1: { input_text: 5.0, input_image: 10.0, output: 8.0, cached_input: 0.5 }, # rubocop:disable Naming/VariableNumber
           gpt41: { input: 2.0, output: 8.0, cached_input: 0.5 },
           gpt41_mini: { input: 0.4, output: 1.6, cached_input: 0.1 },
           gpt41_nano: { input: 0.1, output: 0.4 },
@@ -168,7 +170,7 @@ module RubyLLM
           when /embedding/ then 'embedding'
           when /^tts|whisper|gpt4o_(?:mini_)?(?:transcribe|tts)$/ then 'audio'
           when 'moderation' then 'moderation'
-          when /dall/ then 'image'
+          when /dall-e|gpt-image/ then 'image'
           else 'chat'
           end
         end
@@ -235,20 +237,11 @@ module RubyLLM
 
           # 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
@@ -257,13 +250,10 @@ module RubyLLM
         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?(/o\d|gpt-5|codex/)
 
           if model_id.match?(/gpt-4-turbo|gpt-4o/)
@@ -281,16 +271,13 @@ module RubyLLM
             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,

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

@@ -13,18 +13,16 @@ module RubyLLM
 
         def render_payload(messages, tools:, temperature:, model:, stream: false, schema: nil, cache_prompts: {}) # rubocop:disable Lint/UnusedMethodArgument, Metrics/ParameterLists
           payload = {
-            model: model,
+            model: model.id,
             messages: format_messages(messages),
             stream: stream
           }
 
-          # Only include temperature if it's not nil (some models don't accept it)
           payload[:temperature] = temperature unless temperature.nil?
 
           payload[:tools] = tools.map { |_, tool| chat_tool_for(tool) } if tools.any?
 
           if schema
-            # Use strict mode from schema if specified, default to true
             strict = schema[:strict] != false
 
             payload[:response_format] = {

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

@@ -23,9 +23,6 @@ module RubyLLM
           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:)

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

@@ -5,13 +5,49 @@ module RubyLLM
     class OpenAI
       # Image generation methods for the OpenAI API integration
       module Images
+        def paint(prompt, model:, size:, with:, params:)
+          @operation = with.nil? ? :generation : :editing
+          @connection = connection_multipart(@connection.config) if editing? && !multipart_middleware?(@connection)
+          super
+        end
+
+        private
+
+        def editing?
+          @operation == :editing
+        end
+
+        def generating?
+          @operation == :generation
+        end
+
+        def multipart_middleware?(connection)
+          connection.connection.builder.handlers.include?(Faraday::Multipart::Middleware)
+        end
+
         module_function
 
         def images_url
+          generating? ? generation_url : edits_url
+        end
+
+        def generation_url
           'images/generations'
         end
 
-        def render_image_payload(prompt, model:, size:)
+        def edits_url
+          'images/edits'
+        end
+
+        def render_image_payload(prompt, model:, size:, with:, params:)
+          if generating?
+            render_generation_payload(prompt, model:, size:)
+          else
+            render_edit_payload(prompt, model:, with:, params:)
+          end
+        end
+
+        def render_generation_payload(prompt, model:, size:)
           {
             model: model,
             prompt: prompt,
@@ -20,16 +56,50 @@ module RubyLLM
           }
         end
 
+        def render_edit_payload(prompt, model:, with:, params:)
+          content = Content.new(prompt, with)
+          params[:image] = []
+          content.attachments.each do |attachment|
+            params[:image] << Faraday::UploadIO.new(StringIO.new(attachment.content), attachment.mime_type,
+                                                    attachment.filename)
+          end
+          params.merge({
+                         model:,
+                         prompt: content.text,
+                         n: 1
+                       })
+        end
+
         def parse_image_response(response, model:)
+          if generating?
+            parse_generation_response(response, model:)
+          else
+            parse_edit_response(response, model:)
+          end
+        end
+
+        def parse_generation_response(response, model:)
           data = response.body
           image_data = data['data'].first
 
           Image.new(
             url: image_data['url'],
-            mime_type: 'image/png', # DALL-E typically returns PNGs
+            mime_type: 'image/png',
             revised_prompt: image_data['revised_prompt'],
             model_id: model,
-            data: image_data['b64_json']
+            data: image_data['b64_json'],
+            usage: data['usage']
+          )
+        end
+
+        def parse_edit_response(response, model:)
+          data = response.body
+          image_data = data['data'].first
+          Image.new(
+            mime_type: 'image/png',
+            model_id: model,
+            data: image_data['b64_json'],
+            usage: data['usage']
           )
         end
       end

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

@@ -8,7 +8,6 @@ module RubyLLM
         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)