geminize 1.1.0 → 1.2.0

data/lib/geminize/models/content_response_extensions.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Geminize
+  module Models
+    # Extends ContentResponse with function calling response handling
+    class ContentResponse
+      # Get the function call information from the response
+      # @return [Geminize::Models::FunctionResponse, nil] Function call information or nil if not present
+      def function_call
+        return @function_call if defined?(@function_call)
+
+        @function_call = nil
+        candidates = @raw_response["candidates"]
+
+        if candidates && !candidates.empty?
+          content = candidates.first["content"]
+          if content && content["parts"] && !content["parts"].empty?
+            function_call_part = content["parts"].find { |part| part["functionCall"] || part["function_call"] }
+
+            if function_call_part
+              # Handle both "functionCall" and "function_call" formats (API may vary)
+              function_data = function_call_part["functionCall"] || function_call_part["function_call"]
+
+              if function_data
+                # Extract name and args - handle different API response formats
+                name = function_data["name"]
+                args = function_data["args"] || function_data["arguments"]
+
+                if name
+                  @function_call = FunctionResponse.new(name, args || {})
+                end
+              end
+            end
+          end
+        end
+
+        @function_call
+      end
+
+      # Check if the response contains a function call
+      # @return [Boolean] True if the response contains a function call
+      def has_function_call?
+        !function_call.nil?
+      end
+
+      # Get structured JSON response if available
+      # @return [Hash, nil] Parsed JSON response or nil if not a JSON response
+      def json_response
+        return @json_response if defined?(@json_response)
+
+        @json_response = nil
+
+        if has_text?
+          begin
+            @json_response = JSON.parse(text)
+          rescue JSON::ParserError
+            # Try to parse any JSON-like content from the text
+            json_match = text.match(/```json\s*(.*?)\s*```/m) || text.match(/\{.*\}/m) || text.match(/\[.*\]/m)
+            if json_match
+              begin
+                @json_response = JSON.parse(json_match[1] || json_match[0])
+              rescue JSON::ParserError
+                # Still not valid JSON
+                @json_response = nil
+              end
+            end
+          end
+        end
+
+        @json_response
+      end
+
+      # Check if the response contains valid JSON
+      # @return [Boolean] True if the response contains valid JSON
+      def has_json_response?
+        !json_response.nil?
+      end
+
+      # Enhanced parse_response method to handle function calls
+      alias_method :original_parse_response, :parse_response
+
+      private
+
+      # Parse the response data and extract relevant information
+      def parse_response
+        original_parse_response
+        # Clear any cached function call before parsing again
+        remove_instance_variable(:@function_call) if defined?(@function_call)
+        parse_function_call
+      end
+
+      # Parse function call information from the response
+      def parse_function_call
+        candidates = @raw_response["candidates"]
+
+        if candidates && !candidates.empty?
+          content = candidates.first["content"]
+          if content && content["parts"] && !content["parts"].empty?
+            function_call_part = content["parts"].find { |part| part["functionCall"] || part["function_call"] }
+
+            if function_call_part
+              # Handle both "functionCall" and "function_call" formats (API may vary)
+              function_data = function_call_part["functionCall"] || function_call_part["function_call"]
+
+              if function_data
+                # Extract name and args - handle different API response formats
+                name = function_data["name"]
+                args = function_data["args"] || function_data["arguments"]
+
+                if name
+                  @function_call = FunctionResponse.new(name, args || {})
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/geminize/models/function_declaration.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Geminize
+  module Models
+    # Represents a function declaration for function calling in Gemini API
+    class FunctionDeclaration
+      # @return [String] Name of the function
+      attr_reader :name
+
+      # @return [String] Description of what the function does
+      attr_reader :description
+
+      # @return [Hash] JSON schema for function parameters
+      attr_reader :parameters
+
+      # Initialize a new function declaration
+      # @param name [String] The name of the function
+      # @param description [String] A description of what the function does
+      # @param parameters [Hash] JSON schema for function parameters
+      # @raise [Geminize::ValidationError] If the function declaration is invalid
+      def initialize(name, description, parameters)
+        @name = name
+        @description = description
+        @parameters = parameters
+        validate!
+      end
+
+      # Validate the function declaration
+      # @raise [Geminize::ValidationError] If the function declaration is invalid
+      # @return [Boolean] true if validation passes
+      def validate!
+        validate_name!
+        validate_description!
+        validate_parameters!
+        true
+      end
+
+      # Convert the function declaration to a hash for API requests
+      # @return [Hash] The function declaration as a hash
+      def to_hash
+        {
+          name: @name,
+          description: @description,
+          parameters: @parameters
+        }
+      end
+
+      # Alias for to_hash
+      # @return [Hash] The function declaration as a hash
+      def to_h
+        to_hash
+      end
+
+      private
+
+      # Validate the function name
+      # @raise [Geminize::ValidationError] If the name is invalid
+      def validate_name!
+        unless @name.is_a?(String)
+          raise Geminize::ValidationError.new(
+            "Function name must be a string, got #{@name.class}",
+            "INVALID_ARGUMENT"
+          )
+        end
+
+        if @name.empty?
+          raise Geminize::ValidationError.new(
+            "Function name cannot be empty",
+            "INVALID_ARGUMENT"
+          )
+        end
+      end
+
+      # Validate the function description
+      # @raise [Geminize::ValidationError] If the description is invalid
+      def validate_description!
+        unless @description.is_a?(String)
+          raise Geminize::ValidationError.new(
+            "Function description must be a string, got #{@description.class}",
+            "INVALID_ARGUMENT"
+          )
+        end
+
+        if @description.empty?
+          raise Geminize::ValidationError.new(
+            "Function description cannot be empty",
+            "INVALID_ARGUMENT"
+          )
+        end
+      end
+
+      # Validate the function parameters
+      # @raise [Geminize::ValidationError] If the parameters are invalid
+      def validate_parameters!
+        unless @parameters.is_a?(Hash)
+          raise Geminize::ValidationError.new(
+            "Function parameters must be a hash, got #{@parameters.class}",
+            "INVALID_ARGUMENT"
+          )
+        end
+
+        # Validate that the parameters follow JSON Schema format
+        unless @parameters.key?(:type) || @parameters.key?("type")
+          raise Geminize::ValidationError.new(
+            "Function parameters must include a 'type' field",
+            "INVALID_ARGUMENT"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/geminize/models/function_response.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Geminize
+  module Models
+    # Represents a function response from Gemini API
+    class FunctionResponse
+      # @return [String] The name of the function that was called
+      attr_reader :name
+
+      # @return [Hash, Array, String, Numeric, Boolean, nil] The response from the function
+      attr_reader :response
+
+      # Initialize a new function response
+      # @param name [String] The name of the function that was called
+      # @param response [Hash, Array, String, Numeric, Boolean, nil] The response from the function
+      def initialize(name, response)
+        @name = name
+        @response = response
+        validate!
+      end
+
+      # Validate the function response
+      # @raise [Geminize::ValidationError] If the function response is invalid
+      # @return [Boolean] true if validation passes
+      def validate!
+        if @name.nil? || @name.empty?
+          raise Geminize::ValidationError.new(
+            "Function name cannot be empty",
+            "INVALID_ARGUMENT"
+          )
+        end
+
+        true
+      end
+
+      # Create a FunctionResponse from a hash
+      # @param hash [Hash] The hash representation of a function response
+      # @return [Geminize::Models::FunctionResponse] The function response
+      # @raise [Geminize::ValidationError] If the hash is invalid
+      def self.from_hash(hash)
+        unless hash.is_a?(Hash)
+          raise Geminize::ValidationError.new(
+            "Expected a Hash, got #{hash.class}",
+            "INVALID_ARGUMENT"
+          )
+        end
+
+        name = hash["name"] || hash[:name]
+        response = hash["response"] || hash[:response]
+
+        new(name, response)
+      end
+
+      # Convert the function response to a hash
+      # @return [Hash] The function response as a hash
+      def to_hash
+        {
+          name: @name,
+          response: @response
+        }
+      end
+
+      # Alias for to_hash
+      # @return [Hash] The function response as a hash
+      def to_h
+        to_hash
+      end
+    end
+  end
+end

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