geminize 1.0.0 → 1.1.0

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

data/lib/geminize/request_builder.rb

@@ -52,6 +52,35 @@ module Geminize
       def build_streaming_endpoint(model_name)
         build_model_endpoint(model_name, "streamGenerateContent")
       end
+
+      # Build a models list request parameters
+      # @param page_size [Integer, nil] Number of models to return per page
+      # @param page_token [String, nil] Token for retrieving a specific page
+      # @return [Hash] The query parameters for models listing
+      def build_models_list_params(page_size = nil, page_token = nil)
+        params = {}
+        params[:pageSize] = page_size if page_size
+        params[:pageToken] = page_token if page_token
+        params
+      end
+
+      # Build a specific model endpoint for the get model info API
+      # @param model_name [String] The model name or ID to get info for
+      # @return [String] The complete API endpoint path for getting model info
+      def build_get_model_endpoint(model_name)
+        # 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
+        model_name
+      end
+
+      # Build the endpoint for embedding generation
+      # @param model_name [String] The name of the model
+      # @return [String] The complete API endpoint path for embedding generation
+      def build_embedding_endpoint(model_name)
+        build_model_endpoint(model_name, "embedContent")
+      end
     end
   end
 end

data/lib/geminize/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Geminize
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

data/lib/geminize.rb

@@ -478,35 +478,92 @@ module Geminize
       )
     end
 
-    # Get a list of available models from the Gemini API
+    # 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
     # @param client_options [Hash] Options to pass to the client
     # @return [Geminize::Models::ModelList] List of available models
     # @raise [Geminize::GeminizeError] If the request fails
-    # @example Get a list of all available models
-    #   models = Geminize.list_models
-    # @example Get a fresh list bypassing cache
-    #   models = Geminize.list_models(force_refresh: true)
-    # @example Filter models by capability
-    #   vision_models = Geminize.list_models.vision_models
-    def list_models(force_refresh: false, client_options: {})
+    def list_models(page_size: nil, page_token: nil, force_refresh: false, client_options: {})
       validate_configuration!
       model_info = ModelInfo.new(nil, client_options)
-      model_info.list_models(force_refresh: force_refresh)
+      model_info.list_models(page_size: page_size, page_token: page_token, force_refresh: force_refresh)
+    end
+
+    # Get all available models, handling pagination automatically
+    # @param force_refresh [Boolean] Force a refresh from the API instead of using cache
+    # @param client_options [Hash] Options to pass to the client
+    # @return [Geminize::Models::ModelList] Complete list of all available models
+    # @raise [Geminize::GeminizeError] If the request fails
+    def list_all_models(force_refresh: false, client_options: {})
+      validate_configuration!
+      model_info = ModelInfo.new(nil, client_options)
+      model_info.list_all_models(force_refresh: force_refresh)
     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 (can be "models/gemini-1.5-pro" or just "gemini-1.5-pro")
     # @param force_refresh [Boolean] Force a refresh from the API instead of using cache
     # @param client_options [Hash] Options to pass to the client
     # @return [Geminize::Models::Model] The model information
     # @raise [Geminize::GeminizeError] If the request fails or model is not found
-    # @example Get information about a specific model
-    #   model = Geminize.get_model("gemini-1.5-pro")
-    def get_model(model_id, force_refresh: false, client_options: {})
+    def get_model(model_name, force_refresh: false, client_options: {})
       validate_configuration!
       model_info = ModelInfo.new(nil, client_options)
