ruby-gemini-api 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f5a02e1edca475bc3a7ab45e9e595186a99e2546fb46c1f1f1232a8215d45469
-  data.tar.gz: a688b8e1a0bb724ab24d8cb1113ad689a784bc41915b180e17e9b4552dad4628
+  metadata.gz: 42b86546e154705767e40dad92410df0e1be21e335ae95630d8c2213f42a8a04
+  data.tar.gz: ea10d1a8c13bf0c49ccd720c9e1c25494b9c9a4955879b15e20c2722d5f8f712
 SHA512:
-  metadata.gz: a5d4af0804fb7ded6bbf069b492b31b56979ab6421dafcf671704a8aae62405946ca4efa6cdb1ef13ab69ec16a19fb0b1d19df5045d6840ae843c7500250094d
-  data.tar.gz: e9c83f07e0cfb54827d7c0a4180ab8731a7b8580669073d7d9acfe0a8b45b015d18c42acf6fbd1ffd2da3b9acb89ea7723da7e1abba756761666944a985f63dc
+  metadata.gz: 778b3de54c33818cb7d8fc6f2adc6e3876b5db4ef6dae3c9c1e1ad0db429c4b9c3225ae0518545feaba441cea212fbff0843ee72fe095c73f5fbc3b0c3a37862
+  data.tar.gz: 07cfd038ac791757e11ea1784ba48760fd3b292b6cb5edf8434930dcd4815da89431259ca9359718dc665117630d82d70852f934ef1644130d92666d0c504e12

data/CHANGELOG.md

@@ -5,3 +5,9 @@
 
 ## [0.1.1] - 2025-05-04
 - Changed generate_contents to accept temperature parameter
+
+## [0.1.2] - 2025-07-10
+- Add function calling
+
+## [0.1.3] - 2025-10-09
+- Add support for multi-image input

data/README.md

