geminize 1.0.0 → 1.2.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/models/safety_setting.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Geminize
+  module Models
+    # Represents a safety setting for content filtering in Gemini API
+    class SafetySetting
+      # Valid harm categories for safety settings
+      HARM_CATEGORIES = [
+        "HARM_CATEGORY_HARASSMENT",
+        "HARM_CATEGORY_HATE_SPEECH",
+        "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+        "HARM_CATEGORY_DANGEROUS_CONTENT"
+      ].freeze
+
+      # Valid threshold levels for safety settings
+      THRESHOLD_LEVELS = [
+        "BLOCK_NONE",
+        "BLOCK_LOW_AND_ABOVE",
+        "BLOCK_MEDIUM_AND_ABOVE",
+        "BLOCK_ONLY_HIGH"
+      ].freeze
+
+      # @return [String] The harm category this setting applies to
+      attr_reader :category
+
+      # @return [String] The threshold level for filtering
+      attr_reader :threshold
+
+      # Initialize a new safety setting
+      # @param category [String] The harm category this setting applies to
+      # @param threshold [String] The threshold level for filtering
+      # @raise [Geminize::ValidationError] If the safety setting is invalid
+      def initialize(category, threshold)
+        @category = category
+        @threshold = threshold
+        validate!
+      end
+
+      # Validate the safety setting
+      # @raise [Geminize::ValidationError] If the safety setting is invalid
+      # @return [Boolean] true if validation passes
+      def validate!
+        validate_category!
+        validate_threshold!
+        true
+      end
+
+      # Convert the safety setting to a hash for API requests
+      # @return [Hash] The safety setting as a hash
+      def to_hash
+        {
+          category: @category,
+          threshold: @threshold
+        }
+      end
+
+      # Alias for to_hash
+      # @return [Hash] The safety setting as a hash
+      def to_h
+        to_hash
+      end
+
+      private
+
+      # Validate the harm category
+      # @raise [Geminize::ValidationError] If the category is invalid
+      def validate_category!
+        unless @category.is_a?(String)
+          raise Geminize::ValidationError.new(
+            "Category must be a string, got #{@category.class}",
+            "INVALID_ARGUMENT"
+          )
+        end
+
+        unless HARM_CATEGORIES.include?(@category)
+          raise Geminize::ValidationError.new(
+            "Invalid harm category: #{@category}. Must be one of: #{HARM_CATEGORIES.join(", ")}",
+            "INVALID_ARGUMENT"
+          )
+        end
+      end
+
+      # Validate the threshold level
+      # @raise [Geminize::ValidationError] If the threshold is invalid
+      def validate_threshold!
+        unless @threshold.is_a?(String)
+          raise Geminize::ValidationError.new(
+            "Threshold must be a string, got #{@threshold.class}",
+            "INVALID_ARGUMENT"
+          )
+        end
+
+        unless THRESHOLD_LEVELS.include?(@threshold)
+          raise Geminize::ValidationError.new(
+            "Invalid threshold level: #{@threshold}. Must be one of: #{THRESHOLD_LEVELS.join(", ")}",
+            "INVALID_ARGUMENT"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/geminize/models/tool.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Geminize
+  module Models
+    # Represents a tool for function calling in Gemini API
+    class Tool
+      # @return [Geminize::Models::FunctionDeclaration] The function declaration for this tool
+      attr_reader :function_declaration
+
+      # Initialize a new tool
+      # @param function_declaration [Geminize::Models::FunctionDeclaration] The function declaration
+      # @raise [Geminize::ValidationError] If the tool is invalid
+      def initialize(function_declaration)
+        @function_declaration = function_declaration
+        validate!
+      end
+
+      # Validate the tool
+      # @raise [Geminize::ValidationError] If the tool is invalid
+      # @return [Boolean] true if validation passes
+      def validate!
+        unless @function_declaration.is_a?(Geminize::Models::FunctionDeclaration)
+          raise Geminize::ValidationError.new(
+            "Function declaration must be a FunctionDeclaration, got #{@function_declaration.class}",
+            "INVALID_ARGUMENT"
+          )
+        end
+
+        true
+      end
+
+      # Convert the tool to a hash for API requests
+      # @return [Hash] The tool as a hash
+      def to_hash
+        {
+          functionDeclarations: @function_declaration.to_hash
+        }
+      end
+
+      # Alias for to_hash
+      # @return [Hash] The tool as a hash
+      def to_h
+        to_hash
+      end
+    end
+  end
+end

data/lib/geminize/models/tool_config.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Geminize
+  module Models
+    # Represents configuration for tool execution in Gemini API
+    class ToolConfig
+      # Valid execution modes for tools
+      EXECUTION_MODES = ["AUTO", "MANUAL", "NONE"].freeze
+
+      # @return [String] The execution mode for tools
+      attr_reader :execution_mode
+
+      # Initialize a new tool configuration
+      # @param execution_mode [String] The execution mode for tools
+      # @raise [Geminize::ValidationError] If the tool configuration is invalid
+      def initialize(execution_mode = "AUTO")
+        @execution_mode = execution_mode
+        validate!
+      end
+
+      # Validate the tool configuration
+      # @raise [Geminize::ValidationError] If the tool configuration is invalid
+      # @return [Boolean] true if validation passes
+      def validate!
+        unless EXECUTION_MODES.include?(@execution_mode)
+          raise Geminize::ValidationError.new(
+            "Invalid execution mode: #{@execution_mode}. Must be one of: #{EXECUTION_MODES.join(", ")}",
+            "INVALID_ARGUMENT"
+          )
+        end
+
+        true
+      end
+
+      # Convert the tool configuration to a hash for API requests
+      # @return [Hash] The tool configuration as a hash
+      def to_hash
+        {
+          function_calling_config: {
+            mode: @execution_mode
+          }
+        }
+      end
+
+      # Alias for to_hash
+      # @return [Hash] The tool configuration as a hash
+      def to_h
+        to_hash
+      end
+    end
+  end
+end