genai-rb 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1aec54cd52a2625f22438e6d5baa1418f71e923ace70ffca6d29e67f3aedc99b
+  data.tar.gz: c5dcdba349bc3930b2d353e43e07e88f2a384db499bafa133722e8d77e376d73
+SHA512:
+  metadata.gz: 8df382a222223835262b53fa5175b569610b10042c113c2b0e40184aef851db017b51afb450911cb461d9d4b47ec5c01346ffceb4d751f36d83e9b55c6f123b1
+  data.tar.gz: d3d6a35dbbf0896c424e4a29aa9d8bbd25bb11632fb388c71449efcf0cde702a653149b2b38509f54d4d5442d920a184401f5ebf07cb58a9e607b72f4bee545c

data/CHANGELOG.md

@@ -0,0 +1,10 @@
+## [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)
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +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.

data/README.md

@@ -0,0 +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
+
+Open source under the [MIT License](https://opensource.org/licenses/MIT).

data/lib/genai/chat.rb

@@ -0,0 +1,233 @@
+# 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?
+      content[:parts].each do |part|
+        return false if part.empty?
+        return false if part[:text] && part[:text].empty?
+      end
+      true
+    end
+
+    def self.validate_contents(contents)
+      return false if contents.empty?
+      contents.each do |content|
+        return false unless validate_content(content)
+      end
+      true
+    end
+
+    def self.validate_response(response)
+      return false unless response[:candidates] && !response[:candidates].empty?
+      return false unless response[:candidates][0][:content]
+      validate_content(response[:candidates][0][:content])
+    end
+
+    def self.extract_curated_history(comprehensive_history)
+      return [] if comprehensive_history.empty?
+      
+      curated_history = []
+      length = comprehensive_history.length
+      i = 0
+      
+      while i < length
+        unless ["user", "model"].include?(comprehensive_history[i][:role])
+          raise ArgumentError, "Role must be user or model, but got #{comprehensive_history[i][:role]}"
+        end
+
+        if comprehensive_history[i][:role] == "user"
+          current_input = comprehensive_history[i]
+          curated_history << current_input
+          i += 1
+        else
+          current_output = []
+          is_valid = true
+          
+          while i < length && comprehensive_history[i][:role] == "model"
+            current_output << comprehensive_history[i]
+            if is_valid && !validate_content(comprehensive_history[i])
+              is_valid = false
+            end
+            i += 1
+          end
+          
+          if is_valid
+            curated_history.concat(current_output)
+          elsif !curated_history.empty?
+            curated_history.pop
+          end
+        end
+      end
+      
+      curated_history
+    end
+  end
+
+  class BaseChat
+    attr_reader :model, :config, :comprehensive_history, :curated_history
+
+    def initialize(model:, config: nil, history: [])
+      @model = model
+      @config = config
+      
+      # Convert history items to proper format
+      content_models = history.map do |content|
+        content.is_a?(Hash) ? content : content
+      end
+      
+      @comprehensive_history = content_models
+      @curated_history = ChatValidator.extract_curated_history(content_models)
+    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)
+      end
+    end
+
+    def get_history(curated: false)
+      curated ? @curated_history : @comprehensive_history
+    end
+  end
+
+  class Chat < BaseChat
+    def initialize(client:, model:, config: nil, history: [])
+      @client = client
+      super(model: model, config: config, history: history)
+    end
+
+    def send_message(message, config: nil)
+      # Convert message to proper content format
+      input_content = case message
+      when String
+        { role: "user", parts: [{ text: message }] }
+      when Array
+        { role: "user", parts: message }
+      when Hash
+        message
+      else
+        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,
+        automatic_function_calling_history: automatic_function_calling_history,
+        is_valid: ChatValidator.validate_response(response)
+      )
+
+      response
+    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 }] }
+      when Array
+        { role: "user", parts: message }
+      when Hash
+        message
+      else
+        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
+
+  class Chats
+    def initialize(client)
+      @client = client
+      @user_sessions = {}
+    end
+
+    def create(model:, config: nil, history: [])
+      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,
+          config: config || {
+            temperature: 0.7,
+            max_output_tokens: 2048
+          }
+        )
+      end
+      
+      @user_sessions[user_id]
+    end
+
+    def clear_user_session(user_id)
+      @user_sessions.delete(user_id)
+    end
+
+    def clear_all_sessions
+      @user_sessions.clear
+    end
+
+    def get_session_count
+      @user_sessions.length
+    end
+
+    def get_active_users
+      @user_sessions.keys
+    end
+  end
+end

data/lib/genai/config.rb

@@ -0,0 +1,32 @@
+require "net/http"
+require "json"
+
+module Genai
+  class Config
+    attr_accessor :api_key, :base_url, :timeout, :max_retries
+    
+    def initialize(api_key: nil, base_url: nil, timeout: 60, max_retries: 3)
+      @api_key = api_key || ENV["GEMINI_API_KEY"]
+      @base_url = base_url || "https://generativelanguage.googleapis.com"
+      @timeout = timeout
+      @max_retries = max_retries
+      
+      validate_config!
+    end
+    
+    def validate_config!
+      raise Error, "API key is required. Set GEMINI_API_KEY environment variable or pass api_key parameter." if @api_key.nil? || @api_key.empty?
+    end
+    
+    def api_url(endpoint)
+      "#{@base_url}/v1beta/#{endpoint}"
+    end
+    
+    def headers
+      {
+        "Content-Type" => "application/json",
+        "x-goog-api-key" => @api_key
+      }
+    end
+  end
+end 

data/lib/genai/model.rb

@@ -0,0 +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
+end 

data/lib/genai/version.rb

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

data/lib/genai.rb

@@ -0,0 +1,32 @@
+require_relative "genai/config"
+require_relative "genai/model"
+require_relative "genai/chat"
+require_relative "genai/version"
+
+module Genai
+  class Error < StandardError; end
+  
+  class Client
+    attr_reader :config
+    
+    def initialize(api_key: nil, **options)
+      @config = Config.new(api_key: api_key, **options)
+    end
+    
+    def model(model_id)
+      Model.new(self, model_id)
+    end
+    
+    def chats
+      Chats.new(self)
+    end
+    
+    def generate_content(model:, contents:, **options)
+      self.model(model).generate_content(contents: contents, **options)
+    end
+  end
+  
+  def self.new(**options)
+    Client.new(**options)
+  end
+end 

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: genai-rb
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Siruu580
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: ''
+email:
+- root@hina.cat
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/genai.rb
+- lib/genai/chat.rb
+- lib/genai/config.rb
+- lib/genai/model.rb
+- lib/genai/version.rb
+homepage: https://github.com/Siruu580/genai
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/Siruu580/genai
+  changelog_uri: https://github.com/Siruu580/genai/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: genai for ruby
+test_files: []