@@ -1,4 +1,4 @@
-[README ‐ 日本語](https://github.com/rira100000000/ruby-gemini-api/wiki/README-%E2%80%90-%E6%97%A5%E6%9C%AC%E8%AA%9E)
+[README ‐ 日本語](https://github.com/rira100000000/ruby-gemini-api/blob/main/README_ja.md)
 # Ruby-Gemini-API
 
 A Ruby client library for Google's Gemini API. This gem provides a simple, intuitive interface for interacting with Gemini's generative AI capabilities, following patterns similar to other AI client libraries.
@@ -18,6 +18,81 @@ This project is inspired by and pays homage to [ruby-openai](https://github.com/
 - Document processing (PDFs and other formats)
 - Context caching for efficient processing
 
+### Function Calling
+
+This library provides an intuitive DSL to define tools for function calling, making it easy to describe your functions to the Gemini model.
+
+#### Basic Usage
+
+```ruby
+require 'gemini'
+
+# Initialize Gemini client
+client = Gemini::Client.new(ENV['GEMINI_API_KEY'])
+
+# Define tools using the ToolDefinition DSL
+tools = Gemini::ToolDefinition.new do
+  function :get_current_weather, description: "Get the current weather information" do
+    property :location, type: :string, description: "City name, e.g., Tokyo", required: true
+  end
+end
+
+# User prompt
+user_prompt = "Tell me the current weather in Tokyo."
+
+# Send request with the defined tools
+response = client.generate_content(
+  user_prompt,
+  model: "gemini-1.5-flash", # Or any model that supports function calling
+  tools: tools
+)
+
+# Parse function call from the response
+unless response.function_calls.empty?
+  function_call = response.function_calls.first
+  puts "Function to call: #{function_call['name']}"
+  puts "Arguments: #{function_call['args']}"
+end
+```
+
+#### Advanced Tool Management
+
+You can define multiple functions, add them dynamically, combine tool sets, and manage them easily.
+
+```ruby
+# Define a set of weather tools
+weather_tools = Gemini::ToolDefinition.new do
+  function :get_current_weather, description: "Get the current weather" do
+    property :location, type: :string, description: "City name", required: true
+  end
+end
+
+# Define another set of stock-related tools
+stock_tools = Gemini::ToolDefinition.new do
+  function :get_stock_price, description: "Get the stock price for a symbol" do
+    property :ticker, type: :string, description: "Stock ticker symbol", required: true
+  end
+end
+
+# Combine tool sets using the + operator
+all_tools = weather_tools + stock_tools
+puts "Combined functions: #{all_tools.list_functions}"
+# => Combined functions: [:get_current_weather, :get_stock_price]
+
+# Add a new function later
+all_tools.add_function :send_email, description: "Send an email" do
+  property :to, type: :string, required: true
+  property :body, type: :string, required: true
+end
+puts "After adding a function: #{all_tools.list_functions}"
+# => After adding a function: [:get_current_weather, :get_stock_price, :send_email]
+
+# Delete a function
+all_tools.delete_function(:get_stock_price)
+puts "After deleting a function: #{all_tools.list_functions}"
+# => After deleting a function: [:get_current_weather, :send_email]
+```
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -204,11 +279,11 @@ require 'gemini'
 
 client = Gemini::Client.new(ENV['GEMINI_API_KEY'])
 
-# Generate an image using Gemini 2.0
+# Generate an image using Gemini 2.5
 response = client.images.generate(
   parameters: {
     prompt: "A beautiful sunset over the ocean with sailing boats",
-    model: "gemini-2.0-flash-exp-image-generation",
+    model: "gemini-2.5-flash-image-preview",
     size: "16:9"
   }
 )
@@ -223,6 +298,72 @@ else
 end
 ```
 
+#### Image Generation with Multiple Input Images
+
+You can generate new images by combining or editing multiple input images:
+
+```ruby
+require 'gemini'
+
+client = Gemini::Client.new(ENV['GEMINI_API_KEY'])
+
+# Generate a new image using multiple input images
+response = client.images.generate(
+  parameters: {
+    prompt: "Combine these two images to create a single artistic composition",
+    image_paths: ["path/to/image1.jpg", "path/to/image2.png"],
+    model: "gemini-2.5-flash-image-preview",
+    temperature: 0.7
+  }
+)
+
+# Save the generated image
+if response.success? && response.images.any?
+  response.save_image("combined_image.png")
+  puts "Combined image saved"
+end
+```
+
+You can also use file objects:
+
+```ruby
+# Using file objects
+File.open("image1.jpg", "rb") do |file1|
+  File.open("image2.png", "rb") do |file2|
+    response = client.images.generate(
+      parameters: {
+        prompt: "Combine these images together",
+        images: [file1, file2],
+        model: "gemini-2.5-flash-image-preview"
+      }
+    )
+    
+    if response.success? && response.images.any?
+      response.save_image("result.png")
+    end
+  end
+end
+```
+
+Base64-encoded image data is also supported:
+
+```ruby
+require 'base64'
+
+# Base64-encoded image data
+base64_data1 = Base64.strict_encode64(File.binread("image1.jpg"))
+base64_data2 = Base64.strict_encode64(File.binread("image2.png"))
+
+response = client.images.generate(
+  parameters: {
+    prompt: "Merge these images together",
+    image_base64s: [base64_data1, base64_data2],
+    mime_types: ["image/jpeg", "image/png"],
+    model: "gemini-2.5-flash-image-preview"
+  }
+)
+```
+
 You can also use Imagen 3 model (Note: This feature is not fully tested yet):
 
 ```ruby
@@ -244,7 +385,7 @@ if response.success? && !response.images.empty?
 end
 ```
 
-For a complete example, check out the `demo/image_generation_demo.rb` file included with the gem.
+For complete examples, check out the `demo/image_generation_demo.rb` and `demo/multi_image_generation_demo.rb` files included with the gem.
 
 ### Audio Transcription
 

data/lib/gemini/client.rb

@@ -116,34 +116,30 @@ module Gemini
     
     # Helper methods for convenience
     
-    # Method with usage similar to OpenAI's chat
+        # Method with usage similar to OpenAI's chat
     def generate_content(prompt, model: "gemini-2.0-flash-lite", system_instruction: nil, 
-                        response_mime_type: nil, response_schema: nil, temperature: 0.5, **parameters, &stream_callback)
-      # For image/text combinations, the prompt is passed as an array
-      # example: [{type: "text", text: "What is this?"}, {type: "image_url", image_url: {url: "https://example.com/image.jpg"}}]
+                        response_mime_type: nil, response_schema: nil, temperature: 0.5, tools: nil, **parameters, &stream_callback)
       content = format_content(prompt)
       params = {
         contents: [content],
         model: model
       }
-      
+
       if system_instruction
         params[:system_instruction] = format_content(system_instruction)
       end
-      
-        params[:generation_config] ||= {}
-        
+      params[:generation_config] ||= {}
+      params[:generation_config]["temperature"] = temperature
       if response_mime_type
         params[:generation_config]["response_mime_type"] = response_mime_type
       end
-      
+
       if response_schema
         params[:generation_config]["response_schema"] = response_schema
       end
-      params[:generation_config]["temperature"] = temperature
-      # Merge other parameters
+      params[:tools] = tools if tools
       params.merge!(parameters)
-      
+
       if block_given?
         chat(parameters: params, &stream_callback)
       else

data/lib/gemini/images.rb

@@ -4,43 +4,279 @@ module Gemini
       @client = client
     end
 
-    # 画像を生成するメインメソッド
+    # Main method to generate images
     def generate(parameters: {})
       prompt = parameters[:prompt]
       raise ArgumentError, "prompt parameter is required" unless prompt
 
-      # モデルの決定（デフォルトはGemini 2.0）
-      model = parameters[:model] || "gemini-2.0-flash-exp-image-generation"
+      model = parameters[:model] || "gemini-2.5-flash-image-preview"
       
-      # モデルに応じた画像生成処理
+      # Image editing mode if input images are provided (supports single/multiple images)
+      if has_input_images?(parameters)
+        return generate_with_images(prompt, model, parameters)
+      end
+      
+      # Image generation process based on model
       if model.start_with?("imagen")
-        # Imagen 3を使用
+        # Use Imagen 3
         response = imagen_generate(prompt, parameters)
       else
-        # Gemini 2.0を使用
+        # Use Gemini 2.0
         response = gemini_generate(prompt, parameters)
       end
       
-      # レスポンスをラップして返す
+      # Wrap and return response
       Gemini::Response.new(response)
     end
     
     private
+
+    # Check if input images exist (supports single/multiple images)
+    def has_input_images?(parameters)
+      # Single image parameters
+      single_image = parameters[:image] || parameters[:image_path] || parameters[:image_base64]
+      # Multiple image parameters
+      multiple_images = parameters[:images] || parameters[:image_paths] || parameters[:image_base64s]
+      
+      single_image || multiple_images
+    end
+    
+    # Image generation with image+text (supports single/multiple images)
+    def generate_with_images(prompt, model, parameters)      
+      # Process image data (supports single/multiple images)
+      image_parts = process_input_images(parameters)
+      
+      # Build content parts (place text first, then images)
+      parts = [{ "text" => prompt }] + image_parts
+      
+      # Build generation config
+      generation_config = {
+        "responseModalities" => ["Image"]
+      }
+      
+      # Add temperature setting if provided
+      if parameters[:temperature]
+        generation_config["temperature"] = parameters[:temperature]
+      end
+      
+      # Build request parameters
+      request_params = {
+        "contents" => [{
+          "parts" => parts
+        }],
+        "generationConfig" => generation_config
+      }
+      
+      # Merge other parameters (specify keys to exclude)
+      excluded_keys = [:prompt, :image, :image_path, :image_base64, :images, :image_paths, :image_base64s, :model, :temperature]
+      parameters.each do |key, value|
+        next if excluded_keys.include?(key)
+        request_params[key.to_s] = value
+      end
+      
+      # API call
+      response = @client.json_post(
+        path: "models/#{model}:generateContent",
+        parameters: request_params
+      )
+      
+      Gemini::Response.new(response)
+    end
     
-    # Gemini 2.0モデルを使用した画像生成
+    # Image generation with image+text (kept for backward compatibility)
+    def generate_with_image(prompt, model, parameters)
+      generate_with_images(prompt, model, parameters)
+    end
+
+    # Process input images (supports single/multiple images)
+    def process_input_images(parameters)
+      image_parts = []
+      
+      # Process multiple images
+      if parameters[:images] || parameters[:image_paths] || parameters[:image_base64s]
+        # Multiple file objects
+        if parameters[:images]
+          parameters[:images].each_with_index do |image, index|
+            if image.respond_to?(:read)
+              image_data = process_image_io(image)
+              image_parts << create_image_part(image_data)
+            else
+              raise ArgumentError, "Invalid image at index #{index}. Expected file object."
+            end
+          end
+        end
+        
+        # Multiple file paths
+        if parameters[:image_paths]
+          parameters[:image_paths].each_with_index do |path, index|
+            image_data = process_image_file(path)
+            image_parts << create_image_part(image_data)
+          end
+        end
+        
+        # Multiple Base64 data
+        if parameters[:image_base64s]
+          mime_types = parameters[:mime_types] || Array.new(parameters[:image_base64s].size, "image/jpeg")
+          parameters[:image_base64s].each_with_index do |base64_data, index|
+            image_data = {
+              data: base64_data,
+              mime_type: mime_types[index] || "image/jpeg"
+            }
+            image_parts << create_image_part(image_data)
+          end
+        end
+      else
+        # Process single image (for backward compatibility)
+        image_data = process_single_input_image(parameters)
+        image_parts << create_image_part(image_data)
+      end
+      
+      image_parts
+    end
+
+    # Process single input image (for backward compatibility)
+    def process_single_input_image(parameters)
+      if parameters[:image_base64]
+        # When Base64 data is provided directly
+        {
+          data: parameters[:image_base64],
+          mime_type: parameters[:mime_type] || "image/jpeg"
+        }
+      elsif parameters[:image_path]
+        # When file path is provided
+        process_image_file(parameters[:image_path])
+      elsif parameters[:image]
+        # When file object is provided
+        if parameters[:image].respond_to?(:read)
+          process_image_io(parameters[:image])
+        else
+          raise ArgumentError, "Invalid image parameter. Expected file path, file object, or base64 data."
+        end
+      else
+        raise ArgumentError, "No image data provided"
+      end
+    end
+
+    # Create API part from image data
+    def create_image_part(image_data)
+      {
+        "inline_data" => {
+          "mime_type" => image_data[:mime_type],
+          "data" => image_data[:data]
+        }
+      }
+    end
+
+    # Process input image (old method - kept for backward compatibility)
+    def process_input_image(parameters)
+      process_single_input_image(parameters)
+    end
+
+    # Process image from file path (newly added)
+    def process_image_file(file_path)
+      raise ArgumentError, "File does not exist: #{file_path}" unless File.exist?(file_path)
+      
+      require 'base64'
+      
+      # Determine MIME type
+      mime_type = determine_image_mime_type(file_path)
+      
+      # Read file and encode as Base64
+      file_data = File.binread(file_path)
+      base64_data = Base64.strict_encode64(file_data)
+      
+      {
+        data: base64_data,
+        mime_type: mime_type
+      }
+    end
+
+    # Process image from IO object (newly added)
+    def process_image_io(image_io)
+      require 'base64'
+      
+      # Move to beginning of file
+      image_io.rewind if image_io.respond_to?(:rewind)
+      
+      # Read data
+      file_data = image_io.read
+      
+      # Determine MIME type (use file path if available, otherwise infer from content)
+      mime_type = if image_io.respond_to?(:path) && image_io.path
+                    determine_image_mime_type(image_io.path)
+                  else
+                    determine_mime_type_from_content(file_data)
+                  end
+      
+      # Base64 encode
+      base64_data = Base64.strict_encode64(file_data)
+      
+      {
+        data: base64_data,
+        mime_type: mime_type
+      }
+    end
+
+    # Determine image MIME type from file path (newly added)
+    def determine_image_mime_type(file_path)
+      ext = File.extname(file_path).downcase
+      case ext
+      when ".jpg", ".jpeg"
+        "image/jpeg"
+      when ".png"
+        "image/png"
+      when ".gif"
+        "image/gif"
+      when ".webp"
+        "image/webp"
+      when ".bmp"
+        "image/bmp"
+      when ".tiff", ".tif"
+        "image/tiff"
+      else
+        # Default to JPEG
+        "image/jpeg"
+      end
+    end
+
+    # Determine MIME type from file content (newly added)
+    def determine_mime_type_from_content(data)
+      return "image/jpeg" if data.nil? || data.empty?
+      
+      # Check file header
+      header = data[0, 8].bytes
+      
+      case
+      when header[0..1] == [0xFF, 0xD8]
+        "image/jpeg"
+      when header[0..7] == [0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]
+        "image/png"
+      when header[0..2] == [0x47, 0x49, 0x46]
+        "image/gif"
+      when header[0..3] == [0x52, 0x49, 0x46, 0x46] && data[8..11].bytes == [0x57, 0x45, 0x42, 0x50]
+        "image/webp"
+      when header[0..1] == [0x42, 0x4D]
+        "image/bmp"
+      else
+        # Default to JPEG
+        "image/jpeg"
+      end
+    end
+
+    # Image generation using Gemini 2.5 model (original code unchanged)
     def gemini_generate(prompt, parameters)
-      # パラメータの準備
-      model = parameters[:model] || "gemini-2.0-flash-exp-image-generation"
+      # Prepare parameters
+      model = parameters[:model] || "gemini-2.5-flash-image-preview"
       
-      # サイズパラメータの処理（現在はGemini APIでは使用しない）
+      # Process size parameter (currently not used in Gemini API)
       # aspect_ratio = process_size_parameter(parameters[:size])
       
-      # 生成設定の構築
+      # Build generation config
       generation_config = {
-        "responseModalities" => ["Text", "Image"]
+        "responseModalities" => ["Image"]  # Image output only, even for text-only image generation
       }
       
-      # リクエストパラメータの構築
+      # Build request parameters
       request_params = {
         "contents" => [{
           "parts" => [
@@ -50,29 +286,29 @@ module Gemini
         "generationConfig" => generation_config
       }
       
-      # API呼び出し
+      # API call
       @client.json_post(
         path: "models/#{model}:generateContent",
         parameters: request_params
       )
     end
     
-    # Imagen 3モデルを使用した画像生成
+    # Image generation using Imagen 3 model (original code unchanged)
     def imagen_generate(prompt, parameters)
-      # モデル名の取得（デフォルトはImagen 3の標準モデル）
+      # Get model name (default is Imagen 3 standard model)
       model = parameters[:model] || "imagen-3.0-generate-002"
       
-      # サイズパラメータからアスペクト比を取得
+      # Get aspect ratio from size parameter
       aspect_ratio = process_size_parameter(parameters[:size])
       
-      # 画像生成数の設定
+      # Set number of images to generate
       sample_count = parameters[:n] || parameters[:sample_count] || 1
-      sample_count = [[sample_count.to_i, 1].max, 4].min # 1〜4の範囲に制限
+      sample_count = [[sample_count.to_i, 1].max, 4].min # Limit to range 1-4
       
-      # 人物生成の設定
+      # Set person generation setting
       person_generation = parameters[:person_generation] || "ALLOW_ADULT"
       
-      # リクエストパラメータの構築
+      # Build request parameters
       request_params = {
         "instances" => [
           {
@@ -84,20 +320,20 @@ module Gemini
         }
       }
       
-      # アスペクト比が指定されている場合は追加
+      # Add aspect ratio if specified
       request_params["parameters"]["aspectRatio"] = aspect_ratio if aspect_ratio
       
-      # 人物生成設定を追加
+      # Add person generation setting
       request_params["parameters"]["personGeneration"] = person_generation
       
-      # API呼び出し
+      # API call
       @client.json_post(
         path: "models/#{model}:predict",
         parameters: request_params
       )
     end
     
-    # サイズパラメータからアスペクト比を決定
+    # Determine aspect ratio from size parameter (original code unchanged)
     def process_size_parameter(size)
       return nil unless size
       
@@ -115,7 +351,7 @@ module Gemini
       when "1:1", "3:4", "4:3", "9:16", "16:9"
         size.to_s
       else
-        "1:1" # デフォルト
+        "1:1" # Default
       end
     end
   end

data/lib/gemini/response.rb

@@ -138,11 +138,8 @@ module Gemini
     
     # Get function call information
     def function_calls
-      return [] unless valid?
-      
-      first_candidate&.dig("content", "parts")
-        &.select { |part| part.key?("functionCall") }
-        &.map { |part| part["functionCall"] } || []
+      parts = first_candidate.dig("content", "parts") || []
+      parts.map { |part| part["functionCall"] }.compact
     end
     
     # Get response role (usually "model")

data/lib/gemini/tool_definition.rb

@@ -0,0 +1,68 @@
+module Gemini
+  class ToolDefinition
+    def initialize(&block)
+      @functions = {}
+      instance_eval(&block) if block_given?
+    end
+
+    def function(name, description:, &block)
+      @functions[name] = {
+        name: name,
+        description: description,
+        parameters: {
+          type: 'object',
+          properties: {},
+          required: []
+        }
+      }
+      @current_function = name
+      instance_eval(&block) if block_given?
+      @current_function = nil
+    end
+    alias add_function function
+
+    def property(name, type:, description:, required: false)
+      raise 'property must be defined within a function block' unless @current_function
+
+      @functions[@current_function][:parameters][:properties][name] = {
+        type: type.to_s,
+        description: description
+      }
+      @functions[@current_function][:parameters][:required] << name if required
+    end
+
+    def +(other)
+      raise ArgumentError, 'can only merge with another ToolDefinition' unless other.is_a?(ToolDefinition)
+
+      new_definition = dup
+      other.instance_variable_get(:@functions).each do |name, definition|
+        new_definition.instance_variable_get(:@functions)[name] = definition
+      end
+      new_definition
+    end
+
+    def delete_function(name)
+      @functions.delete(name)
+    end
+
+    def list_functions
+      @functions.keys
+    end
+
+    def to_h
+      {
+        function_declarations: @functions.values
+      }
+    end
+
+    def to_json(*args)
+      to_h.to_json(*args)
+    end
+
+    def dup
+      new_instance = self.class.new
+      new_instance.instance_variable_set(:@functions, @functions.dup)
+      new_instance
+    end
+  end
+end

data/lib/gemini/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Gemini
-  VERSION = "0.1.1"
+  VERSION = "0.1.3"
 end

data/lib/gemini.rb

@@ -3,7 +3,8 @@ require "faraday/multipart"
 require "json"
 require 'dotenv/load'
 
-require_relative "gemini/version"
+require_relative 'gemini/version'
+require_relative 'gemini/tool_definition'
 require_relative "gemini/http_headers"
 require_relative "gemini/http"
 require_relative "gemini/client"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-gemini-api
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - rira100000000
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-05-04 00:00:00.000000000 Z
+date: 2025-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -161,6 +161,7 @@ files:
 - lib/gemini/response.rb
 - lib/gemini/runs.rb
 - lib/gemini/threads.rb
+- lib/gemini/tool_definition.rb
 - lib/gemini/version.rb
 - lib/ruby/gemini.rb
 homepage: https://github.com/rira100000000/ruby-gemini-api