geminize 1.2.0 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 900c19e9cf075e32779e3ee2f4f4530fdced2c027e8bc393d05250c1b20e5dac
-  data.tar.gz: 7d1a9a2f365eff24d2625492916d578f661fd881263c1cd4101352d7b16780ce
+  metadata.gz: 86fb5e9a612c451c27419e3c7d17f707ed337b9f38283493a521123b515e0e03
+  data.tar.gz: 9743507bf4df70ea1292757b01bc5e7d4f4c32cf7ef899b3bd9ef63acfb7966a
 SHA512:
-  metadata.gz: b1e3a5235a330b9bba4690a2452992f331bf4b76294109e2d4a8beb3fbc357c3f06be8b9728d607aff8653367458827bf17b166a1c89c6d243062272e747b154
-  data.tar.gz: a9c73fc3264fccaa26ba6b525d89807a9a99052232c12387281844d1cca821609c795fe199ed222c601962e8f144fc73854b73eccc75994fc3ab6ac70e4f7b2d
+  metadata.gz: f279410c3e5b848ba9ac652b15cc78a4112da3d5ea5aab425a2257525aa16fdf42bd68e03329f91e98ebef9bfda3a72eb2dfd18db489eed10def917e2ba6dfb5
+  data.tar.gz: 608c8b726d586e66ed8ae8b81174509fa4b5ff9d3fae299efde0013afc6d7b91d7c25f6840b7f7d94d0a3a4a645657843c4a4d1d0bf61723761e771050e93c85

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,23 @@
+## [1.3.1] - 2025-05-17
+
+### Changed
+
+- Refactored `Geminize::ModuleExtensions` and `Geminize::ModuleSafety` into the main `Geminize` module for a flatter internal structure. This change is internal and does not affect the public API.
+
+## [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

@@ -311,7 +311,7 @@ weather_functions = [
 response = Geminize.generate_with_functions(
   "What's the weather in San Francisco?",
   weather_functions,
-  "gemini-1.5-pro", # Make sure you use a model that supports function calling
+  "gemini-2.0-flash", # Make sure you use a model that supports function calling
   {
     temperature: 0.2,
     system_instruction: "Use the provided function to get weather information."
@@ -382,7 +382,7 @@ require 'geminize'
 # Request JSON-formatted data
 response = Geminize.generate_json(
   "List the three largest planets in our solar system with their diameters in km",
-  "gemini-1.5-pro", # Use a model that supports JSON mode
+  "gemini-2.0-flash", # Use a model that supports JSON mode
   { temperature: 0.2 }
 )
 
@@ -417,7 +417,7 @@ safety_settings = [
 response = Geminize.generate_with_safety_settings(
   "Explain the concept of nuclear fission",
   safety_settings,
-  "gemini-1.5-pro",
+  "gemini-2.0-flash",
   { temperature: 0.7 }
 )
 
@@ -426,7 +426,7 @@ puts response.text
 # For maximum safety (blocks most potentially harmful content)
 safe_response = Geminize.generate_text_safe(
   "Tell me about controversial political topics",
-  "gemini-1.5-pro"
+  "gemini-2.0-flash"
 )
 
 puts "Safe response: #{safe_response.text}"
@@ -434,7 +434,7 @@ puts "Safe response: #{safe_response.text}"
 # For minimum filtering (blocks only the most harmful content)
 permissive_response = Geminize.generate_text_permissive(
   "Describe a controversial historical event",
-  "gemini-1.5-pro"
+  "gemini-2.0-flash"
 )
 
 puts "Permissive response: #{permissive_response.text}"
@@ -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
 
@@ -510,7 +554,7 @@ models = Geminize.list_models
 puts "Available models: #{models.size}"
 
 # Get details about a specific model
-model = Geminize.get_model("gemini-1.5-pro")
+model = Geminize.get_model("gemini-2.0-flash")
 puts "Model: #{model.display_name}"
 puts "Token limits: #{model.input_token_limit} input, #{model.output_token_limit} output"
 

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/examples/function_calling.rb

@@ -8,7 +8,7 @@ require "json"
 # 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-1.5-pro-latest" # Use the latest model that supports function calling
+  config.default_model = "gemini-2.0-flash" # Use the latest model that supports function calling
 end
 
 # Define a weather function that can handle a location and unit

data/examples/multimodal.rb

@@ -63,7 +63,7 @@ begin
       {source_type: "file", data: File.join(File.dirname(__FILE__), "ruby.png")}, # Use relative path from script
       {source_type: "file", data: File.join(File.dirname(__FILE__), "ruby.png")}  # Use relative path from script
     ],
-    "gemini-1.5-pro-latest", # Explicitly specify model
+    "gemini-2.0-flash", # Explicitly specify model
     max_tokens: 500
   )
 
@@ -106,7 +106,7 @@ begin
   # Create a content request
   request = Geminize::Models::ContentRequest.new(
     "Tell me about these images:",
-    "gemini-1.5-pro-latest",
+    "gemini-2.0-flash",
     temperature: 0.3,
     max_tokens: 800
   )

data/examples/safety_settings.rb

@@ -7,7 +7,7 @@ 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-1.5-pro-latest" # Use the latest model
+  config.default_model = "gemini-2.0-flash" # Use the latest model
 end
 
 # A prompt that might trigger safety filters

data/lib/geminize/model_info.rb

@@ -104,7 +104,7 @@ module Geminize
     # @return [Geminize::Models::Model] The model information
     # @raise [Geminize::GeminizeError] If the request fails or model is not found
     def get_model(model_name, force_refresh: false)
-      # 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/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