ruby-gemini-api 0.1.4 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c80fbf2cb7142ab3ff7d6a17d8b5f1e43960ec8ed398ee7f4c35286ed72ce962
-  data.tar.gz: 261f1a1e04757b93aac9c8a42263e355758bba4ec512f6c9dd408b63146e17fe
+  metadata.gz: 80e6cd429265c5341e1efcd3e701f9643cdb4785f18826234ec879178d4a236e
+  data.tar.gz: c9a9c5201b616ce2d534393c1d99240563b9d36229dac4f564f71b4ed82ee42b
 SHA512:
-  metadata.gz: 780a9684677d9bfdd8945727c9cd00e1e0ecc9e43a63a038da17a18aa8e524e43f601946bd1fbc00c9406e4a45b80d59fedfdfc85e190b973cedd9c2340a5be4
-  data.tar.gz: 399dff8bc6f6693b6267412b2fee067269125ea9b16ffd105d94b4ac9154ca1ade4246b6d3ca9aa9e7cb689e3f2d4a12ea771d4fc688de24e36688205675ab0f
+  metadata.gz: b1ac2fe8cf4dacad20f21a7eab1872fa496a797b76d9af12cb401c5f563aeaed9cd58e4323334fcd6bbf67d74273902b5f9f076a5a44833474b4f3a4e8409148
+  data.tar.gz: 17693cd9f1a87ad1fdf21c26153d1ac351ca9137c99e1c97cddd2524333db21190b0bbf5c08b995939c950338f0d5bf4607263a2ae0bc92c0343b28d439c2a6f

data/CHANGELOG.md

@@ -13,4 +13,15 @@
 - Add support for multi-image input
 
 ## [0.1.4] - 2025-11-08
-- Add support for grounding search
+- 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
+
+## [0.1.6] - 2025-12-11
+- Add support for video understanding
+  - Analyze local video files (Files API and inline data)
+  - Analyze YouTube videos
+  - Helper methods: describe, ask, extract_timestamps, analyze_segment
+  - Support for MP4, MPEG, MOV, AVI, FLV, WebM, WMV, 3GPP formats

data/README.md

@@ -11,6 +11,7 @@ This project is inspired by and pays homage to [ruby-openai](https://github.com/
 - Chat functionality with conversation history
 - Streaming responses for real-time text generation
 - Audio transcription capabilities
+- Video understanding (including YouTube videos)
 - Thread and message management for chat applications
 - Runs management for executing AI tasks
 - Convenient Response object for easy access to generated content
@@ -43,7 +44,7 @@ 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
+  model: "gemini-2.5-flash", # Or any model that supports function calling
   tools: tools
 )
 
@@ -126,7 +127,7 @@ client = Gemini::Client.new(ENV['GEMINI_API_KEY'])
 # Generate text
 response = client.generate_content(
   "What are the main features of Ruby programming language?",
-  model: "gemini-2.0-flash-lite"
+  model: "gemini-2.5-flash"
 )
 
 # Access the generated content using Response object
@@ -147,7 +148,7 @@ client = Gemini::Client.new(ENV['GEMINI_API_KEY'])
 # Stream response in real-time
 client.generate_content_stream(
   "Tell me a story about a programmer who loves Ruby",
-  model: "gemini-2.0-flash-lite"
+  model: "gemini-2.5-flash"
 ) do |chunk|
   print chunk
   $stdout.flush
@@ -170,7 +171,7 @@ contents = [
 
 # Get response with conversation history
 response = client.chat(parameters: {
-  model: "gemini-2.0-flash-lite",
+  model: "gemini-2.5-flash",
   contents: contents
 })
 
@@ -198,7 +199,7 @@ system_instruction = "You are a Ruby programming expert who provides concise cod
 
 # Use system instructions with chat
 response = client.chat(parameters: {
-  model: "gemini-2.0-flash-lite",
+  model: "gemini-2.5-flash",
   system_instruction: { parts: [{ text: system_instruction }] },
   contents: [{ role: "user", parts: [{ text: "How do I write a simple web server in Ruby?" }] }]
 })
@@ -225,7 +226,7 @@ response = client.generate_content(
     { type: "text", text: "Describe what you see in this image" },
     { type: "image_file", image_file: { file_path: "path/to/image.jpg" } }
   ],
-  model: "gemini-2.0-flash"
+  model: "gemini-2.5-flash"
 )
 
 # Access the description using Response object
