geminize 0.1.1 → 1.1.0

data/examples/multimodal.rb

@@ -20,7 +20,7 @@ begin
   # Generate content with an image from a file
   response = Geminize.generate_text_multimodal(
     "Describe this image in detail:",
-    [{source_type: "file", data: "./examples/ruby.png"}] # Updated path
+    [{source_type: "file", data: File.join(File.dirname(__FILE__), "ruby.png")}] # Use relative path from script
   )
 
   puts "Response:"
@@ -28,7 +28,7 @@ begin
   puts "\nFinish reason: #{response.finish_reason}"
 rescue => e
   puts "Error: #{e.message}"
-  puts "Make sure the path './examples/ruby.png' is correct relative to the project root."
+  puts "Make sure the path './ruby.png' is correct relative to the project root."
 end
 
 puts "\n============================================================"
@@ -60,8 +60,8 @@ begin
   response = Geminize.generate_text_multimodal(
     "Compare these two images and describe the differences (they might be the same):",
     [
-      {source_type: "file", data: "./examples/ruby.png"}, # Updated path
-      {source_type: "file", data: "./examples/ruby.png"}  # Updated path
+      {source_type: "file", data: File.join(File.dirname(__FILE__), "ruby.png")}, # Use relative path from script
+      {source_type: "file", data: File.join(File.dirname(__FILE__), "ruby.png")}  # Use relative path from script
     ],
     "gemini-1.5-pro-latest", # Explicitly specify model
     max_tokens: 500
@@ -71,7 +71,7 @@ begin
   puts response.text
 rescue => e
   puts "Error: #{e.message}"
-  puts "Make sure the path './examples/ruby.png' is correct."
+  puts "Make sure the path './ruby.png' is correct."
 end
 
 puts "\n============================================================"
@@ -80,7 +80,7 @@ puts "============================================================"
 
 begin
   # Read image directly into bytes
-  image_bytes = File.binread("./examples/ruby.png") # Updated path
+  image_bytes = File.binread(File.join(File.dirname(__FILE__), "ruby.png")) # Use relative path from script
 
   # Generate content with raw image bytes
   response = Geminize.generate_text_multimodal(
@@ -92,7 +92,7 @@ begin
   puts response.text
 rescue => e
   puts "Error: #{e.message}"
-  puts "Make sure the path './examples/ruby.png' is correct."
+  puts "Make sure the path './ruby.png' is correct."
 end
 
 puts "\n============================================================"
@@ -112,7 +112,7 @@ begin
   )
 
   # Add multiple images using different methods
-  request.add_image_from_file("./examples/ruby.png") # Updated path
+  request.add_image_from_file(File.join(File.dirname(__FILE__), "ruby.png")) # Use relative path from script
   request.add_image_from_url("https://miro.medium.com/v2/resize:fit:720/format:webp/1*zkA1cWgJDlMUxI5TRcIHdQ.jpeg") # Updated URL
 
   # Generate the response
@@ -122,7 +122,7 @@ begin
   puts response.text
 
   # Check if usage data is available before accessing it
-  if response.usage && response.usage.total_tokens
+  if response.usage&.total_tokens
     puts "\nUsed #{response.usage.total_tokens} tokens total"
   else
     puts "\nUsage data not available in the response."

data/lib/geminize/configuration.rb

@@ -17,7 +17,7 @@ module Geminize
     DEFAULT_MODEL = "gemini-2.0-flash"
 
     # Default embedding model
-    DEFAULT_EMBEDDING_MODEL = "embedding-001"
+    DEFAULT_EMBEDDING_MODEL = "gemini-embedding-exp-03-07"
 
     # Default timeout values (in seconds)
     DEFAULT_TIMEOUT = 30
@@ -69,9 +69,9 @@ module Geminize
     # @return [void]
     def reset!
       @api_key = ENV["GEMINI_API_KEY"]
-      @api_version = DEFAULT_API_VERSION
-      @default_model = DEFAULT_MODEL
-      @default_embedding_model = DEFAULT_EMBEDDING_MODEL
+      @api_version = ENV["GEMINI_API_VERSION"] || DEFAULT_API_VERSION
+      @default_model = ENV["GEMINI_MODEL"] || DEFAULT_MODEL
+      @default_embedding_model = ENV["GEMINI_EMBEDDING_MODEL"] || DEFAULT_EMBEDDING_MODEL
       @timeout = DEFAULT_TIMEOUT
       @open_timeout = DEFAULT_OPEN_TIMEOUT
       @streaming_timeout = DEFAULT_STREAMING_TIMEOUT

data/lib/geminize/model_info.rb

@@ -9,6 +9,9 @@ module Geminize
     # @return [Geminize::Client] The HTTP client
     attr_reader :client
 
+    # Default page size for listing models
+    DEFAULT_PAGE_SIZE = 50
+
     # Initialize a new ModelInfo instance
     # @param client [Geminize::Client, nil] The HTTP client to use
     # @param options [Hash] Additional options for the client
@@ -20,19 +23,26 @@ module Geminize
     end
 
     # List available models from the Gemini API
+    # @param page_size [Integer, nil] Number of models to return per page (max 1000)
+    # @param page_token [String, nil] Token for retrieving a specific page
     # @param force_refresh [Boolean] Force a refresh from the API instead of using cache
     # @return [Geminize::Models::ModelList] List of available models
     # @raise [Geminize::GeminizeError] If the request fails
-    def list_models(force_refresh: false)
-      cache_key = "models_list"
+    def list_models(page_size: nil, page_token: nil, force_refresh: false)
+      cache_key = "models_list_#{page_size}_#{page_token}"
 
       # Check if we have a valid cached result
       if !force_refresh && @cache[cache_key] && @cache_expiry[cache_key] > Time.now
         return @cache[cache_key]
       end
 
+      # Prepare query parameters
+      params = {}
+      params[:pageSize] = page_size if page_size
+      params[:pageToken] = page_token
+
       # Make the API request
-      response = client.get("models")
+      response = client.get("models", params)
 
       # Create a ModelList from the response
       model_list = Models::ModelList.from_api_data(response)
@@ -44,13 +54,62 @@ module Geminize
       model_list
     end
 
+    # Get all available models, handling pagination automatically
+    # @param force_refresh [Boolean] Force a refresh from the API instead of using cache
+    # @return [Geminize::Models::ModelList] Complete list of all available models
+    # @raise [Geminize::GeminizeError] If any request fails
+    def list_all_models(force_refresh: false)
+      cache_key = "all_models_list"
+
+      # Check if we have a valid cached result
+      if !force_refresh && @cache[cache_key] && @cache_expiry[cache_key] > Time.now
+        return @cache[cache_key]
+      end
+
+      all_models = []
+      page_token = nil
+
+      # Fetch first page
+      model_list = list_models(
+        page_size: DEFAULT_PAGE_SIZE,
+        page_token: page_token,
+        force_refresh: force_refresh
+      )
+      all_models.concat(model_list.models)
+
+      # Fetch additional pages if available
+      while model_list.has_more_pages?
+        page_token = model_list.next_page_token
+        model_list = list_models(
+          page_size: DEFAULT_PAGE_SIZE,
+          page_token: page_token,
+          force_refresh: force_refresh
+        )
+        all_models.concat(model_list.models)
+      end
+
+      # Create a consolidated model list
+      result = Models::ModelList.new(all_models)
+
+      # Cache the result
+      @cache[cache_key] = result
+      @cache_expiry[cache_key] = Time.now + @cache_ttl
+
+      result
+    end
+
     # Get information about a specific model
-    # @param model_id [String] The model ID to retrieve
+    # @param model_name [String] The model name to retrieve (models/{model})
     # @param force_refresh [Boolean] Force a refresh from the API instead of using cache
     # @return [Geminize::Models::Model] The model information
     # @raise [Geminize::GeminizeError] If the request fails or model is not found
-    def get_model(model_id, force_refresh: false)
-      cache_key = "model_#{model_id}"
+    def get_model(model_name, force_refresh: false)
+      # Handle both formats: "models/gemini-1.5-pro" or just "gemini-1.5-pro"
+      unless model_name.start_with?("models/")
+        model_name = "models/#{model_name}"
+      end
+
+      cache_key = "model_#{model_name}"
 
       # Check if we have a valid cached result
       if !force_refresh && @cache[cache_key] && @cache_expiry[cache_key] > Time.now
@@ -59,7 +118,7 @@ module Geminize
 
       # Make the API request
       begin
-        response = client.get("models/#{model_id}")
+        response = client.get(model_name)
 
         # Create a Model from the response
         model = Models::Model.from_api_data(response)
@@ -71,10 +130,30 @@ module Geminize
         model
       rescue Geminize::NotFoundError => e
         # Re-raise with a more descriptive message
-        raise Geminize::NotFoundError.new("Model '#{model_id}' not found", e.code, e.http_status)
+        raise Geminize::NotFoundError.new("Model '#{model_name}' not found", e.code, e.http_status)
       end
     end
 
+    # Get models that support a specific generation method
+    # @param method [String] The generation method (e.g., "generateContent", "embedContent")
+    # @param force_refresh [Boolean] Force a refresh from the API instead of using cache
+    # @return [Geminize::Models::ModelList] List of models that support the method
+    # @raise [Geminize::GeminizeError] If the request fails
+    def get_models_by_method(method, force_refresh: false)
+      all_models = list_all_models(force_refresh: force_refresh)
+      all_models.filter_by_method(method)
+    end
+
+    # Get models by base model ID
+    # @param base_model_id [String] The base model ID to filter by
+    # @param force_refresh [Boolean] Force a refresh from the API instead of using cache
+    # @return [Geminize::Models::ModelList] List of models with the specified base model ID
+    # @raise [Geminize::GeminizeError] If the request fails
+    def get_models_by_base_id(base_model_id, force_refresh: false)
+      all_models = list_all_models(force_refresh: force_refresh)
+      all_models.filter_by_base_model_id(base_model_id)
+    end
+
     # Clear all cached model information
     # @return [void]
     def clear_cache

data/lib/geminize/models/content_request.rb

@@ -214,7 +214,7 @@ module Geminize
         # Map content_parts to the structure the API expects
         api_parts = @content_parts.map do |part|
           if part[:type] == "text"
-            { text: part[:text] }
+            {text: part[:text]}
           elsif part[:type] == "image"
             {
               inlineData: {

data/lib/geminize/models/model.rb

@@ -4,69 +4,131 @@ module Geminize
   module Models
     # Represents an AI model from the Gemini API.
     class Model
-      # @return [String] The unique identifier for the model
-      attr_reader :id
-
-      # @return [String] The display name of the model
+      # @return [String] The resource name of the model
       attr_reader :name
 
+      # @return [String] The base model ID
+      attr_reader :base_model_id
+
       # @return [String] The model version
       attr_reader :version
 
+      # @return [String] The display name of the model
+      attr_reader :display_name
+
       # @return [String] The model description
       attr_reader :description
 
-      # @return [Array<String>] List of supported capabilities (e.g., 'text', 'vision', 'embedding')
-      attr_reader :capabilities
+      # @return [Integer] Maximum number of input tokens allowed
+      attr_reader :input_token_limit
+
+      # @return [Integer] Maximum number of output tokens available
+      attr_reader :output_token_limit
 
-      # @return [Hash] Model limitations and constraints
-      attr_reader :limitations
+      # @return [Array<String>] Supported generation methods
+      attr_reader :supported_generation_methods
 
-      # @return [Array<String>] Recommended use cases for this model
-      attr_reader :use_cases
+      # @return [Float] Default temperature
+      attr_reader :temperature
+
+      # @return [Float] Maximum allowed temperature
+      attr_reader :max_temperature
+
+      # @return [Float] Default top_p value for nucleus sampling
+      attr_reader :top_p
+
+      # @return [Integer] Default top_k value for sampling
+      attr_reader :top_k
 
       # @return [Hash] Raw model data from the API
       attr_reader :raw_data
 
       # Create a new Model instance
       # @param attributes [Hash] Model attributes
-      # @option attributes [String] :id The model ID
-      # @option attributes [String] :name The model name
+      # @option attributes [String] :name The resource name of the model
+      # @option attributes [String] :base_model_id The base model ID
       # @option attributes [String] :version The model version
+      # @option attributes [String] :display_name The display name of the model
       # @option attributes [String] :description The model description
-      # @option attributes [Array<String>] :capabilities List of capabilities
-      # @option attributes [Hash] :limitations Model limitations
-      # @option attributes [Array<String>] :use_cases Recommended use cases
+      # @option attributes [Integer] :input_token_limit Maximum input tokens
+      # @option attributes [Integer] :output_token_limit Maximum output tokens
+      # @option attributes [Array<String>] :supported_generation_methods Supported methods
+      # @option attributes [Float] :temperature Default temperature
+      # @option attributes [Float] :max_temperature Maximum temperature
+      # @option attributes [Float] :top_p Default top_p value
+      # @option attributes [Integer] :top_k Default top_k value
       # @option attributes [Hash] :raw_data Raw model data from API
       def initialize(attributes = {})
-        @id = attributes[:id]
         @name = attributes[:name]
+        @base_model_id = attributes[:base_model_id]
         @version = attributes[:version]
+        @display_name = attributes[:display_name]
         @description = attributes[:description]
-        @capabilities = attributes[:capabilities] || []
-        @limitations = attributes[:limitations] || {}
-        @use_cases = attributes[:use_cases] || []
+        @input_token_limit = attributes[:input_token_limit]
+        @output_token_limit = attributes[:output_token_limit]
+        @supported_generation_methods = attributes[:supported_generation_methods] || []
+        @temperature = attributes[:temperature]
+        @max_temperature = attributes[:max_temperature]
+        @top_p = attributes[:top_p]
+        @top_k = attributes[:top_k]
         @raw_data = attributes[:raw_data] || {}
       end
 
-      # Check if model supports a specific capability
-      # @param capability [String] Capability to check for
-      # @return [Boolean] True if the model supports the capability
-      def supports?(capability)
-        capabilities.include?(capability.to_s.downcase)
+      # Shorthand accessor for the model ID (last part of the name path)
+      # @return [String] The model ID
+      def id
+        return nil unless @name
+        @name.split("/").last
+      end
+
+      # Check if model supports a specific generation method
+      # @param method [String] Generation method to check for
+      # @return [Boolean] True if the model supports the method
+      def supports_method?(method)
+        supported_generation_methods.include?(method.to_s)
+      end
+
+      # Check if model supports content generation
+      # @return [Boolean] True if the model supports content generation
+      def supports_content_generation?
+        supports_method?("generateContent")
+      end
+
+      # Check if model supports message generation (chat)
+      # @return [Boolean] True if the model supports message generation
+      def supports_message_generation?
+        supports_method?("generateMessage")
+      end
+
+      # Check if model supports embedding generation
+      # @return [Boolean] True if the model supports embedding generation
+      def supports_embedding?
+        supports_method?("embedContent")
+      end
+
+      # Check if model supports streaming content generation
+      # @return [Boolean] True if the model supports streaming content generation
+      def supports_streaming?
+        supports_method?("streamGenerateContent")
       end
 
       # Convert model to a hash representation
       # @return [Hash] Hash representation of the model
       def to_h
         {
-          id: id,
           name: name,
+          id: id,
+          base_model_id: base_model_id,
           version: version,
+          display_name: display_name,
           description: description,
-          capabilities: capabilities,
-          limitations: limitations,
-          use_cases: use_cases
+          input_token_limit: input_token_limit,
+          output_token_limit: output_token_limit,
+          supported_generation_methods: supported_generation_methods,
+          temperature: temperature,
+          max_temperature: max_temperature,
+          top_p: top_p,
+          top_k: top_k
         }
       end
 
@@ -80,92 +142,22 @@ module Geminize
       # @param data [Hash] Raw API response data
       # @return [Model] New Model instance
       def self.from_api_data(data)
-        # Extract capabilities from model data
-        capabilities = extract_capabilities(data)
-
-        # Extract limitations from model data
-        limitations = extract_limitations(data)
-
-        # Extract use cases from model data
-        use_cases = extract_use_cases(data)
-
         new(
-          id: data["name"]&.split("/")&.last,
-          name: data["displayName"],
-          version: extract_version(data),
+          name: data["name"],
+          base_model_id: data["baseModelId"],
+          version: data["version"],
+          display_name: data["displayName"],
           description: data["description"],
-          capabilities: capabilities,
-          limitations: limitations,
-          use_cases: use_cases,
+          input_token_limit: data["inputTokenLimit"],
+          output_token_limit: data["outputTokenLimit"],
+          supported_generation_methods: data["supportedGenerationMethods"] || [],
+          temperature: data["temperature"],
+          max_temperature: data["maxTemperature"],
+          top_p: data["topP"],
+          top_k: data["topK"],
           raw_data: data
         )
       end
-
-      private_class_method def self.extract_version(data)
-        # Extract version from model name or other fields
-        # Example: if name is "gemini-1.0-pro", extract "1.0"
-        if data["displayName"]
-          match = data["displayName"].match(/[-_](\d+\.\d+)[-_]/)
-          return match[1] if match
-
-          # Try another pattern (e.g., "Gemini 1.5 Pro")
-          match = data["displayName"].match(/\s(\d+\.\d+)\s/)
-          return match[1] if match
-        end
-        nil
-      end
-
-      private_class_method def self.extract_capabilities(data)
-        capabilities = []
-
-        # Example capability extraction, adjust based on actual API response format
-        capabilities << "text" if data.dig("supportedGenerationMethods")&.include?("generateText")
-        capabilities << "chat" if data.dig("supportedGenerationMethods")&.include?("generateMessage")
-        capabilities << "vision" if data.dig("supportedGenerationMethods")&.include?("generateContent") &&
-          data.dig("inputSetting", "supportMultiModal")
-        capabilities << "embedding" if data.dig("supportedGenerationMethods")&.include?("embedContent")
-
-        capabilities
-      end
-
-      private_class_method def self.extract_limitations(data)
-        limitations = {}
-
-        # Extract token limits
-        if data.dig("inputTokenLimit")
-          limitations[:input_token_limit] = data["inputTokenLimit"]
-        end
-
-        if data.dig("outputTokenLimit")
-          limitations[:output_token_limit] = data["outputTokenLimit"]
-        end
-
-        # Extract any other limitations from the API data
-        limitations
-      end
-
-      private_class_method def self.extract_use_cases(data)
-        # Extract use cases from the description or other fields
-        # This is a simple implementation - adjust based on actual API data
-        use_cases = []
-
-        if data["description"]
-          if data["description"].include?("chat")
-            use_cases << "conversational_ai"
-          end
-
-          if data["description"].include?("vision") || data["description"].include?("image")
-            use_cases << "image_understanding"
-          end
-
-          if data["description"].include?("embedding")
-            use_cases << "semantic_search"
-            use_cases << "clustering"
-          end
-        end
-
-        use_cases
-      end
     end
   end
 end

data/lib/geminize/models/model_list.rb

@@ -12,13 +12,18 @@ module Geminize
       # @return [Array<Model>] The list of models
       attr_reader :models
 
+      # @return [String, nil] Token for fetching the next page of results
+      attr_reader :next_page_token
+
       # Delegate array methods to the underlying models array
       def_delegators :@models, :[], :size, :length, :empty?, :first, :last
 
       # Create a new ModelList
       # @param models [Array<Model>] Initial list of models
-      def initialize(models = [])
+      # @param next_page_token [String, nil] Token for fetching the next page
+      def initialize(models = [], next_page_token = nil)
         @models = models
+        @next_page_token = next_page_token
       end
 
       # Implement Enumerable's required each method
@@ -35,43 +40,50 @@ module Geminize
         self
       end
 
-      # Find a model by its ID
+      # Find a model by its resource name
+      # @param name [String] The model name to search for
+      # @return [Model, nil] The found model or nil
+      def find_by_name(name)
+        @models.find { |model| model.name == name }
+      end
+
+      # Find a model by its ID (last part of the resource name)
       # @param id [String] The model ID to search for
       # @return [Model, nil] The found model or nil
       def find_by_id(id)
         @models.find { |model| model.id == id }
       end
 
-      # Find all models that support a specific capability
-      # @param capability [String] The capability to filter by
+      # Find all models that support a specific generation method
+      # @param method [String] The generation method to filter by
       # @return [ModelList] A new ModelList containing only matching models
-      def filter_by_capability(capability)
-        filtered = @models.select { |model| model.supports?(capability) }
-        ModelList.new(filtered)
+      def filter_by_method(method)
+        filtered = @models.select { |model| model.supports_method?(method) }
+        ModelList.new(filtered, nil)
       end
 
-      # Find all models that support vision capabilities
-      # @return [ModelList] A new ModelList containing only vision-capable models
-      def vision_models
-        filter_by_capability("vision")
+      # Find all models that support content generation
+      # @return [ModelList] A new ModelList containing only content generation capable models
+      def content_generation_models
+        filter_by_method("generateContent")
       end
 
-      # Find all models that support embedding capabilities
-      # @return [ModelList] A new ModelList containing only embedding-capable models
-      def embedding_models
-        filter_by_capability("embedding")
+      # Find all models that support streaming content generation
+      # @return [ModelList] A new ModelList containing only streaming capable models
+      def streaming_models
+        filter_by_method("streamGenerateContent")
       end
 
-      # Find all models that support text generation
-      # @return [ModelList] A new ModelList containing only text generation models
-      def text_models
-        filter_by_capability("text")
+      # Find all models that support embeddings
+      # @return [ModelList] A new ModelList containing only embedding-capable models
+      def embedding_models
+        filter_by_method("embedContent")
       end
 
       # Find all models that support chat/conversation
       # @return [ModelList] A new ModelList containing only chat-capable models
       def chat_models
-        filter_by_capability("chat")
+        filter_by_method("generateMessage")
       end
 
       # Filter models by version
@@ -79,16 +91,40 @@ module Geminize
       # @return [ModelList] A new ModelList containing only matching models
       def filter_by_version(version)
         filtered = @models.select { |model| model.version == version }
-        ModelList.new(filtered)
+        ModelList.new(filtered, nil)
       end
 
-      # Filter models by name pattern
-      # @param pattern [String, Regexp] The pattern to match model names against
+      # Filter models by display name pattern
+      # @param pattern [String, Regexp] The pattern to match model display names against
       # @return [ModelList] A new ModelList containing only matching models
-      def filter_by_name(pattern)
+      def filter_by_display_name(pattern)
         pattern = Regexp.new(pattern.to_s, Regexp::IGNORECASE) if pattern.is_a?(String)
-        filtered = @models.select { |model| model.name&.match?(pattern) }
-        ModelList.new(filtered)
+        filtered = @models.select { |model| model.display_name&.match?(pattern) }
+        ModelList.new(filtered, nil)
+      end
+
+      # Filter models by base model ID
+      # @param base_model_id [String] The base model ID to filter by
+      # @return [ModelList] A new ModelList containing only matching models
+      def filter_by_base_model_id(base_model_id)
+        filtered = @models.select { |model| model.base_model_id == base_model_id }
+        ModelList.new(filtered, nil)
+      end
+
+      # Find models with a minimum input token limit
+      # @param min_limit [Integer] The minimum input token limit
+      # @return [ModelList] A new ModelList containing only matching models
+      def filter_by_min_input_tokens(min_limit)
+        filtered = @models.select { |model| model.input_token_limit && model.input_token_limit >= min_limit }
+        ModelList.new(filtered, nil)
+      end
+
+      # Find models with a minimum output token limit
+      # @param min_limit [Integer] The minimum output token limit
+      # @return [ModelList] A new ModelList containing only matching models
+      def filter_by_min_output_tokens(min_limit)
+        filtered = @models.select { |model| model.output_token_limit && model.output_token_limit >= min_limit }
+        ModelList.new(filtered, nil)
       end
 
       # Create a ModelList from API response data
@@ -96,16 +132,22 @@ module Geminize
       # @return [ModelList] New ModelList instance
       def self.from_api_data(data)
         models = []
+        next_page_token = data["nextPageToken"]
 
         # Process model data from API response
-        # The exact structure will depend on the Gemini API response format
         if data.key?("models")
           models = data["models"].map do |model_data|
             Model.from_api_data(model_data)
           end
         end
 
-        new(models)
+        new(models, next_page_token)
+      end
+
+      # Check if there are more pages of results available
+      # @return [Boolean] True if there are more pages
+      def has_more_pages?
+        !next_page_token.nil? && !next_page_token.empty?
       end
 
       # Convert to array of hashes representation