geminize 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 900c19e9cf075e32779e3ee2f4f4530fdced2c027e8bc393d05250c1b20e5dac
-  data.tar.gz: 7d1a9a2f365eff24d2625492916d578f661fd881263c1cd4101352d7b16780ce
+  metadata.gz: 251a4ad929a96e4773c21c159849ec415c8ee32269e3a1cda100effeda96d1ed
+  data.tar.gz: 74b958a848f75a0cf700c3751a2fb596c5a22a4a65ea9b927ead0149fef255e7
 SHA512:
-  metadata.gz: b1e3a5235a330b9bba4690a2452992f331bf4b76294109e2d4a8beb3fbc357c3f06be8b9728d607aff8653367458827bf17b166a1c89c6d243062272e747b154
-  data.tar.gz: a9c73fc3264fccaa26ba6b525d89807a9a99052232c12387281844d1cca821609c795fe199ed222c601962e8f144fc73854b73eccc75994fc3ab6ac70e4f7b2d
+  metadata.gz: a1ec3f597e8f30eedf8fe12304497896ba98e7e35137d751a64f0d3430a4723db6d63997b8852e0794e44029d014408d070613a117ae0089290d0c8e852cb2bd
+  data.tar.gz: cc0de3e6fa6949894ee531092ba02c0f07a4d828540fd1bf4f0b3d8c037f7e761212e4e4cc02dc35fedd2eea0ac8446c17c1f1ff601d64b5b5bbfa847b6702a4

data/.memory_bank/activeContext.md

@@ -12,6 +12,7 @@
 - Function calling capabilities
 - JSON mode for structured responses
 - Safety settings for content moderation
+- Code execution capabilities
 
 ### Key Implementation Details
 
@@ -32,6 +33,15 @@
 - Function result processing
 - String-based function call detection
 
+#### Code Execution
+
+- Python code generation and execution support
+- Code execution result handling
+- Support for code libraries like matplotlib, numpy, etc.
+- Tool-based code execution integration
+- Executable code response parsing
+- Code output result parsing
+
 #### JSON Mode
 
 - Structured data response handling
@@ -91,10 +101,10 @@
 - Error handling refinements
 - Models API integration
 - Function calling support
+- Code execution capabilities
 
 ### Upcoming Features
 
-- Code execution support
 - Additional content types (audio, PDF)
 - Caching support
 - Advanced parameter tuning

data/.memory_bank/progress.md

@@ -2,7 +2,7 @@
 
 ## Current Status
 
-Geminize is a functional Ruby gem providing a complete interface to the Google Gemini API. The current implementation includes all core features with a focus on stability, documentation, and ease of use. The gem now also includes function calling, JSON mode, and safety settings features.
+Geminize is a functional Ruby gem providing a complete interface to the Google Gemini API. The current implementation includes all core features with a focus on stability, documentation, and ease of use. The gem now also includes function calling, JSON mode, safety settings, and code execution features.
 
 ## Development Progress
 
@@ -19,6 +19,7 @@ Geminize is a functional Ruby gem providing a complete interface to the Google G
 - **Function Calling**: ✅ Complete
 - **JSON Mode**: ✅ Complete
 - **Safety Settings**: ✅ Complete
+- **Code Execution**: ✅ Complete
 
 ### Documentation
 
@@ -79,7 +80,7 @@ Geminize is a functional Ruby gem providing a complete interface to the Google G
 
 ### v1.3.0 (Planned)
 
-- Code execution support
+- Added code execution support
 - Additional content types (audio, PDF)
 - Caching mechanisms
 - Improved conversation persistence

data/.memory_bank/tasks.md

@@ -29,10 +29,12 @@
     - [x] Add safety configuration to requests
     - [x] Implement module-level safety methods
     - [x] Add tests for safety settings
