genai-rb 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1aec54cd52a2625f22438e6d5baa1418f71e923ace70ffca6d29e67f3aedc99b
-  data.tar.gz: c5dcdba349bc3930b2d353e43e07e88f2a384db499bafa133722e8d77e376d73
+  metadata.gz: ba4f68bb9f9fb0a8aedbe47bc8e81f2859f7418f049a6d9610b7f32982a09e0f
+  data.tar.gz: '08bb6995fb0b749cdadde7a6be83373c53db9033ec03b8d8bc5228cf7f74ed4a'
 SHA512:
-  metadata.gz: 8df382a222223835262b53fa5175b569610b10042c113c2b0e40184aef851db017b51afb450911cb461d9d4b47ec5c01346ffceb4d751f36d83e9b55c6f123b1
-  data.tar.gz: d3d6a35dbbf0896c424e4a29aa9d8bbd25bb11632fb388c71449efcf0cde702a653149b2b38509f54d4d5442d920a184401f5ebf07cb58a9e607b72f4bee545c
+  metadata.gz: 6fb0326f7a91add9c63a3fc1876b0360345bb6176763b708fca4a7c1a9408a77c0d422ad658fce4127458a876cb8727a67eccbb4c71f1ebe60704eacd519cf84
+  data.tar.gz: 4ebf4cfc65b6d21be25ced6dc666795b4110e9d4adc3d2538e32760bbf69e8af61cdb441fd692e98969aef51993a05c3da04f7f7be209334f15903fc9995e940

data/CHANGELOG.md

@@ -1,10 +1,5 @@
-## [Release]
-
-## [0.0.2] - 2025-08-16 (Me gustas tu)
-
-- Fix typos
-- Add support for Korean Unicode decoding
-
-## [0.0.1] - 2025-08-15 (Glass Bead)
-
+## [Release]
+
+## [0.1.0] - 2025-08-16 (Glass Bead)
+
 - Initial release

data/LICENSE.txt

