geminize 1.2.0 → 1.3.1

data/lib/geminize/models/content_response_extensions.rb

@@ -2,117 +2,126 @@
 
 module Geminize
   module Models
-    # Extends ContentResponse with function calling response handling
+    # Extends ContentResponse with function calling capabilities
     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
+      # @return [Geminize::Models::FunctionResponse, nil] The function call in the response, if any
+      attr_reader :function_call
+
+      # @return [String, nil] The raw JSON response content, if this is a JSON response
+      attr_reader :json_response
+
+      # @return [Geminize::Models::CodeExecution::ExecutableCode, nil] The executable code in the response, if any
+      attr_reader :executable_code
 
-        @function_call
+      # @return [Geminize::Models::CodeExecution::CodeExecutionResult, nil] The code execution result in the response, if any
+      attr_reader :code_execution_result
+
+      # Store the response data for extensions
+      alias_method :original_initialize, :initialize
+      def initialize(response_data)
+        @response_data = response_data
+        original_initialize(response_data)
+        parse_function_call
+        parse_json_response
+        parse_code_execution
       end
 
-      # Check if the response contains a function call
-      # @return [Boolean] True if the response contains a function call
+      # Determine if the response contains a function call
+      # @return [Boolean] true if the response contains a function call
       def has_function_call?
-        !function_call.nil?
+        !@function_call.nil?
+      end
+
+      # Determine if the response contains a JSON response
+      # @return [Boolean] true if the response contains a JSON response
+      def has_json_response?
+        !@json_response.nil?
+      end
+
+      # Determine if the response contains executable code
+      # @return [Boolean] true if the response contains executable code
+      def has_executable_code?
+        !@executable_code.nil?
+      end
+
+      # Determine if the response contains a code execution result
+      # @return [Boolean] true if the response contains a code execution result
+      def has_code_execution_result?
+        !@code_execution_result.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)
+      private
+
+      # Parse the function call from the response
+      def parse_function_call
+        candidates = @response_data.dig("candidates") || []
+        return if candidates.empty?
+
+        content = candidates[0].dig("content") || {}
+        parts = content.dig("parts") || []
+        function_call_part = parts.find { |part| part.dig("functionCall") }
+
+        if function_call_part
+          function_call_data = function_call_part["functionCall"]
+          function_name = function_call_data["name"]
+          function_args = function_call_data["args"] || {}
 
-        @json_response = nil
+          @function_call = FunctionResponse.new(function_name, function_args)
+        end
+      end
 
-        if has_text?
+      # Parse JSON response if available
+      def parse_json_response
+        # First try to check if it's explicitly returned as JSON
+        if @response_data.dig("candidates", 0, "content", "parts", 0, "text")
+          text = @response_data.dig("candidates", 0, "content", "parts", 0, "text")
           begin
             @json_response = JSON.parse(text)
+            return
           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
+            # Not valid JSON, continue checking other methods
           end
         end
 
-        @json_response
-      end
+        # Next check if it's returned in structured format
+        candidates = @response_data.dig("candidates") || []
+        return if candidates.empty?
 
-      # Check if the response contains valid JSON
-      # @return [Boolean] True if the response contains valid JSON
-      def has_json_response?
-        !json_response.nil?
+        content = candidates[0].dig("content") || {}
+        parts = content.dig("parts") || []
+        json_part = parts.find { |part| part.key?("structuredValue") }
+
+        if json_part && json_part["structuredValue"]
+          @json_response = json_part["structuredValue"]
+        end
       end
 
-      # Enhanced parse_response method to handle function calls
-      alias_method :original_parse_response, :parse_response
+      # Parse code execution data from the response
+      def parse_code_execution
+        candidates = @response_data.dig("candidates") || []
+        return if candidates.empty?
 
-      private
+        content = candidates[0].dig("content") || {}
+        parts = content.dig("parts") || []
 
-      # 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
+        # Find executable code
+        executable_code_part = parts.find { |part| part.dig("executableCode") }
+        if executable_code_part && executable_code_part["executableCode"]
+          code_data = executable_code_part["executableCode"]
+          language = code_data["language"] || "PYTHON"
+          code = code_data["code"] || ""
 
-      # 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
+          @executable_code = Geminize::Models::CodeExecution::ExecutableCode.new(language, code)
+        end
+
+        # Find code execution result
+        result_part = parts.find { |part| part.dig("codeExecutionResult") }
+        if result_part && result_part["codeExecutionResult"]
+          result_data = result_part["codeExecutionResult"]
+          outcome = result_data["outcome"] || "OUTCOME_OK"
+          output = result_data["output"] || ""
+
+          @code_execution_result = Geminize::Models::CodeExecution::CodeExecutionResult.new(outcome, output)
         end
       end
     end

data/lib/geminize/models/tool.rb

@@ -2,16 +2,21 @@
 
 module Geminize
   module Models
-    # Represents a tool for function calling in Gemini API
+    # Represents a tool for function calling or code execution in Gemini API
     class Tool
-      # @return [Geminize::Models::FunctionDeclaration] The function declaration for this tool
+      # @return [Geminize::Models::FunctionDeclaration, nil] The function declaration for this tool
       attr_reader :function_declaration
 
+      # @return [Boolean] Whether this tool is a code execution tool
+      attr_reader :code_execution
+
       # Initialize a new tool
-      # @param function_declaration [Geminize::Models::FunctionDeclaration] The function declaration
+      # @param function_declaration [Geminize::Models::FunctionDeclaration, nil] The function declaration
+      # @param code_execution [Boolean] Whether this is a code execution tool
       # @raise [Geminize::ValidationError] If the tool is invalid
-      def initialize(function_declaration)
+      def initialize(function_declaration = nil, code_execution = false)
         @function_declaration = function_declaration
+        @code_execution = code_execution
         validate!
       end
 
@@ -19,7 +24,14 @@ module Geminize
       # @raise [Geminize::ValidationError] If the tool is invalid
       # @return [Boolean] true if validation passes
       def validate!
-        unless @function_declaration.is_a?(Geminize::Models::FunctionDeclaration)
+        if !@code_execution && @function_declaration.nil?
+          raise Geminize::ValidationError.new(
+            "Either function_declaration or code_execution must be provided",
+            "INVALID_ARGUMENT"
+          )
+        end
+
+        if @function_declaration && !@function_declaration.is_a?(Geminize::Models::FunctionDeclaration)
           raise Geminize::ValidationError.new(
             "Function declaration must be a FunctionDeclaration, got #{@function_declaration.class}",
             "INVALID_ARGUMENT"
@@ -32,9 +44,15 @@ module Geminize
       # Convert the tool to a hash for API requests
       # @return [Hash] The tool as a hash
       def to_hash
-        {
-          functionDeclarations: @function_declaration.to_hash
-        }
+        if @code_execution
+          {
+            code_execution: {}
+          }
+        else
+          {
+            functionDeclarations: @function_declaration.to_hash
+          }
+        end
       end
 
       # Alias for to_hash

data/lib/geminize/request_builder.rb

@@ -68,7 +68,7 @@ module Geminize
       # @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"
+        # Handle both formats: "models/gemini-2.0-flash" or just "gemini-2.0-flash"
         unless model_name.start_with?("models/")
           model_name = "models/#{model_name}"
         end

data/lib/geminize/version.rb

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