-  - [ ] **Code Execution Support**
-    - [ ] Create code execution model classes
-    - [ ] Implement code execution tools in requests
-    - [ ] Update response handling for code execution
+  - [x] **Code Execution Support**
+    - [x] Create code execution model classes
+    - [x] Implement code execution tools in requests
+    - [x] Update response handling for code execution
+    - [x] Add module-level code execution methods
+    - [x] Create example script for code execution
   - [ ] **Additional Content Types**
     - [ ] Audio content support
     - [ ] Document/PDF content support

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [1.3.0] - 2024-05-02
+
+### Added
+
+- Code execution capabilities for generating and running Python code
+  - Added `generate_with_code_execution` method to create and execute Python code
+  - Implemented `ExecutableCode` model for representing generated code
+  - Added `CodeExecutionResult` model for capturing execution output and status
+  - Added support for visualizations and data analysis with matplotlib and other libraries
+  - Extended tool system to support code execution tools
+  - Updated content request/response handling for code execution
+  - Added comprehensive test suite with VCR tests for code execution
+  - Added examples demonstrating code execution functionality
+
 ## [1.2.0] - 2025-05-02
 
 ### Added

data/README.md

@@ -454,6 +454,48 @@ Available threshold levels (from most to least restrictive):
 - `BLOCK_ONLY_HIGH`
 - `BLOCK_NONE`
 
+## Code Execution
+
+Generate and run Python code to solve problems or analyze data:
+
+```ruby
+require 'geminize'
+# Assumes API key is configured via .env
+
+# Ask Gemini to solve a problem with code
+response = Geminize.generate_with_code_execution(
+  "Calculate the sum of the first 10 prime numbers",
+  "gemini-2.0-flash", # Use a model that supports code execution
+  { temperature: 0.2 }
+)
+
+# Display the response text
+puts "Gemini's explanation:"
+puts response.text
+
+# Access the generated code
+if response.has_executable_code?
+  puts "\nGenerated Python code:"
+  puts response.executable_code.code
+end
+
+# Access the code execution result
+if response.has_code_execution_result?
+  puts "\nExecution result:"
+  puts "Outcome: #{response.code_execution_result.outcome}"
+  puts "Output: #{response.code_execution_result.output}"
+end
+```
+
+Code execution is perfect for:
+
+- Solving mathematical problems
+- Data analysis and visualization
+- Algorithm implementation
+- Demonstrating programming concepts
+
+The model generates Python code, executes it in a secure environment, and returns both the code and its execution results.
+
 ## Streaming Responses
 
 Get real-time, token-by-token responses:
@@ -496,6 +538,8 @@ Check out these example applications to see Geminize in action:
 - [Multimodal Example](examples/multimodal.rb)
 - [System Instructions Example](examples/system_instructions.rb)
 - [Models API Example](examples/models_api.rb)
+- [Function Calling Example](examples/function_calling.rb)
+- [Code Execution Example](examples/code_execution.rb)
 
 ## Working with Models
 

data/examples/code_execution.rb