@@ -256,7 +257,7 @@ response = client.generate_content(
     { text: "Describe this image in detail" },
     { file_data: { mime_type: "image/jpeg", file_uri: file_uri } }
   ],
-  model: "gemini-2.0-flash"
+  model: "gemini-2.5-flash"
 )
 
 # Process the response using Response object
@@ -286,21 +287,19 @@ 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",
+  model: "gemini-2.5-flash",
   tools: [{ google_search: {} }]
 )
 
 if response.success?
   puts response.text
-  
+
   # Check grounding information
   if response.grounded?
     puts "\nSource references:"
-    response.grounding_chunks.each do |chunk|
-      if chunk['web']
-        puts "- #{chunk['web']['title']}"
-        puts "  #{chunk['web']['uri']}"
-      end
+    response.grounding_sources.each do |source|
+      puts "- #{source[:title]}"
+      puts "  #{source[:url]}"
     end
   end
 end
@@ -311,13 +310,15 @@ end
 ```ruby
 # Check if response is grounded
 if response.grounded?
-  # Get full grounding metadata
+  # 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
-  
-  # Get source chunks (references)
   chunks = response.grounding_chunks
-  
-  # Get search entry point
   entry_point = response.search_entry_point
 end
 ```
@@ -327,7 +328,7 @@ end
 ```ruby
 response = client.generate_content(
   "What are the latest AI developments in 2024?",
-  model: "gemini-2.0-flash-lite",
+  model: "gemini-2.5-flash",
   tools: [{ google_search: {} }]
 )
 
@@ -345,6 +346,86 @@ You can find a grounding search demo in:
 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
@@ -470,7 +551,7 @@ client = Gemini::Client.new(ENV['GEMINI_API_KEY'])
 # Transcribe audio file (note: file size limit is 20MB for direct upload)
 response = client.audio.transcribe(
   parameters: {
-    model: "gemini-1.5-flash",
+    model: "gemini-2.5-flash",
     file: File.open("audio_file.mp3", "rb"),
     language: "en",
     content_text: "Transcribe this audio clip"
@@ -502,7 +583,7 @@ file_name = upload_result["file"]["name"]
 # Use the file ID for transcription
 response = client.audio.transcribe(
   parameters: {
-    model: "gemini-1.5-flash",
+    model: "gemini-2.5-flash",
     file_uri: file_uri,
     language: "en"
   }
@@ -521,6 +602,137 @@ client.files.delete(name: file_name)
 
 For more examples, check out the `demo/file_audio_demo.rb` file included with the gem.
 
+### Video Understanding
+
+Gemini API can understand video content, enabling description, segmentation, information extraction, and question answering. It can process videos up to 2 hours long.
+
+#### Basic Usage (Upload via Files API)
+
+For video files larger than 20MB or files you want to reuse multiple times, uploading via Files API is recommended:
+
+```ruby
+require 'gemini'
+
+client = Gemini::Client.new(ENV['GEMINI_API_KEY'])
+
+# Upload and analyze a video file
+result = client.video.analyze(
+  file_path: "path/to/video.mp4",
+  prompt: "Describe this video in detail"
+)
+
+response = result[:response]
+
+if response.success?
+  puts response.text
+else
+  puts "Video analysis failed: #{response.error}"
+end
+
+# File information (optional)
+puts "File URI: #{result[:file_uri]}"
+puts "File name: #{result[:file_name]}"
+```
+
+#### Analyze as Inline Data (Videos under 20MB)
+
+Small video files can be Base64-encoded and sent inline:
+
+```ruby
+# Analyze a video under 20MB inline
+response = client.video.analyze_inline(
+  file_path: "path/to/small_video.mp4",
+  prompt: "What is happening in this video?"
+)
+
+if response.success?
+  puts response.text
+end
+```
+
+#### YouTube Video Analysis
+
+You can directly analyze public YouTube videos (private and unlisted videos are not supported):
+
+```ruby
+# Analyze a video using YouTube URL
+response = client.video.analyze_youtube(
+  url: "https://www.youtube.com/watch?v=XXXXX",
+  prompt: "What are the three main points of this video?"
+)
+
+if response.success?
+  puts response.text
+end
+```
+
+#### Helper Methods
+
+Helper methods are provided for common operations:
+
+```ruby
+# Get video description
+response = client.video.describe(file_path: "video.mp4")
+puts response.text
+
+# Get YouTube video description
+response = client.video.describe(youtube_url: "https://youtube.com/...")
+puts response.text
+
+# Ask questions about a video
+response = client.video.ask(
+  file_uri: result[:file_uri],
+  question: "Who appears in this video?"
+)
+puts response.text
+
+# Extract timestamps
+response = client.video.extract_timestamps(
+  file_uri: result[:file_uri],
+  query: "important scenes"
+)
+puts response.text
+```
+
+#### Video Segment Analysis
+
+You can analyze only a portion of a video:
+
+```ruby
+# Analyze a specific segment of the video
+response = client.video.analyze_segment(
+  file_uri: result[:file_uri],
+  prompt: "What is happening in this scene?",
+  start_offset: "30s",
+  end_offset: "60s"
+)
+
+if response.success?
+  puts response.text
+end
+```
+
+#### Supported Video Formats
+
+- MP4 - video/mp4
+- MPEG - video/mpeg
+- MOV - video/quicktime
+- AVI - video/x-msvideo
+- FLV - video/x-flv
+- MPG - video/mpeg
+- WebM - video/webm
+- WMV - video/x-ms-wmv
+- 3GPP - video/3gpp
+
+#### Limitations
+
+- 2 million context window: up to approximately 2 hours
+- 1 million context window: up to approximately 1 hour
+- YouTube free plan: cannot process more than 8 hours of video per day
+- Approximately 300 tokens consumed per second of video (at default resolution)
+
+Demo application can be found in `demo/video_demo.rb`.
+
 ### Document Processing
 
 Gemini API can process long documents (up to 3,600 pages), including PDFs. Gemini models understand both text and images within the document, enabling you to analyze, summarize, and extract information.
@@ -534,7 +746,7 @@ client = Gemini::Client.new(ENV['GEMINI_API_KEY'])
 result = client.documents.process(
   file_path: "path/to/document.pdf",
   prompt: "Summarize this document in three key points",
-  model: "gemini-1.5-flash"
+  model: "gemini-2.5-flash"
 )
 
 response = result[:response]
@@ -563,7 +775,7 @@ file_path = "path/to/document.pdf"
 thread_result = client.chat_with_file(
   file_path,
   "Please provide an overview of this document",
-  model: "gemini-1.5-flash"
+  model: "gemini-2.5-flash"
 )
 
 # Get the thread ID (for continuing the conversation)
@@ -610,7 +822,7 @@ Demo applications can be found in `demo/document_chat_demo.rb` and `demo/documen
 
 Context caching allows you to preprocess and store inputs like large documents or images with the Gemini API, then reuse them across multiple requests. This saves processing time and token usage when asking different questions about the same content.
 