@@ -1,21 +1,21 @@
-The MIT License (MIT)
-
-Copyright (c) 2025 Siruu580
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
+The MIT License (MIT)
+
+Copyright (c) 2025 Siruu580
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -1,107 +1,107 @@
-
-# Genai
-
-An unofficial Ruby package for Google Gemini. Easily generate text and images, analyze web content, and integrate Google Search—all with a simple Ruby API.
-
-## Installation
-
-Add to your Gemfile:
-
-```ruby
-gem 'genai-rb'
-```
-
-Then run:
-
-```bash
-bundle install
-```
-
-Or install directly:
-
-```bash
-gem install genai-rb
-```
-
-## Usage
-
-### Setup
-
-Get your Gemini API key from [Google AI Studio](https://makersuite.google.com/app/apikey).
-
-Set your API key:
-
-```bash
-export GEMINI_API_KEY="api_key"
-```
-
-Or pass it directly:
-
-```ruby
-require 'genai'
-client = Genai.new(api_key: "api_key")
-```
-
-### Text Generation
-
-```ruby
-response = client.generate_content(contents: "Hello, how are you?")
-puts response
-```
-
-### Use a Specific Model
-
-```ruby
-response = client.generate_content(model_id: "gemini-2.5-flash", contents: "Explain quantum computing.")
-```
-
-### URL Context
-
-```ruby
-response = client.generate_content(contents: "Summarize: https://example.com/article", tools: [:url_context])
-```
-
-### Google Search Integration
-
-```ruby
-response = client.generate_content(contents: "Latest AI news?", tools: [:google_search, :url_context])
-```
-
-### Advanced Configuration
-
-```ruby
-client = Genai.new(api_key: "api_key", timeout: 120, max_retries: 5)
-response = client.model("gemini-2.0-flash").generate_content(
-  contents: "Write a creative story about a robot learning to paint",
-  config: { temperature: 0.8, max_output_tokens: 1000 }
-)
-```
-
-### Model Instances
-
-```ruby
-model = client.model("gemini-2.5-flash")
-response = model.generate_content(contents: "Explain the benefits of renewable energy")
-```
-
-## Supported Models
-
-- All Gemini models
-
-## Features
-
-- Text and image generation
-- URL context analysis
-- Google Search integration
-- Multiple model support
-- Customizable generation config
-- Robust error handling and retry logic
-- Simple, intuitive Ruby API
-
-## Contributing
-
-Pull requests are always welcome.
-
-## License
-
+
+# Genai
+
+An unofficial Ruby package for Google Gemini. Easily generate text and images, analyze web content, and integrate Google Search—all with a simple Ruby API.
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem 'genai-rb'
+```
+
+Then run:
+
+```bash
+bundle install
+```
+
+Or install directly:
+
+```bash
+gem install genai-rb
+```
+
+## Usage
+
+### Setup
+
+Get your Gemini API key from [Google AI Studio](https://makersuite.google.com/app/apikey).
+
+Set your API key:
+
+```bash
+export GEMINI_API_KEY="api_key"
+```
+
+Or pass it directly:
+
+```ruby
+require 'genai'
+client = Genai.new(api_key: "api_key")
+```
+
+### Text Generation
+
+```ruby
+response = client.generate_content(contents: "Hello, how are you?")
+puts response
+```
+
+### Use a Specific Model
+
+```ruby
+response = client.generate_content(model_id: "gemini-2.5-flash", contents: "Explain quantum computing.")
+```
+
+### URL Context
+
+```ruby
+response = client.generate_content(contents: "Summarize: https://example.com/article", tools: [:url_context])
+```
+
+### Google Search Integration
+
+```ruby
+response = client.generate_content(contents: "Latest AI news?", tools: [:google_search, :url_context])
+```
+
+### Advanced Configuration
+
+```ruby
+client = Genai.new(api_key: "api_key", timeout: 120, max_retries: 5)
+response = client.model("gemini-2.0-flash").generate_content(
+  contents: "Write a creative story about a robot learning to paint",
+  config: { temperature: 0.8, max_output_tokens: 1000 }
+)
+```
+
+### Model Instances
+
+```ruby
+model = client.model("gemini-2.5-flash")
+response = model.generate_content(contents: "Explain the benefits of renewable energy")
+```
+
+## Supported Models
+
+- All Gemini models
+
+## Features
+
+- Text and image generation
+- URL context analysis
+- Google Search integration
+- Multiple model support
+- Customizable generation config
+- Robust error handling and retry logic
+- Simple, intuitive Ruby API
+
+## Contributing
+
+Pull requests are always welcome.
+
+## License
+
 Open source under the [MIT License](https://opensource.org/licenses/MIT).

data/lib/genai/chat.rb

@@ -1,19 +1,4 @@
-# Copyright 2025 Google LLC
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
 module Genai
-  # Chat history validation methods
   module ChatValidator
     def self.validate_content(content)
       return false unless content[:parts] && !content[:parts].empty?
@@ -85,7 +70,6 @@ module Genai
       @model = model
       @config = config
       
-      # Convert history items to proper format
       content_models = history.map do |content|
         content.is_a?(Hash) ? content : content
       end
@@ -95,22 +79,17 @@ module Genai
     end
 
     def record_history(user_input:, model_output:, automatic_function_calling_history: [], is_valid: true)
-      # Extract input contents from automatic function calling history or use user input
       input_contents = if !automatic_function_calling_history.empty?
-        # Deduplicate existing chat history from AFC history
         automatic_function_calling_history[@curated_history.length..-1] || [user_input]
       else
         [user_input]
       end
       
-      # Use model output or create empty content if no output
       output_contents = model_output.empty? ? [{ role: "model", parts: [] }] : model_output
       
-      # Update comprehensive history
       @comprehensive_history.concat(input_contents)
       @comprehensive_history.concat(output_contents)
       
-      # Update curated history only if valid
       if is_valid
         @curated_history.concat(input_contents)
         @curated_history.concat(output_contents)
@@ -129,7 +108,6 @@ module Genai
     end
 
     def send_message(message, config: nil)
-      # Convert message to proper content format
       input_content = case message
       when String
         { role: "user", parts: [{ text: message }] }
@@ -141,24 +119,20 @@ module Genai
         raise ArgumentError, "Message must be a String, Array, or Hash"
       end
 
-      # Generate content using the model
       model_instance = @client.model(@model)
       response = model_instance.generate_content(
         contents: @curated_history + [input_content],
         config: config || @config
       )
 
-      # Extract model output from response
       model_output = if response[:candidates] && !response[:candidates].empty? && response[:candidates][0][:content]
         [response[:candidates][0][:content]]
       else
         []
       end
 
-      # Get automatic function calling history if available
       automatic_function_calling_history = response[:automatic_function_calling_history] || []
 
-      # Record the conversation in history
       record_history(
         user_input: input_content,
         model_output: model_output,
@@ -170,7 +144,6 @@ module Genai
     end
 
     def send_message_stream(message, config: nil)
-      # Convert message to proper content format
       input_content = case message
       when String
         { role: "user", parts: [{ text: message }] }
@@ -182,8 +155,7 @@ module Genai
         raise ArgumentError, "Message must be a String, Array, or Hash"
       end
 
-      # This would need to be implemented in the Model class to support streaming
-      # For now, we'll use regular send_message
+
       send_message(message, config: config)
     end
   end
@@ -198,9 +170,7 @@ module Genai
       Chat.new(client: @client, model: model, config: config, history: history)
     end
 
-    # 사용자별 세션 관리 메소드들
     def get_user_session(user_id, model: "gemini-2.0-flash", config: nil)
-      # 사용자별 세션이 없으면 새로 생성
       unless @user_sessions[user_id]
         @user_sessions[user_id] = create(
           model: model,

data/lib/genai/model.rb

@@ -1,395 +1,395 @@
-require "net/http"
-require "json"
-require "uri"
-require 'base64'
-require 'cgi'
-
-module Genai
-  class Model
-    attr_reader :client, :model_id
-    
-    def initialize(client, model_id)
-      @client = client
-      @model_id = model_id
-    end
-    
-    def generate_content(contents:, tools: nil, config: nil, grounding: nil, **options)
-      tools = Array(tools).dup if tools
-      if grounding
-        if grounding.is_a?(Hash) && grounding[:dynamic_threshold]
-          tools ||= []
-          tools << self.class.grounding_with_dynamic_threshold(grounding[:dynamic_threshold])
-        else
-          tools ||= []
-          tools << self.class.grounding_tool
-        end
-      end
-      
-      contents_with_urls = extract_and_add_urls(contents)
-      request_body = build_request_body(contents: contents_with_urls, tools: tools, config: config, **options)
-      response = make_request(request_body)
-      parse_response(response)
-    end
-
-    def self.grounding_tool
-      { google_search: {} }
-    end
-
-    def self.grounding_with_dynamic_threshold(threshold)
-      {
-        google_search_retrieval: {
-          dynamic_retrieval_config: {
-            mode: "MODE_DYNAMIC",
-            dynamic_threshold: threshold
-          }
-        }
-      }
-    end
-    
-    private
-    
-    def extract_and_add_urls(contents)
-      if contents.is_a?(String)
-        urls = extract_urls_from_text(contents)
-        if urls.any?
-          return [
-            { role: "user", parts: [{ text: contents }] },
-            *urls.map { |url| { role: "user", parts: [{ text: url }] } }
-          ]
-        end
-      end
-      contents
-    end
-    
-    def extract_urls_from_text(text)
-      url_pattern = /https?:\/\/[^\s]+/
-      text.scan(url_pattern)
-    end
-    
-    def build_request_body(contents:, tools: nil, config: nil, **options)
-      body = {
-        contents: normalize_contents(contents)
-      }
-      
-      body[:tools] = normalize_tools(tools) if tools
-      body[:generationConfig] = normalize_config(config) if config
-      
-      options.each { |key, value| body[key] = value }
-      
-      body
-    end
-    
-    def normalize_contents(contents)
-      if contents.is_a?(String)
-        if is_image_url?(contents) || is_base64_image?(contents)
-          [{ role: "user", parts: [{ inline_data: { mime_type: detect_mime_type(contents), data: extract_image_data(contents) } }] }]
-        else
-          [{ role: "user", parts: [{ text: contents }] }]
-        end
-      elsif contents.is_a?(Array)
-        contents.map do |content|
-          if content.is_a?(String)
-            if is_image_url?(content) || is_base64_image?(content)
-              { role: "user", parts: [{ inline_data: { mime_type: detect_mime_type(content), data: extract_image_data(content) } }] }
-            else
-              { role: "user", parts: [{ text: content }] }
-            end
-          elsif content.is_a?(Hash)
-            content[:role] ||= "user"
-            content
-          else
-            raise Error, "Invalid content format: #{content.class}"
-          end
-        end
-              elsif contents.is_a?(Hash)
-          contents[:role] ||= "user"
-          [contents]
-        else
-          raise Error, "Invalid contents format: #{contents.class}"
-        end
-    end
-
-    def is_image_url?(text)
-      image_extensions = %w[.jpg .jpeg .png .gif .webp .bmp .tiff]
-      text.match?(/^https?:\/\/.+/i) && image_extensions.any? { |ext| text.downcase.include?(ext) }
-    end
-
-    def is_base64_image?(text)
-      text.match?(/^data:image\/[a-zA-Z]+;base64,/)
-    end
-
-    def detect_mime_type(content)
-      if is_image_url?(content)
-        case content.downcase
-        when /\.(jpg|jpeg)$/
-          "image/jpeg"
-        when /\.png$/
-          "image/png"
-        when /\.gif$/
-          "image/gif"
-        when /\.webp$/
-          "image/webp"
-        when /\.bmp$/
-          "image/bmp"
-        when /\.tiff$/
-          "image/tiff"
-        else
-          "image/jpeg"
-        end
-      elsif is_base64_image?(content)
-        match = content.match(/^data:image\/([a-zA-Z]+);base64,/)
-        if match
-          "image/#{match[1]}"
-        else
-          "image/jpeg"
-        end
-      else
-        "text/plain"
-      end
-    end
-
-    def extract_image_data(content)
-      if is_image_url?(content)
-        download_and_encode_image(content)
-      elsif is_base64_image?(content)
-        content.match(/^data:image\/[a-zA-Z]+;base64,(.+)$/)[1]
-      else
-        content
-      end
-    end
-
-    def download_and_encode_image(url)
-      begin
-        uri = URI(url)
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl = true if uri.scheme == 'https'
-        http.open_timeout = 10
-        http.read_timeout = 10
-        
-        request = Net::HTTP::Get.new(uri)
-        request['User-Agent'] = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
-        
-        response = http.request(request)
-        
-        if response.is_a?(Net::HTTPSuccess)
-          Base64.strict_encode64(response.body)
-        else
-          raise Error, "Failed to download image: #{response.code}"
-        end
-      rescue => e
-        raise Error, "Error downloading image: #{e.message}"
-      end
-    end
-    
-    def normalize_tools(tools)
-      return [] if tools.nil?
-      
-      if tools.is_a?(Array)
-        tools.map { |tool| normalize_tool(tool) }
-      else
-        [normalize_tool(tools)]
-      end
-    end
-    
-    def normalize_tool(tool)
-      case tool
-      when Hash
-        tool
-      when :url_context, "url_context"
-        { url_context: {} }
-      when :google_search, "google_search"
-        { google_search: {} }
-      when :google_search_retrieval, "google_search_retrieval"
-        { google_search_retrieval: {} }
-      else
-        raise Error, "Unknown tool: #{tool}"
-      end
-    end
-    
-    def normalize_config(config)
-      return {} if config.nil?
-      
-      if config.is_a?(Hash)
-        config
-      else
-        raise Error, "Config must be a Hash"
-      end
-    end
-    
-    def make_request(request_body)
-      uri = URI(client.config.api_url("models/#{model_id}:generateContent"))
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = true
-      http.open_timeout = client.config.timeout
-      http.read_timeout = client.config.timeout
-      
-      request = Net::HTTP::Post.new(uri)
-      client.config.headers.each { |key, value| request[key] = value }
-      request.body = request_body.to_json
-      
-      response = http.request(request)
-      
-      case response
-      when Net::HTTPSuccess
-        response
-      when Net::HTTPClientError
-        raise Error, "Client error: #{response.code} - #{response.body}"
-      when Net::HTTPServerError
-        raise Error, "Server error: #{response.code} - #{response.body}"
-      else
-        raise Error, "Unexpected response: #{response.code} - #{response.body}"
-      end
-    end
-    
-    def parse_response(response)
-      data = JSON.parse(response.body)
-      
-      candidates = data["candidates"] || []
-      return "" if candidates.empty?
-      
-      content = candidates.first["content"]
-      parts = content["parts"] || []
-      
-      text_parts = parts.map { |part| part["text"] }.compact
-      text = text_parts.join
-      
-      if candidates.first["groundingMetadata"]
-        grounding_info = candidates.first["groundingMetadata"]
-        if grounding_info["groundingChunks"]
-          text += "\n\n참고한 URL:\n"
-          grounding_info["groundingChunks"].each_with_index do |chunk, index|
-            if chunk["web"]
-              original_url = extract_original_url(chunk["web"]["uri"])
-              decoded_url = original_url.gsub(/\\u([0-9a-fA-F]{4})/) { |m| [$1.to_i(16)].pack('U') }
-              decoded_url = CGI.unescape(decoded_url)
-              encoded_url = decoded_url.gsub(' ', '%20')
-              text += "#{index + 1}. #{encoded_url}\n"
-            end
-          end
-        end
-      end
-      
-      text
-    end
-    
-    def extract_original_url(redirect_url)
-      return redirect_url unless redirect_url.include?("vertexaisearch.cloud.google.com")
-      
-      final_url = follow_redirects(redirect_url)
-      return final_url if final_url && final_url != redirect_url
-      
-      begin
-        uri = URI(redirect_url)
-        
-        path_parts = uri.path.split("/")
-        if path_parts.include?("grounding-api-redirect")
-          encoded_url = path_parts.last
-          
-          decoded_url = try_decode_url(encoded_url)
-          return decoded_url if decoded_url && decoded_url.start_with?("http")
-        end
-        
-        if uri.query
-          params = URI.decode_www_form(uri.query)
-          original_url = params.find { |k, v| k == "url" || k == "original_url" || k == "target" }&.last
-          return original_url if original_url && original_url.start_with?("http")
-        end
-        
-        if uri.query && uri.query.include?("http")
-          url_match = uri.query.match(/https?:\/\/[^\s&]+/)
-          return url_match[0] if url_match
-        end
-        
-        if ENV['DEBUG']
-          puts "URL 파싱 실패 - 구조:"
-          puts "  전체 URL: #{redirect_url}"
-          puts "  경로: #{uri.path}"
-          puts "  쿼리: #{uri.query}"
-          puts "  인코딩된 부분: #{path_parts.last}" if path_parts.last
-        end
-        
-      rescue => e
-        puts "URL 파싱 오류: #{e.message}" if ENV['DEBUG']
-      end
-      
-      redirect_url
-    end
-    
-    def follow_redirects(url, max_redirects = 5)
-      current_url = url
-      redirect_count = 0
-      
-      while redirect_count < max_redirects
-        begin
-          uri = URI(current_url)
-          http = Net::HTTP.new(uri.host, uri.port)
-          http.use_ssl = true if uri.scheme == 'https'
-          http.open_timeout = 10
-          http.read_timeout = 10
-          
-          request = Net::HTTP::Get.new(uri)
-          request['User-Agent'] = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
-          
-          response = http.request(request)
-          
-          case response
-          when Net::HTTPRedirection
-            redirect_count += 1
-            location = response['location']
-            if location
-              if location.start_with?('/')
-                current_url = "#{uri.scheme}://#{uri.host}#{location}"
-              elsif location.start_with?('http')
-                current_url = location
-              else
-                current_url = "#{uri.scheme}://#{uri.host}/#{location}"
-              end
-            else
-              break
-            end
-          else
-            return current_url
-          end
-        rescue => e
-          puts "리다이렉트 추적 오류: #{e.message}" if ENV['DEBUG']
-          return url
-        end
-      end
-      
-      current_url
-    end
-    
-    def try_decode_url(encoded_url)
-      begin
-        require 'base64'
-        decoded_bytes = Base64.urlsafe_decode64(encoded_url)
-        decoded_url = decoded_bytes.force_encoding('UTF-8')
-        return decoded_url if decoded_url.start_with?("http")
-      rescue
-      end
-      
-      begin
-        decoded_bytes = Base64.decode64(encoded_url)
-        decoded_url = decoded_bytes.force_encoding('UTF-8')
-        return decoded_url if decoded_url.start_with?("http")
-      rescue
-      end
-      
-      begin
-        decoded_url = URI.decode(encoded_url)
-        return decoded_url if decoded_url.start_with?("http")
-      rescue
-      end
-      
-      begin
-        padded_url = encoded_url + "=" * (4 - encoded_url.length % 4)
-        decoded_bytes = Base64.decode64(padded_url)
-        decoded_url = decoded_bytes.force_encoding('UTF-8')
-        return decoded_url if decoded_url.start_with?("http")
-      rescue
-      end
-      
-      nil
-    end
-  end
+require "net/http"
+require "json"
+require "uri"
+require 'base64'
+require 'cgi'
+
+module Genai
+  class Model
+    attr_reader :client, :model_id
+    
+    def initialize(client, model_id)
+      @client = client
+      @model_id = model_id
+    end
+    
+    def generate_content(contents:, tools: nil, config: nil, grounding: nil, **options)
+      tools = Array(tools).dup if tools
+      if grounding
+        if grounding.is_a?(Hash) && grounding[:dynamic_threshold]
+          tools ||= []
+          tools << self.class.grounding_with_dynamic_threshold(grounding[:dynamic_threshold])
+        else
+          tools ||= []
+          tools << self.class.grounding_tool
+        end
+      end
+      
+      contents_with_urls = extract_and_add_urls(contents)
+      request_body = build_request_body(contents: contents_with_urls, tools: tools, config: config, **options)
+      response = make_request(request_body)
+      parse_response(response)
+    end
+
+    def self.grounding_tool
+      { google_search: {} }
+    end
+
+    def self.grounding_with_dynamic_threshold(threshold)
+      {
+        google_search_retrieval: {
+          dynamic_retrieval_config: {
+            mode: "MODE_DYNAMIC",
+            dynamic_threshold: threshold
+          }
+        }
+      }
+    end
+    
+    private
+    
+    def extract_and_add_urls(contents)
+      if contents.is_a?(String)
+        urls = extract_urls_from_text(contents)
+        if urls.any?
+          return [
+            { role: "user", parts: [{ text: contents }] },
+            *urls.map { |url| { role: "user", parts: [{ text: url }] } }
+          ]
+        end
+      end
+      contents
+    end
+    
+    def extract_urls_from_text(text)
+      url_pattern = /https?:\/\/[^\s]+/
+      text.scan(url_pattern)
+    end
+    
+    def build_request_body(contents:, tools: nil, config: nil, **options)
+      body = {
+        contents: normalize_contents(contents)
+      }
+      
+      body[:tools] = normalize_tools(tools) if tools
+      body[:generationConfig] = normalize_config(config) if config
+      
+      options.each { |key, value| body[key] = value }
+      
+      body
+    end
+    
+    def normalize_contents(contents)
+      if contents.is_a?(String)
+        if is_image_url?(contents) || is_base64_image?(contents)
+          [{ role: "user", parts: [{ inline_data: { mime_type: detect_mime_type(contents), data: extract_image_data(contents) } }] }]
+        else
+          [{ role: "user", parts: [{ text: contents }] }]
+        end
+      elsif contents.is_a?(Array)
+        contents.map do |content|
+          if content.is_a?(String)
+            if is_image_url?(content) || is_base64_image?(content)
+              { role: "user", parts: [{ inline_data: { mime_type: detect_mime_type(content), data: extract_image_data(content) } }] }
+            else
+              { role: "user", parts: [{ text: content }] }
+            end
+          elsif content.is_a?(Hash)
+            content[:role] ||= "user"
+            content
+          else
+            raise Error, "Invalid content format: #{content.class}"
+          end
+        end
+              elsif contents.is_a?(Hash)
+          contents[:role] ||= "user"
+          [contents]
+        else
+          raise Error, "Invalid contents format: #{contents.class}"
+        end
+    end
+
+    def is_image_url?(text)
+      image_extensions = %w[.jpg .jpeg .png .gif .webp .bmp .tiff]
+      text.match?(/^https?:\/\/.+/i) && image_extensions.any? { |ext| text.downcase.include?(ext) }
+    end
+
+    def is_base64_image?(text)
+      text.match?(/^data:image\/[a-zA-Z]+;base64,/)
+    end
+
+    def detect_mime_type(content)
+      if is_image_url?(content)
+        case content.downcase
+        when /\.(jpg|jpeg)$/
+          "image/jpeg"
+        when /\.png$/
+          "image/png"
+        when /\.gif$/
+          "image/gif"
+        when /\.webp$/
+          "image/webp"
+        when /\.bmp$/
+          "image/bmp"
+        when /\.tiff$/
+          "image/tiff"
+        else
+          "image/jpeg"
+        end
+      elsif is_base64_image?(content)
+        match = content.match(/^data:image\/([a-zA-Z]+);base64,/)
+        if match
+          "image/#{match[1]}"
+        else
+          "image/jpeg"
+        end
+      else
+        "text/plain"
+      end
+    end
+
+    def extract_image_data(content)
+      if is_image_url?(content)
+        download_and_encode_image(content)
+      elsif is_base64_image?(content)
+        content.match(/^data:image\/[a-zA-Z]+;base64,(.+)$/)[1]
+      else
+        content
+      end
+    end
+
+    def download_and_encode_image(url)
+      begin
+        uri = URI(url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true if uri.scheme == 'https'
+        http.open_timeout = 10
+        http.read_timeout = 10
+        
+        request = Net::HTTP::Get.new(uri)
+        request['User-Agent'] = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+        
+        response = http.request(request)
+        
+        if response.is_a?(Net::HTTPSuccess)
+          Base64.strict_encode64(response.body)
+        else
+          raise Error, "Failed to download image: #{response.code}"
+        end
+      rescue => e
+        raise Error, "Error downloading image: #{e.message}"
+      end
+    end
+    
+    def normalize_tools(tools)
+      return [] if tools.nil?
+      
+      if tools.is_a?(Array)
+        tools.map { |tool| normalize_tool(tool) }
+      else
+        [normalize_tool(tools)]
+      end
+    end
+    
+    def normalize_tool(tool)
+      case tool
+      when Hash
+        tool
+      when :url_context, "url_context"
+        { url_context: {} }
+      when :google_search, "google_search"
+        { google_search: {} }
+      when :google_search_retrieval, "google_search_retrieval"
+        { google_search_retrieval: {} }
+      else
+        raise Error, "Unknown tool: #{tool}"
+      end
+    end
+    
+    def normalize_config(config)
+      return {} if config.nil?
+      
+      if config.is_a?(Hash)
+        config
+      else
+        raise Error, "Config must be a Hash"
+      end
+    end
+    
+    def make_request(request_body)
+      uri = URI(client.config.api_url("models/#{model_id}:generateContent"))
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      http.open_timeout = client.config.timeout
+      http.read_timeout = client.config.timeout
+      
+      request = Net::HTTP::Post.new(uri)
+      client.config.headers.each { |key, value| request[key] = value }
+      request.body = request_body.to_json
+      
+      response = http.request(request)
+      
+      case response
+      when Net::HTTPSuccess
+        response
+      when Net::HTTPClientError
+        raise Error, "Client error: #{response.code} - #{response.body}"
+      when Net::HTTPServerError
+        raise Error, "Server error: #{response.code} - #{response.body}"
+      else
+        raise Error, "Unexpected response: #{response.code} - #{response.body}"
+      end
+    end
+    
+    def parse_response(response)
+      data = JSON.parse(response.body)
+      
+      candidates = data["candidates"] || []
+      return "" if candidates.empty?
+      
+      content = candidates.first["content"]
+      parts = content["parts"] || []
+      
+      text_parts = parts.map { |part| part["text"] }.compact
+      text = text_parts.join
+      
+      if candidates.first["groundingMetadata"]
+        grounding_info = candidates.first["groundingMetadata"]
+        if grounding_info["groundingChunks"]
+          text += "\n\n참고한 URL:\n"
+          grounding_info["groundingChunks"].each_with_index do |chunk, index|
+            if chunk["web"]
+              original_url = extract_original_url(chunk["web"]["uri"])
+              decoded_url = original_url.gsub(/\\u([0-9a-fA-F]{4})/) { |m| [$1.to_i(16)].pack('U') }
+              decoded_url = CGI.unescape(decoded_url)
+              encoded_url = decoded_url.gsub(' ', '%20')
+              text += "#{index + 1}. #{encoded_url}\n"
+            end
+          end
+        end
+      end
+      
+      text
+    end
+    
+    def extract_original_url(redirect_url)
+      return redirect_url unless redirect_url.include?("vertexaisearch.cloud.google.com")
+      
+      final_url = follow_redirects(redirect_url)
+      return final_url if final_url && final_url != redirect_url
+      
+      begin
+        uri = URI(redirect_url)
+        
+        path_parts = uri.path.split("/")
+        if path_parts.include?("grounding-api-redirect")
+          encoded_url = path_parts.last
+          
+          decoded_url = try_decode_url(encoded_url)
+          return decoded_url if decoded_url && decoded_url.start_with?("http")
+        end
+        
+        if uri.query
+          params = URI.decode_www_form(uri.query)
+          original_url = params.find { |k, v| k == "url" || k == "original_url" || k == "target" }&.last
+          return original_url if original_url && original_url.start_with?("http")
+        end
+        
+        if uri.query && uri.query.include?("http")
+          url_match = uri.query.match(/https?:\/\/[^\s&]+/)
+          return url_match[0] if url_match
+        end
+        
+        if ENV['DEBUG']
+          puts "URL 파싱 실패 - 구조:"
+          puts "  전체 URL: #{redirect_url}"
+          puts "  경로: #{uri.path}"
+          puts "  쿼리: #{uri.query}"
+          puts "  인코딩된 부분: #{path_parts.last}" if path_parts.last
+        end
+        
+      rescue => e
+        puts "URL 파싱 오류: #{e.message}" if ENV['DEBUG']
+      end
+      
+      redirect_url
+    end
+    
+    def follow_redirects(url, max_redirects = 5)
+      current_url = url
+      redirect_count = 0
+      
+      while redirect_count < max_redirects
+        begin
+          uri = URI(current_url)
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true if uri.scheme == 'https'
+          http.open_timeout = 10
+          http.read_timeout = 10
+          
+          request = Net::HTTP::Get.new(uri)
+          request['User-Agent'] = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+          
+          response = http.request(request)
+          
+          case response
+          when Net::HTTPRedirection
+            redirect_count += 1
+            location = response['location']
+            if location
+              if location.start_with?('/')
+                current_url = "#{uri.scheme}://#{uri.host}#{location}"
+              elsif location.start_with?('http')
+                current_url = location
+              else
+                current_url = "#{uri.scheme}://#{uri.host}/#{location}"
+              end
+            else
+              break
+            end
+          else
+            return current_url
+          end
+        rescue => e
+          puts "리다이렉트 추적 오류: #{e.message}" if ENV['DEBUG']
+          return url
+        end
+      end
+      
+      current_url
+    end
+    
+    def try_decode_url(encoded_url)
+      begin
+        require 'base64'
+        decoded_bytes = Base64.urlsafe_decode64(encoded_url)
+        decoded_url = decoded_bytes.force_encoding('UTF-8')
+        return decoded_url if decoded_url.start_with?("http")
+      rescue
+      end
+      
+      begin
+        decoded_bytes = Base64.decode64(encoded_url)
+        decoded_url = decoded_bytes.force_encoding('UTF-8')
+        return decoded_url if decoded_url.start_with?("http")
+      rescue
+      end
+      
+      begin
+        decoded_url = URI.decode(encoded_url)
+        return decoded_url if decoded_url.start_with?("http")
+      rescue
+      end
+      
+      begin
+        padded_url = encoded_url + "=" * (4 - encoded_url.length % 4)
+        decoded_bytes = Base64.decode64(padded_url)
+        decoded_url = decoded_bytes.force_encoding('UTF-8')
+        return decoded_url if decoded_url.start_with?("http")
+      rescue
+      end
+      
+      nil
+    end
+  end
 end 

data/lib/genai/version.rb

@@ -1,3 +1,3 @@
-module Genai
-  VERSION = "0.0.2"
+module Genai
+  VERSION = "0.1.0"
 end 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: genai-rb
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Siruu580
@@ -89,5 +89,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.7
 specification_version: 4
-summary: genai for ruby
+summary: gemini module for ruby
 test_files: []