-      model_info.get_model(model_id, force_refresh: force_refresh)
+      model_info.get_model(model_name, force_refresh: force_refresh)
+    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
+    # @param client_options [Hash] Options to pass to the client
+    # @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, client_options: {})
+      validate_configuration!
+      model_info = ModelInfo.new(nil, client_options)
+      model_info.get_models_by_method(method, force_refresh: force_refresh)
+    end
+
+    # Get models that support content generation
+    # @param force_refresh [Boolean] Force a refresh from the API instead of using cache
+    # @param client_options [Hash] Options to pass to the client
+    # @return [Geminize::Models::ModelList] List of models that support content generation
+    # @raise [Geminize::GeminizeError] If the request fails
+    def get_content_generation_models(force_refresh: false, client_options: {})
+      models = list_all_models(force_refresh: force_refresh, client_options: client_options)
+      models.content_generation_models
+    end
+
+    # Get models that support embedding generation
+    # @param force_refresh [Boolean] Force a refresh from the API instead of using cache
+    # @param client_options [Hash] Options to pass to the client
+    # @return [Geminize::Models::ModelList] List of models that support embedding generation
+    # @raise [Geminize::GeminizeError] If the request fails
+    def get_embedding_models(force_refresh: false, client_options: {})
+      models = list_all_models(force_refresh: force_refresh, client_options: client_options)
+      models.embedding_models
+    end
+
+    # Get models that support chat generation
+    # @param force_refresh [Boolean] Force a refresh from the API instead of using cache
+    # @param client_options [Hash] Options to pass to the client
+    # @return [Geminize::Models::ModelList] List of models that support chat generation
+    # @raise [Geminize::GeminizeError] If the request fails
+    def get_chat_models(force_refresh: false, client_options: {})
+      models = list_all_models(force_refresh: force_refresh, client_options: client_options)
+      models.chat_models
+    end
+
+    # Get models that support streaming generation
+    # @param force_refresh [Boolean] Force a refresh from the API instead of using cache
+    # @param client_options [Hash] Options to pass to the client
+    # @return [Geminize::Models::ModelList] List of models that support streaming generation
+    # @raise [Geminize::GeminizeError] If the request fails
+    def get_streaming_models(force_refresh: false, client_options: {})
+      models = list_all_models(force_refresh: force_refresh, client_options: client_options)
+      models.streaming_models
     end
 
     # Update a conversation's system instruction

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: geminize
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Nhat Long Nguyen
@@ -130,8 +130,50 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".cursor/mcp.json"
+- ".cursor/rules/isolation_rules/Core/command-execution.mdc"
+- ".cursor/rules/isolation_rules/Core/complexity-decision-tree.mdc"
+- ".cursor/rules/isolation_rules/Core/creative-phase-enforcement.mdc"
+- ".cursor/rules/isolation_rules/Core/creative-phase-metrics.mdc"
+- ".cursor/rules/isolation_rules/Core/file-verification.mdc"
+- ".cursor/rules/isolation_rules/Core/platform-awareness.mdc"
+- ".cursor/rules/isolation_rules/Level3/planning-comprehensive.mdc"
+- ".cursor/rules/isolation_rules/Level3/task-tracking-intermediate.mdc"
+- ".cursor/rules/isolation_rules/Phases/CreativePhase/creative-phase-architecture.mdc"
+- ".cursor/rules/isolation_rules/main.mdc"
+- ".cursor/rules/isolation_rules/visual-maps/archive-mode-map.mdc"
+- ".cursor/rules/isolation_rules/visual-maps/creative-mode-map.mdc"
+- ".cursor/rules/isolation_rules/visual-maps/implement-mode-map.mdc"
+- ".cursor/rules/isolation_rules/visual-maps/plan-mode-map.mdc"
+- ".cursor/rules/isolation_rules/visual-maps/qa-mode-map.mdc"
+- ".cursor/rules/isolation_rules/visual-maps/reflect-mode-map.mdc"
+- ".cursor/rules/isolation_rules/visual-maps/van-mode-map.mdc"
+- ".cursor/rules/isolation_rules/visual-maps/van_mode_split/van-complexity-determination.mdc"
+- ".cursor/rules/isolation_rules/visual-maps/van_mode_split/van-file-verification.mdc"
+- ".cursor/rules/isolation_rules/visual-maps/van_mode_split/van-mode-map.mdc"
+- ".cursor/rules/isolation_rules/visual-maps/van_mode_split/van-platform-detection.mdc"
+- ".cursor/rules/isolation_rules/visual-maps/van_mode_split/van-qa-checks/build-test.mdc"
+- ".cursor/rules/isolation_rules/visual-maps/van_mode_split/van-qa-checks/config-check.mdc"
+- ".cursor/rules/isolation_rules/visual-maps/van_mode_split/van-qa-checks/dependency-check.mdc"
+- ".cursor/rules/isolation_rules/visual-maps/van_mode_split/van-qa-checks/environment-check.mdc"
+- ".cursor/rules/isolation_rules/visual-maps/van_mode_split/van-qa-checks/file-verification.mdc"
+- ".cursor/rules/isolation_rules/visual-maps/van_mode_split/van-qa-main.mdc"
+- ".cursor/rules/isolation_rules/visual-maps/van_mode_split/van-qa-utils/common-fixes.mdc"
+- ".cursor/rules/isolation_rules/visual-maps/van_mode_split/van-qa-utils/mode-transitions.mdc"
+- ".cursor/rules/isolation_rules/visual-maps/van_mode_split/van-qa-utils/reports.mdc"
+- ".cursor/rules/isolation_rules/visual-maps/van_mode_split/van-qa-utils/rule-calling-guide.mdc"
+- ".cursor/rules/isolation_rules/visual-maps/van_mode_split/van-qa-utils/rule-calling-help.mdc"
+- ".cursor/rules/isolation_rules/visual-maps/van_mode_split/van-qa-validation.md.old"
+- ".env.example"
+- ".memory_bank/activeContext.md"
+- ".memory_bank/progress.md"
+- ".memory_bank/projectbrief.md"
+- ".memory_bank/systemPatterns.md"
+- ".memory_bank/tasks.md"
+- ".memory_bank/techContext.md"
 - ".rspec"
 - ".standard.yml"
+- ".tool-versions"
 - ".yardopts"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
@@ -142,6 +184,7 @@ files:
 - examples/README.md
 - examples/configuration.rb
 - examples/embeddings.rb
+- examples/models_api.rb
 - examples/multimodal.rb
 - examples/ruby.png
 - examples/system_instructions.rb
@@ -197,7 +240,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.8
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Ruby interface for Google's Gemini AI API
 test_files: []