-**Important**: Context caching requires a minimum input of 32,768 tokens. The maximum token count matches the context window size of the model you are using. Caches automatically expire after 48 hours, but you can set a custom TTL (Time To Live).Models are only available in fixed version stable models (e.g. gemini-1.5-pro-001).The version suffix (e.g. -001 for gemini-1.5-pro-001) must be included.
+**Important**: Context caching requires a minimum input of 32,768 tokens. The maximum token count matches the context window size of the model you are using. Caches automatically expire after 48 hours, but you can set a custom TTL (Time To Live). Using stable model versions like gemini-2.5-flash is recommended.
 
 ```ruby
 require 'gemini'
@@ -622,7 +834,7 @@ cache_result = client.documents.cache(
   file_path: "path/to/large_document.pdf",
   system_instruction: "You are a document analysis expert. Please understand the content thoroughly and answer questions accurately.",
   ttl: "86400s", # 24 hours (in seconds)
-  model: "gemini-1.5-flash-001"
+  model: "gemini-2.5-flash"
 )
 
 # Get the cache name
@@ -633,7 +845,7 @@ puts "Cache name: #{cache_name}"
 response = client.generate_content_with_cache(
   "What are the key findings in this document?",
   cached_content: cache_name,
-  model: "gemini-1.5-flash-001"
+  model: "gemini-2.5-flash"
 )
 
 if response.success?
@@ -785,7 +997,7 @@ require 'gemini'
 client = Gemini::Client.new(ENV['GEMINI_API_KEY'])
 
 # Create a new thread
-thread = client.threads.create(parameters: { model: "gemini-2.0-flash-lite" })
+thread = client.threads.create(parameters: { model: "gemini-2.5-flash" })
 thread_id = thread["id"]
 
 # Add a message to the thread
@@ -821,7 +1033,7 @@ client = Gemini::Client.new(ENV['GEMINI_API_KEY'])
 
 response = client.generate_content(
   "Tell me about the Ruby programming language",
-  model: "gemini-2.0-flash-lite"
+  model: "gemini-2.5-flash"
 )
 
 # Basic response information
@@ -897,8 +1109,9 @@ The gem includes several demo applications that showcase its functionality:
 - `demo/demo.rb` - Basic text generation and chat
 - `demo/stream_demo.rb` - Streaming text generation
 - `demo/audio_demo.rb` - Audio transcription
+- `demo/video_demo.rb` - Video understanding (local files and YouTube)
 - `demo/vision_demo.rb` - Image recognition
-- `demo/image_generation_demo.rb` - Image generation 
+- `demo/image_generation_demo.rb` - Image generation
 - `demo/file_vision_demo.rb` - Image recognition with large image files
 - `demo/file_audio_demo.rb` - Audio transcription with large audio files
 - `demo/structured_output_demo.rb` - Structured JSON output with schema
@@ -925,6 +1138,12 @@ ruby demo/audio_demo.rb path/to/audio/file.mp3
 # Audio transcription with over 20MB audio file
 ruby demo/file_audio_demo.rb path/to/audio/file.mp3
 
+# Video understanding (local file)
+ruby demo/video_demo.rb path/to/video/file.mp4
+
+# Video understanding (YouTube)
+ruby demo/video_demo.rb --youtube https://www.youtube.com/watch?v=XXXXX
+
 # Image recognition
 ruby demo/vision_demo.rb path/to/image/file.jpg
 
@@ -954,10 +1173,8 @@ ruby demo/document_cache_demo.rb path/to/document.pdf
 
 The library supports various Gemini models:
 
-- `gemini-2.0-flash-lite`
-- `gemini-2.0-flash`
-- `gemini-2.0-pro`
-- `gemini-1.5-flash`
+- `gemini-2.5-flash`
+- `gemini-2.5-pro`
 
 ## Requirements
 

data/lib/gemini/audio.rb

@@ -8,7 +8,7 @@ module Gemini
     def transcribe(parameters: {})
       file = parameters.delete(:file)
       file_uri = parameters.delete(:file_uri)
-      model = parameters.delete(:model) || "gemini-1.5-flash"
+      model = parameters.delete(:model) || "gemini-2.5-flash"
       language = parameters.delete(:language)
       content_text = parameters.delete(:content_text) || "Transcribe this audio clip"
       

data/lib/gemini/cached_content.rb

@@ -24,7 +24,7 @@ module Gemini
       mime_type ||= file_path ? @client.determine_mime_type(file_path) : "application/octet-stream"
       
       # モデルを取得（models/プレフィックスを追加）
-      model_name = model || parameters[:model] || "gemini-1.5-flash"
+      model_name = model || parameters[:model] || "gemini-2.5-flash"
       model_name = "models/#{model_name}" unless model_name.start_with?("models/")
       
       # キャッシュリクエストを構築（キャメルケースに注意）

data/lib/gemini/client.rb

@@ -59,6 +59,11 @@ module Gemini
       @documents ||= Gemini::Documents.new(client: self)
     end
 
+    # 動画処理アクセサ
+    def video
+      @video ||= Gemini::Video.new(client: self)
+    end
+
     # キャッシュ管理アクセサ
     def cached_content
       @cached_content ||= Gemini::CachedContent.new(client: self)
@@ -77,7 +82,7 @@ module Gemini
     # OpenAI chat-like text generation method for Gemini API
     # Extended to support streaming callbacks
     def chat(parameters: {}, &stream_callback)
-      model = parameters.delete(:model) || "gemini-2.0-flash-lite"
+      model = parameters.delete(:model) || "gemini-2.5-flash"
       
       # If streaming callback is provided
       if block_given?
@@ -117,8 +122,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.5-flash", 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 +143,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?
@@ -148,38 +158,44 @@ module Gemini
     end
 
     # 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)
+    def generate_content_stream(prompt, model: "gemini-2.5-flash", system_instruction: nil,
+                              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
 
     # ファイルを使った会話（複数ファイル対応）
-    def chat_with_multimodal(file_paths, prompt, model: "gemini-1.5-flash", **parameters)
+    def chat_with_multimodal(file_paths, prompt, model: "gemini-2.5-flash", **parameters)
       # スレッドを作成
       thread = threads.create(parameters: { model: model })
       thread_id = thread["id"]
@@ -247,7 +263,7 @@ module Gemini
       end
     end
 
-    def generate_content_with_cache(prompt, cached_content:, model: "gemini-1.5-flash", **parameters)
+    def generate_content_with_cache(prompt, cached_content:, model: "gemini-2.5-flash", **parameters)
       # モデル名にmodels/プレフィックスを追加
       model_name = model.start_with?("models/") ? model : "models/#{model}"
       
@@ -278,12 +294,12 @@ module Gemini
     end
 
     # 単一ファイルのヘルパー
-    def chat_with_file(file_path, prompt, model: "gemini-1.5-flash", **parameters)
+    def chat_with_file(file_path, prompt, model: "gemini-2.5-flash", **parameters)
       chat_with_multimodal([file_path], prompt, model: model, **parameters)
     end
 
     # ファイルをアップロードして質問するシンプルなヘルパー
-    def upload_and_process_file(file_path, prompt, content_type: nil, model: "gemini-1.5-flash", **parameters)
+    def upload_and_process_file(file_path, prompt, content_type: nil, model: "gemini-2.5-flash", **parameters)
       # MIMEタイプを自動判定
       mime_type = content_type || determine_mime_type(file_path)
       
@@ -399,7 +415,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/documents.rb

@@ -5,7 +5,7 @@ module Gemini
     end
 
     # ドキュメントをアップロードして質問する基本メソッド
-    def process(file: nil, file_path: nil, prompt:, model: "gemini-1.5-flash", **parameters)
+    def process(file: nil, file_path: nil, prompt:, model: "gemini-2.5-flash", **parameters)
       # ファイルパスが指定されている場合はファイルを開く
       if file_path && !file
         file = File.open(file_path, "rb")
@@ -70,7 +70,7 @@ module Gemini
         file_name = upload_result["file"]["name"]
         
         # モデル名の取得と調整
-        model = parameters[:model] || "gemini-1.5-flash"
+        model = parameters[:model] || "gemini-2.5-flash"
         model = "models/#{model}" unless model.start_with?("models/")
         
         # キャッシュに保存（パラメータの名前に注意）

data/lib/gemini/files.rb

@@ -125,11 +125,21 @@ module Gemini
       when ".mp4"
         "video/mp4"
       when ".avi"
-        "video/avi"
+        "video/x-msvideo"
       when ".mov"
         "video/quicktime"
       when ".mkv"
         "video/x-matroska"
+      when ".mpeg", ".mpg"
+        "video/mpeg"
+      when ".webm"
+        "video/webm"
+      when ".wmv"
+        "video/x-ms-wmv"
+      when ".flv"
+        "video/x-flv"
+      when ".3gp", ".3gpp"
+        "video/3gpp"
       when ".pdf"
         "application/pdf"
       when ".txt"

data/lib/gemini/response.rb

@@ -119,6 +119,57 @@ module Gemini
     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

data/lib/gemini/threads.rb

@@ -27,7 +27,7 @@ module Gemini
         id: thread_id,
         created_at: created_at,
         metadata: parameters[:metadata] || {},
-        model: parameters[:model] || "gemini-2.0-flash-lite"
+        model: parameters[:model] || "gemini-2.5-flash"
       }
       
       {

data/lib/gemini/version.rb

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

data/lib/gemini/video.rb

@@ -0,0 +1,341 @@
+module Gemini
+  class Video
+    # サポートされる動画形式
+    SUPPORTED_FORMATS = %w[.mp4 .mpeg .mov .avi .flv .mpg .webm .wmv .3gp .3gpp].freeze
+
+    def initialize(client:)
+      @client = client
+    end
+
+    # 動画ファイルを分析する（Files APIでアップロード後に分析）
+    # 20MB以上のファイルや複数回利用する場合に推奨
+    def analyze(file: nil, file_path: nil, prompt:, model: "gemini-2.5-flash", **parameters)
+      # ファイルパスが指定されている場合はファイルを開く
+      if file_path && !file
+        file = File.open(file_path, "rb")
+        close_file = true
+      else
+        close_file = false
+      end
+
+      begin
+        raise ArgumentError, "file or file_path parameter is required" unless file
+
+        # MIMEタイプを判定
+        mime_type = parameters.delete(:mime_type) || determine_video_mime_type(file)
+
+        # ファイルをアップロード
+        upload_result = @client.files.upload(file: file)
+        file_uri = upload_result["file"]["uri"]
+        file_name = upload_result["file"]["name"]
+
+        # ファイルがACTIVE状態になるまで待機
+        wait_for_file_active(file_name)
+
+        # コンテンツを生成
+        raw_response = generate_video_content(
+          file_uri: file_uri,
+          mime_type: mime_type,
+          prompt: prompt,
+          model: model,
+          **parameters
+        )
+
+        # レスポンスとファイル情報を返す
+        {
+          response: Gemini::Response.new(raw_response),
+          file_uri: file_uri,
+          file_name: file_name
+        }
+      ensure
+        file.close if file && close_file
+      end
+    end
+
+    # アップロード済みのファイルURIを使用して分析
+    def analyze_with_file_uri(file_uri:, prompt:, model: "gemini-2.5-flash", mime_type: "video/mp4", **parameters)
+      raw_response = generate_video_content(
+        file_uri: file_uri,
+        mime_type: mime_type,
+        prompt: prompt,
+        model: model,
+        **parameters
+      )
+
+      Gemini::Response.new(raw_response)
+    end
+
+    # YouTube URLから動画を分析（公開動画のみ）
+    def analyze_youtube(url:, prompt:, model: "gemini-2.5-flash", **parameters)
+      # YouTube URLのバリデーション
+      unless valid_youtube_url?(url)
+        raise ArgumentError, "Invalid YouTube URL. Only public YouTube videos are supported."
+      end
+
+      # リクエストパラメータを構築
+      request_params = {
+        contents: [{
+          parts: [
+            { text: prompt },
+            {
+              file_data: {
+                file_uri: url
+              }
+            }
+          ]
+        }]
+      }
+
+      # 追加パラメータをマージ
+      merge_additional_params(request_params, parameters)
+
+      # APIリクエスト
+      response = @client.json_post(
+        path: "models/#{model}:generateContent",
+        parameters: request_params
+      )
+
+      Gemini::Response.new(response)
+    end
+
+    # 小さい動画ファイルをインラインデータとして分析（20MB未満向け）
+    def analyze_inline(file: nil, file_path: nil, prompt:, model: "gemini-2.5-flash", **parameters)
+      # ファイルパスが指定されている場合はファイルを開く
+      if file_path && !file
+        file = File.open(file_path, "rb")
+        close_file = true
+      else
+        close_file = false
+      end
+
+      begin
+        raise ArgumentError, "file or file_path parameter is required" unless file
+
+        # ファイルサイズチェック（20MB = 20 * 1024 * 1024）
+        file.rewind
+        file_size = file.size
+        if file_size > 20 * 1024 * 1024
+          raise ArgumentError, "File size exceeds 20MB. Use analyze method with Files API instead."
+        end
+
+        # MIMEタイプを判定
+        mime_type = parameters.delete(:mime_type) || determine_video_mime_type(file)
+
+        # Base64エンコード
+        file.rewind
+        require 'base64'
+        file_data = Base64.strict_encode64(file.read)
+
+        # リクエストパラメータを構築
+        request_params = {
+          contents: [{
+            parts: [
+              { text: prompt },
+              {
+                inline_data: {
+                  mime_type: mime_type,
+                  data: file_data
+                }
+              }
+            ]
+          }]
+        }
+
+        # 追加パラメータをマージ
+        merge_additional_params(request_params, parameters)
+
+        # APIリクエスト
+        response = @client.json_post(
+          path: "models/#{model}:generateContent",
+          parameters: request_params
+        )
+
+        Gemini::Response.new(response)
+      ensure
+        file.close if file && close_file
+      end
+    end
+
+    # 動画の説明を取得するヘルパーメソッド
+    def describe(file: nil, file_path: nil, file_uri: nil, youtube_url: nil, model: "gemini-2.5-flash", language: "ja", **parameters)
+      prompt = language == "ja" ? "この動画の内容を詳しく説明してください。" : "Describe this video in detail."
+
+      if youtube_url
+        analyze_youtube(url: youtube_url, prompt: prompt, model: model, **parameters)
+      elsif file_uri
+        analyze_with_file_uri(file_uri: file_uri, prompt: prompt, model: model, **parameters)
+      elsif file || file_path
+        result = analyze(file: file, file_path: file_path, prompt: prompt, model: model, **parameters)
+        result[:response]
+      else
+        raise ArgumentError, "file, file_path, file_uri, or youtube_url is required"
+      end
+    end
+
+    # タイムスタンプを抽出するヘルパーメソッド
+    def extract_timestamps(file: nil, file_path: nil, file_uri: nil, youtube_url: nil, query:, model: "gemini-2.5-flash", **parameters)
+      prompt = "動画内で「#{query}」が登場するタイムスタンプを全て抽出してください。MM:SS形式で出力してください。"
+
+      if youtube_url
+        analyze_youtube(url: youtube_url, prompt: prompt, model: model, **parameters)
+      elsif file_uri
+        analyze_with_file_uri(file_uri: file_uri, prompt: prompt, model: model, **parameters)
+      elsif file || file_path
+        result = analyze(file: file, file_path: file_path, prompt: prompt, model: model, **parameters)
+        result[:response]
+      else
+        raise ArgumentError, "file, file_path, file_uri, or youtube_url is required"
+      end
+    end
+
+    # 動画のセグメント（一部分）を分析
+    def analyze_segment(file_uri:, prompt:, start_offset: nil, end_offset: nil, model: "gemini-2.5-flash", mime_type: "video/mp4", **parameters)
+      # videoMetadataを構築
+      video_metadata = {}
+      video_metadata[:startOffset] = start_offset if start_offset
+      video_metadata[:endOffset] = end_offset if end_offset
+
+      # リクエストパラメータを構築
+      file_data_part = {
+        file_data: {
+          mime_type: mime_type,
+          file_uri: file_uri
+        }
+      }
+      file_data_part[:file_data][:video_metadata] = video_metadata unless video_metadata.empty?
+
+      request_params = {
+        contents: [{
+          parts: [
+            { text: prompt },
+            file_data_part
+          ]
+        }]
+      }
+
+      # 追加パラメータをマージ
+      merge_additional_params(request_params, parameters)
+
+      # APIリクエスト
+      response = @client.json_post(
+        path: "models/#{model}:generateContent",
+        parameters: request_params
+      )
+
+      Gemini::Response.new(response)
+    end
+
+    # 動画に関する質問に回答
+    def ask(file: nil, file_path: nil, file_uri: nil, youtube_url: nil, question:, model: "gemini-2.5-flash", **parameters)
+      if youtube_url
+        analyze_youtube(url: youtube_url, prompt: question, model: model, **parameters)
+      elsif file_uri
+        analyze_with_file_uri(file_uri: file_uri, prompt: question, model: model, **parameters)
+      elsif file || file_path
+        result = analyze(file: file, file_path: file_path, prompt: question, model: model, **parameters)
+        result[:response]
+      else
+        raise ArgumentError, "file, file_path, file_uri, or youtube_url is required"
+      end
+    end
+
+    private
+
+    # 動画コンテンツを生成する共通メソッド（生のレスポンスを返す）
+    def generate_video_content(file_uri:, mime_type:, prompt:, model:, **parameters)
+      request_params = {
+        contents: [{
+          parts: [
+            { text: prompt },
+            {
+              file_data: {
+                mime_type: mime_type,
+                file_uri: file_uri
+              }
+            }
+          ]
+        }]
+      }
+
+      # 追加パラメータをマージ
+      merge_additional_params(request_params, parameters)
+
+      # APIリクエスト（生のレスポンスを返す）
+      @client.json_post(
+        path: "models/#{model}:generateContent",
+        parameters: request_params
+      )
+    end
+
+    # 追加パラメータをマージするヘルパー
+    def merge_additional_params(request_params, parameters)
+      parameters.each do |key, value|
+        next if key == :contents
+        request_params[key] = value
+      end
+    end
+
+    # YouTube URLのバリデーション
+    def valid_youtube_url?(url)
+      youtube_patterns = [
+        %r{^https?://(?:www\.)?youtube\.com/watch\?v=[\w-]+},
+        %r{^https?://youtu\.be/[\w-]+},
+        %r{^https?://(?:www\.)?youtube\.com/embed/[\w-]+},
+        %r{^https?://(?:www\.)?youtube\.com/v/[\w-]+},
+        %r{^https?://(?:www\.)?youtube\.com/shorts/[\w-]+}
+      ]
+      youtube_patterns.any? { |pattern| url.match?(pattern) }
+    end
+
+    # ファイルがACTIVE状態になるまで待機するメソッド
+    def wait_for_file_active(file_name, max_attempts: 30, interval: 2)
+      attempts = 0
+      loop do
+        file_info = @client.files.get(name: file_name)
+        state = file_info["state"]
+
+        case state
+        when "ACTIVE"
+          return true
+        when "FAILED"
+          raise StandardError, "File processing failed: #{file_info['error']&.dig('message') || 'Unknown error'}"
+        else
+          # PROCESSING状態の場合は待機
+          attempts += 1
+          if attempts >= max_attempts
+            raise StandardError, "File processing timeout. File is still in #{state} state after #{max_attempts * interval} seconds."
+          end
+          sleep(interval)
+        end
+      end
+    end
+
+    # 動画のMIMEタイプを判定するヘルパーメソッド
+    def determine_video_mime_type(file)
+      return "video/mp4" unless file.respond_to?(:path)
+
+      ext = File.extname(file.path).downcase
+      case ext
+      when ".mp4"
+        "video/mp4"
+      when ".mpeg", ".mpg"
+        "video/mpeg"
+      when ".mov"
+        "video/quicktime"
+      when ".avi"
+        "video/x-msvideo"
+      when ".flv"
+        "video/x-flv"
+      when ".webm"
+        "video/webm"
+      when ".wmv"
+        "video/x-ms-wmv"
+      when ".3gp", ".3gpp"
+        "video/3gpp"
+      else
+        # デフォルトはMP4
+        "video/mp4"
+      end
+    end
+  end
+end

data/lib/gemini.rb

@@ -19,6 +19,7 @@ require_relative "gemini/images"
 require_relative "gemini/response"
 require_relative "gemini/documents"
 require_relative "gemini/cached_content"
+require_relative "gemini/video"
 module Gemini
   class Error < StandardError; end
   class ConfigurationError < Error; end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ruby-gemini-api
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.6
 platform: ruby
 authors:
 - rira100000000
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-11-07 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -163,6 +162,7 @@ files:
 - lib/gemini/threads.rb
 - lib/gemini/tool_definition.rb
 - lib/gemini/version.rb
+- lib/gemini/video.rb
 - lib/ruby/gemini.rb
 homepage: https://github.com/rira100000000/ruby-gemini-api
 licenses:
@@ -172,7 +172,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 +186,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: []