@@ -0,0 +1,126 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "geminize"
+
+# Configure the API key
+Geminize.configure do |config|
+  config.api_key = ENV["GEMINI_API_KEY"] # Make sure to set your API key in the environment
+  config.default_model = "gemini-2.0-flash" # Use a model that supports code execution
+end
+
+puts "==========================================="
+puts "=    GEMINIZE CODE EXECUTION EXAMPLES     ="
+puts "==========================================="
+
+puts "\n=== BASIC CODE EXECUTION EXAMPLE ==="
+puts "Asking Gemini to calculate the sum of the first 50 prime numbers..."
+
+begin
+  # Generate a response with code execution enabled
+  response = Geminize.generate_with_code_execution(
+    "What is the sum of the first 50 prime numbers? Generate and run code for the calculation, and make sure you get all 50.",
+    nil,
+    {temperature: 0.2}
+  )
+
+  # Display the generated text
+  puts "\nGemini's response:"
+  puts response.text
+
+  # Display the executable code if present
+  if response.has_executable_code?
+    puts "\nGenerated code:"
+    puts "```#{response.executable_code.language.downcase}"
+    puts response.executable_code.code
+    puts "```"
+  end
+
+  # Display the code execution result if present
+  if response.has_code_execution_result?
+    puts "\nCode execution result:"
+    puts "Outcome: #{response.code_execution_result.outcome}"
+    puts "Output: #{response.code_execution_result.output}"
+  end
+rescue => e
+  puts "Error during code execution: #{e.message}"
+end
+
+puts "\n\n=== PRACTICAL CODE EXECUTION EXAMPLE ==="
+puts "Asking Gemini to analyze some text data..."
+
+begin
+  # Generate a response with code execution for data analysis
+  response = Geminize.generate_with_code_execution(
+    "I have a list of temperatures: 32, 25, 30, 22, 28, 27, 35, 31, 29, 26. " \
+    "Please write code to calculate the mean, median, and standard deviation. " \
+    "Also, create a simple histogram visualization using matplotlib.",
+    nil,
+    {temperature: 0.2}
+  )
+
+  # Display the generated text
+  puts "\nGemini's response:"
+  puts response.text
+
+  # Display the executable code if present
+  if response.has_executable_code?
+    puts "\nGenerated code:"
+    puts "```#{response.executable_code.language.downcase}"
+    puts response.executable_code.code
+    puts "```"
+  end
+
+  # Display the code execution result if present
+  if response.has_code_execution_result?
+    puts "\nCode execution result:"
+    puts "Outcome: #{response.code_execution_result.outcome}"
+    puts "Output: #{response.code_execution_result.output}"
+  end
+rescue => e
+  puts "Error during code execution: #{e.message}"
+end
+
+puts "\n\n=== ITERATIVE PROBLEM SOLVING EXAMPLE ==="
+puts "Asking Gemini to solve a complex problem using code execution..."
+
+begin
+  # Generate a response for a more complex problem
+  response = Geminize.generate_with_code_execution(
+    "Write a Python function to find the nth Fibonacci number where n is a positive integer. " \
+    "Then use this function to calculate the 50th Fibonacci number. " \
+    "Implement it efficiently using memoization to avoid redundant calculations.",
+    nil,
+    {temperature: 0.2}
+  )
+
+  # Display the generated text
+  puts "\nGemini's response:"
+  puts response.text
+
+  # Display the executable code if present
+  if response.has_executable_code?
+    puts "\nGenerated code:"
+    puts "```#{response.executable_code.language.downcase}"
+    puts response.executable_code.code
+    puts "```"
+  end
+
+  # Display the code execution result if present
+  if response.has_code_execution_result?
+    puts "\nCode execution result:"
+    puts "Outcome: #{response.code_execution_result.outcome}"
+    puts "Output: #{response.code_execution_result.output}"
+  end
+rescue => e
+  puts "Error during code execution: #{e.message}"
+  puts "\nNOTE: If you hit a quota limit, try:"
+  puts "1. Using a paid API key with higher quotas"
+  puts "2. Reducing the number of examples you run"
+  puts "3. Adding delays between API calls"
+end
+
+puts "\n==========================================="
+puts "=            END OF EXAMPLES              ="
+puts "==========================================="

