ruby-gemini-api 0.1.3 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 42b86546e154705767e40dad92410df0e1be21e335ae95630d8c2213f42a8a04
-  data.tar.gz: ea10d1a8c13bf0c49ccd720c9e1c25494b9c9a4955879b15e20c2722d5f8f712
+  metadata.gz: e140bb695362a7924c1b633fbe0a5ac0a2dda14880a755157592024f3f4e719e
+  data.tar.gz: 5b6e2ec5d5be300ba558199c8ff2160e598615cbdb4e744209416fa7322bf0f6
 SHA512:
-  metadata.gz: 778b3de54c33818cb7d8fc6f2adc6e3876b5db4ef6dae3c9c1e1ad0db429c4b9c3225ae0518545feaba441cea212fbff0843ee72fe095c73f5fbc3b0c3a37862
-  data.tar.gz: 07cfd038ac791757e11ea1784ba48760fd3b292b6cb5edf8434930dcd4815da89431259ca9359718dc665117630d82d70852f934ef1644130d92666d0c504e12
+  metadata.gz: a2f3b01548fc4da69d1d1e77943444a164dc781940eeb1e7b8ee1d34eeca34db7f46e532f5b504175000145e11e0d343319da59111b87f2f403a99c08e6517e1
+  data.tar.gz: a84dcc5431abb1a4aa9753cec5a8e36106aa365cacf88b3d29998622382069f01650f11396a6867ce0b940e5faa4788fcb2eb7c744a27203a034f2918e353416

data/CHANGELOG.md

@@ -10,4 +10,11 @@
 - Add function calling
 
 ## [0.1.3] - 2025-10-09
-- Add support for multi-image input
+- Add support for multi-image input
+
+## [0.1.4] - 2025-11-08
+- Add support for grounding search
+
+## [0.1.5] - 2025-11-13
+- Add support for URL Context tool
+- Add simplified method for accessing grounding search sources

data/README.md

@@ -272,6 +272,159 @@ client.files.delete(name: file_name)
 
 For more examples, check out the `demo/vision_demo.rb` and `demo/file_vision_demo.rb` files included with the gem.
 