data/lib/geminize/models/code_execution/code_execution_result.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Geminize
+  module Models
+    module CodeExecution
+      # Represents the result of executed code
+      class CodeExecutionResult
+        # Valid outcome values for code execution
+        VALID_OUTCOMES = ["OUTCOME_OK", "OUTCOME_ERROR"].freeze
+
+        # @return [String] The outcome of the code execution (e.g., "OUTCOME_OK", "OUTCOME_ERROR")
+        attr_reader :outcome
+
+        # @return [String] The output from the code execution
+        attr_reader :output
+
+        # Initialize a new code execution result
+        # @param outcome [String] The outcome of the code execution
+        # @param output [String] The output from the code execution
+        # @raise [Geminize::ValidationError] If the code execution result is invalid
+        def initialize(outcome, output)
+          @outcome = outcome
+          @output = output
+          validate!
+        end
+
+        # Validate the code execution result
+        # @raise [Geminize::ValidationError] If the code execution result is invalid
+        # @return [Boolean] true if validation passes
+        def validate!
+          unless @outcome.is_a?(String)
+            raise Geminize::ValidationError.new(
+              "Outcome must be a string, got #{@outcome.class}",
+              "INVALID_ARGUMENT"
+            )
+          end
+
+          unless VALID_OUTCOMES.include?(@outcome)
+            raise Geminize::ValidationError.new(
+              "Invalid outcome: #{@outcome}. Must be one of: #{VALID_OUTCOMES.join(", ")}",
+              "INVALID_ARGUMENT"
+            )
+          end
+
+          unless @output.is_a?(String)
+            raise Geminize::ValidationError.new(
+              "Output must be a string, got #{@output.class}",
+              "INVALID_ARGUMENT"
+            )
+          end
+
+          true
+        end
+
+        # Convert the code execution result to a hash
+        # @return [Hash] The code execution result as a hash
+        def to_hash
+          {
+            outcome: @outcome,
+            output: @output
+          }
+        end
+
+        # Alias for to_hash
+        # @return [Hash] The code execution result as a hash
+        def to_h
+          to_hash
+        end
+      end
+    end
+  end
+end

data/lib/geminize/models/code_execution/executable_code.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Geminize
+  module Models
+    module CodeExecution
+      # Represents executable code generated by the model
+      class ExecutableCode
+        # Valid language options for executable code
+        VALID_LANGUAGES = ["PYTHON"].freeze
+
+        # @return [String] The language of the code (e.g., "PYTHON")
+        attr_reader :language
+
+        # @return [String] The code content
+        attr_reader :code
+
+        # Initialize a new executable code object
+        # @param language [String] The programming language of the code (e.g., "PYTHON")
+        # @param code [String] The code content
+        # @raise [Geminize::ValidationError] If the executable code is invalid
+        def initialize(language, code)
+          @language = language
+          @code = code
+          validate!
+        end
+
+        # Validate the executable code
+        # @raise [Geminize::ValidationError] If the executable code is invalid
+        # @return [Boolean] true if validation passes
+        def validate!
+          unless @language.is_a?(String)
+            raise Geminize::ValidationError.new(
+              "Language must be a string, got #{@language.class}",
+              "INVALID_ARGUMENT"
+            )
+          end
+
+          unless VALID_LANGUAGES.include?(@language)
+            raise Geminize::ValidationError.new(
+              "Invalid language: #{@language}. Must be one of: #{VALID_LANGUAGES.join(", ")}",
+              "INVALID_ARGUMENT"
+            )
+          end
+
+          unless @code.is_a?(String)
+            raise Geminize::ValidationError.new(
+              "Code must be a string, got #{@code.class}",
+              "INVALID_ARGUMENT"
+            )
+          end
+
+          true
+        end
+
+        # Convert the executable code to a hash
+        # @return [Hash] The executable code as a hash
+        def to_hash
+          {
+            language: @language,
+            code: @code
+          }
+        end
+
+        # Alias for to_hash
+        # @return [Hash] The executable code as a hash
+        def to_h
+          to_hash
+        end
+      end
+    end
+  end
+end

data/lib/geminize/models/content_request_extensions.rb

@@ -31,6 +31,14 @@ module Geminize
         self
       end
 
+      # Enable code execution for the request
+      # @return [self] The request object for chaining
+      def enable_code_execution
+        @tools ||= []
+        @tools << Tool.new(nil, true)
+        self
+      end
+
       # Set the tool config for function execution
       # @param execution_mode [String] The execution mode for functions ("AUTO", "MANUAL", or "NONE")
       # @return [self] The request object for chaining

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/module_extensions.rb