+### Grounding with Google Search
+
+You can use Gemini API's Google Search grounding feature to retrieve real-time information.
+
+#### Basic Usage
+
+```ruby
+require 'gemini'
+
+client = Gemini::Client.new(ENV['GEMINI_API_KEY'])
+
+# Use Google Search to get real-time information
+response = client.generate_content(
+  "Who won the euro 2024?",
+  model: "gemini-2.0-flash-lite",
+  tools: [{ google_search: {} }]
+)
+
+if response.success?
+  puts response.text
+
+  # Check grounding information
+  if response.grounded?
+    puts "\nSource references:"
+    response.grounding_sources.each do |source|
+      puts "- #{source[:title]}"
+      puts "  #{source[:url]}"
+    end
+  end
+end
+```
+
+#### Checking Grounding Metadata
+
+```ruby
+# Check if response is grounded
+if response.grounded?
+  # Get formatted source information (recommended)
+  response.grounding_sources.each do |source|
+    puts "Title: #{source[:title]}"
+    puts "URL: #{source[:url]}"
+  end
+
+  # You can also access raw metadata
+  metadata = response.grounding_metadata
+  chunks = response.grounding_chunks
+  entry_point = response.search_entry_point
+end
+```
+
+#### Example with Different Topics
+
+```ruby
+response = client.generate_content(
+  "What are the latest AI developments in 2024?",
+  model: "gemini-2.0-flash-lite",
+  tools: [{ google_search: {} }]
+)
+
+if response.success? && response.grounded?
+  puts response.text
+  puts "\nSources: #{response.grounding_chunks.length} references"
+end
+```
+
+#### Demo Application
+
+You can find a grounding search demo in:
+
+```bash
+ruby demo/grounding_search_demo_ja.rb
+```
+
+### URL Context
+
+You can use Gemini API's URL Context feature to retrieve and analyze content from web pages.
+
+#### Basic Usage
+
+```ruby
+require 'gemini'
+
+client = Gemini::Client.new(ENV['GEMINI_API_KEY'])
+
+# Use URL Context to analyze web pages (shortcut)
+response = client.generate_content(
+  "Summarize the content of this page: https://www.ruby-lang.org",
+  model: "gemini-2.5-flash",
+  url_context: true
+)
+
+if response.success?
+  puts response.text
+end
+```
+
+#### Using Explicit Tools Parameter
+
+```ruby
+# Explicit tools parameter
+response = client.generate_content(
+  "Compare these two pages: https://www.ruby-lang.org and https://www.python.org",
+  model: "gemini-2.5-flash",
+  tools: [{ url_context: {} }]
+)
+```
+
+#### Combining URL Context with Google Search
+
+```ruby
+# Use both URL Context and Google Search
+response = client.generate_content(
+  "What is the latest information about Ruby from https://www.ruby-lang.org and recent news?",
+  model: "gemini-2.5-flash",
+  url_context: true,
+  google_search: true
+)
+```
+
+#### Checking URL Context Metadata
+
+```ruby
+# Check if URL Context was used
+if response.url_context?
+  # Get full metadata
+  metadata = response.url_context_metadata
+
+  # Get retrieved URL information
+  urls = response.retrieved_urls
+
+  # Check retrieval status for each URL
+  response.url_retrieval_statuses.each do |url_info|
+    puts "URL: #{url_info[:url]}"
+    puts "Status: #{url_info[:status]}"
+    puts "Title: #{url_info[:title]}" if url_info[:title]
+  end
+end
+```
+
+#### Limitations
+
+- Maximum 20 URLs per request
+- Maximum 34MB content size per URL
+- YouTube videos and paywalled content are not supported
+
+#### Demo Application
+
+You can find a URL context demo in:
+
+```bash
+ruby demo/url_context_demo.rb https://www.ruby-lang.org
+```
+
 ### Image Generation
 
 ```ruby

data/lib/gemini/client.rb

@@ -117,8 +117,9 @@ module Gemini
     # Helper methods for convenience
     
         # 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, tools: nil, **parameters, &stream_callback)
+    def generate_content(prompt, model: "gemini-2.0-flash-lite", system_instruction: nil,
+                        response_mime_type: nil, response_schema: nil, temperature: 0.5, tools: nil,
+                        url_context: false, google_search: false, **parameters, &stream_callback)
       content = format_content(prompt)
       params = {
         contents: [content],
@@ -137,7 +138,11 @@ module Gemini
       if response_schema
         params[:generation_config]["response_schema"] = response_schema
       end
-      params[:tools] = tools if tools
+
+      # Handle tool shortcuts
+      tools = build_tools_array(tools, url_context: url_context, google_search: google_search)
+      params[:tools] = tools if tools && !tools.empty?
+
       params.merge!(parameters)
 
       if block_given?
@@ -149,32 +154,38 @@ module Gemini
 
     # Streaming text generation
     def generate_content_stream(prompt, model: "gemini-2.0-flash-lite", system_instruction: nil,
-                              response_mime_type: nil, response_schema: nil, temperature: 0.5, **parameters, &block)
+                              response_mime_type: nil, response_schema: nil, temperature: 0.5,
+                              url_context: false, google_search: false, **parameters, &block)
       raise ArgumentError, "Block is required for streaming" unless block_given?
-      
+
       content = format_content(prompt)
       params = {
         contents: [content],
         model: model
       }
-      
+
       if system_instruction
         params[:system_instruction] = format_content(system_instruction)
       end
-      
+
       params[:generation_config] ||= {}
-      
+
       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
+
+      # Handle tool shortcuts
+      tools = build_tools_array(nil, url_context: url_context, google_search: google_search)
+      params[:tools] = tools if tools && !tools.empty?
+
       # Merge other parameters
       params.merge!(parameters)
-      
+
       chat(parameters: params, &block)
     end
 
@@ -399,7 +410,29 @@ module Gemini
     end
     
     private
-    
+
+    # Build tools array from explicit tools parameter and shortcuts
+    def build_tools_array(tools, url_context: false, google_search: false)
+      result_tools = []
+
+      # Add existing tools if provided
+      if tools.is_a?(Array)
+        result_tools.concat(tools)
+      elsif tools
+        result_tools << tools
+      end
+
+      # Add url_context tool if requested
+      result_tools << { url_context: {} } if url_context
+
+      # Add google_search tool if requested
+      result_tools << { google_search: {} } if google_search
+
+      # Remove duplicates based on tool keys and return
+      return nil if result_tools.empty?
+      result_tools.uniq { |tool| tool.keys.first }
+    end
+
     # Process stream chunk and pass to callback
     def process_stream_chunk(chunk, &callback)
       if chunk.respond_to?(:dig) && chunk.dig("candidates", 0, "content", "parts", 0, "text")

data/lib/gemini/response.rb

@@ -99,6 +99,78 @@ module Gemini
     def safety_blocked?
       finish_reason == "SAFETY"
     end
+
+    # Get grounding metadata (for Google Search grounding)
+    def grounding_metadata
+      first_candidate&.dig("groundingMetadata")
+    end
+
+    # Check if response has grounding metadata
+    def grounded?
+      !grounding_metadata.nil? && !grounding_metadata.empty?
+    end
+
+    # Get grounding chunks (source references)
+    def grounding_chunks
+      grounding_metadata&.dig("groundingChunks") || []
+    end
+
+    # Get search entry point URL (if available)
+    def search_entry_point
+      grounding_metadata&.dig("searchEntryPoint", "renderedContent")
+    end
+
+    # Get formatted grounding sources (simplified access)
+    def grounding_sources
+      return [] unless grounded?
+
+      grounding_chunks.map do |chunk|
+        if chunk["web"]
+          {
+            url: chunk["web"]["uri"],
+            title: chunk["web"]["title"],
+            type: "web"
+          }
+        else
+          # Handle other potential chunk types
+          {
+            type: "unknown",
+            data: chunk
+          }
+        end
+      end
+    end
+
+    # Get URL context metadata (for URL Context tool)
+    def url_context_metadata
+      first_candidate&.dig("urlContextMetadata")
+    end
+
+    # Check if response has URL context metadata
+    def url_context?
+      !url_context_metadata.nil? && !url_context_metadata.empty?
+    end
+
+    # Get retrieved URLs from URL context
+    def retrieved_urls
+      return [] unless url_context?
+
+      url_context_metadata&.dig("urlMetadata") || []
+    end
+
+    # Get URL retrieval statuses
+    def url_retrieval_statuses
+      return [] unless url_context?
+
+      retrieved_urls.map do |url_info|
+        {
+          url: url_info["retrievedUrl"],
+          status: url_info["urlRetrievalStatus"],
+          title: url_info["title"]
+        }
+      end
+    end
+    
     
     # Get token usage information
     def usage

data/lib/gemini/version.rb

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

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ruby-gemini-api
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.5
 platform: ruby
 authors:
 - rira100000000
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-10-09 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -172,7 +171,6 @@ metadata:
   source_code_uri: https://github.com/rira100000000/ruby-gemini-api
   changelog_uri: https://github.com/rira100000000/ruby-gemini-api/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -187,8 +185,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
-signing_key: 
+rubygems_version: 3.7.2
 specification_version: 4
 summary: Ruby client for Google's Gemini API
 test_files: []