@@ -224,5 +224,60 @@ module Geminize
         generator.generate(content_request)
       end
     end
+
+    # Generate text with code execution capabilities
+    # @param prompt [String] The input prompt
+    # @param model_name [String, nil] The model to use, defaults to the configured default model
+    # @param params [Hash] Additional parameters for generation
+    # @option params [Float] :temperature Controls randomness (0.0-1.0)
+    # @option params [Integer] :max_tokens Maximum tokens to generate
+    # @option params [Float] :top_p Top-p value for nucleus sampling (0.0-1.0)
+    # @option params [Integer] :top_k Top-k value for sampling
+    # @option params [Array<String>] :stop_sequences Stop sequences to end generation
+    # @option params [String] :system_instruction System instruction to guide model behavior
+    # @param with_retries [Boolean] Whether to retry the generation if it fails
+    # @param max_retries [Integer] Maximum number of retries
+    # @param retry_delay [Float] Delay between retries in seconds
+    # @param client_options [Hash] Options for the HTTP client
+    # @return [Geminize::Models::ContentResponse] The generated response
+    # @raise [Geminize::Error] If the generation fails
+    # @example Generate text with code execution
+    #   Geminize.generate_with_code_execution(
+    #     "What is the sum of the first 50 prime numbers?",
+    #     nil,
+    #     { temperature: 0.2 }
+    #   )
+    def generate_with_code_execution(prompt, model_name = nil, params = {}, with_retries: true, max_retries: 3, retry_delay: 1.0, client_options: nil)
+      validate_configuration!
+
+      # Initialize the generator
+      client = client_options ? Client.new(client_options) : Client.new
+      generator = TextGeneration.new(client)
+
+      # Set up params with defaults
+      generation_params = params.dup
+      with_retries = generation_params.delete(:with_retries) != false if generation_params.key?(:with_retries)
+
+      # Enhance the system instruction to ensure code execution is effective
+      generation_params[:system_instruction] ||= ""
+      generation_params[:system_instruction] = "You are a helpful assistant with the ability to generate and execute Python code. When appropriate, use code to solve problems or complete tasks. " + generation_params[:system_instruction]
+
+      # Create the request
+      content_request = Models::ContentRequest.new(
+        prompt,
+        model_name || configuration.default_model,
+        generation_params
+      )
+
+      # Enable code execution
+      content_request.enable_code_execution
+
+      # Generate the response
+      if with_retries
+        generator.generate_with_retries(content_request, max_retries, retry_delay)
+      else
+        generator.generate(content_request)
+      end
+    end
   end
 end

data/lib/geminize/version.rb

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

data/lib/geminize.rb

@@ -33,6 +33,8 @@ require_relative "geminize/models/tool"
 require_relative "geminize/models/tool_config"
 require_relative "geminize/models/function_response"
 require_relative "geminize/models/safety_setting"
+require_relative "geminize/models/code_execution/executable_code"
+require_relative "geminize/models/code_execution/code_execution_result"
 require_relative "geminize/request_builder"
 require_relative "geminize/vector_utils"
 require_relative "geminize/text_generation"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: geminize
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Nhat Long Nguyen
@@ -182,6 +182,7 @@ files:
 - README.md
 - Rakefile
 - examples/README.md
+- examples/code_execution.rb
 - examples/configuration.rb
 - examples/embeddings.rb
 - examples/function_calling.rb
@@ -204,6 +205,8 @@ files:
 - lib/geminize/model_info.rb
 - lib/geminize/models/chat_request.rb
 - lib/geminize/models/chat_response.rb
+- lib/geminize/models/code_execution/code_execution_result.rb
+- lib/geminize/models/code_execution/executable_code.rb
 - lib/geminize/models/content_request.rb
 - lib/geminize/models/content_request_extensions.rb
 - lib/geminize/models/content_request_safety.rb