genai-rb 0.0.2 → 0.2.0

data/lib/genai/model.rb

@@ -1,234 +1,183 @@
 require "net/http"
 require "json"
 require "uri"
-require 'base64'
-require 'cgi'
 
 module Genai
   class Model
     attr_reader :client, :model_id
-    
+
+    OPENAI_ROLES = {
+      "model" => "assistant",
+      "assistant" => "assistant",
+      "user" => "user",
+      "system" => "system",
+      "developer" => "developer",
+      "tool" => "tool"
+    }.freeze
+
     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)
+      raise Error, "grounding is not supported by OpenAI-compatible chat completions." if grounding
+
+      request_body = build_request_body(contents: contents, 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)
+        model: model_id,
+        messages: normalize_messages(contents)
       }
-      
+
+      body.merge!(normalize_config(config))
       body[:tools] = normalize_tools(tools) if tools
-      body[:generationConfig] = normalize_config(config) if config
-      
-      options.each { |key, value| body[key] = value }
-      
+      body.merge!(normalize_config(options))
       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]
+
+    def normalize_messages(contents)
+      case contents
+      when String
+        [message_from_value(contents)]
+      when Array
+        if contents.all? { |content| openai_message?(content) || parts_message?(content) }
+          contents.map { |content| normalize_message_hash(content) }
         else
-          raise Error, "Invalid contents format: #{contents.class}"
+          [message_from_parts(contents)]
         end
+      when Hash
+        [normalize_message_hash(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) }
+    def message_from_value(value)
+      { role: "user", content: content_from_value(value) }
     end
 
-    def is_base64_image?(text)
-      text.match?(/^data:image\/[a-zA-Z]+;base64,/)
+    def message_from_parts(parts)
+      content = parts.flat_map { |part| Array(content_from_value(part)) }
+      { role: "user", content: compact_content(content) }
     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]}"
+    def normalize_message_hash(message)
+      normalized = stringify_keys(message)
+      role = OPENAI_ROLES.fetch(normalized["role"] || "user") do |unknown_role|
+        raise Error, "Unsupported role for OpenAI-compatible chat completions: #{unknown_role}"
+      end
+
+      if normalized.key?("content")
+        normalized["role"] = role
+        return normalized
+      end
+
+      parts = normalized["parts"]
+      raise Error, "Message hash must include content or parts" unless parts
+
+      {
+        role: role,
+        content: compact_content(parts.flat_map { |part| Array(content_from_part(part)) })
+      }
+    end
+
+    def content_from_value(value)
+      case value
+      when String
+        if image_url?(value) || data_image?(value)
+          { type: "image_url", image_url: { url: value } }
         else
-          "image/jpeg"
+          value
         end
+      when Hash
+        content_from_part(value)
       else
-        "text/plain"
+        raise Error, "Invalid content part format: #{value.class}"
       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
+    def content_from_part(part)
+      normalized = stringify_keys(part)
+
+      return normalized if normalized["type"]
+      return normalized["text"] if normalized.key?("text")
+
+      if normalized["inline_data"]
+        inline_data = normalized["inline_data"]
+        mime_type = inline_data["mime_type"] || inline_data[:mime_type] || "image/jpeg"
+        data = inline_data["data"] || inline_data[:data]
+        return { type: "image_url", image_url: { url: "data:#{mime_type};base64,#{data}" } }
       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}"
+      if normalized["image_url"]
+        image_url = normalized["image_url"]
+        url = image_url.is_a?(Hash) ? image_url["url"] || image_url[:url] : image_url
+        return { type: "image_url", image_url: { url: url } }
       end
+
+      raise Error, "Invalid content part: #{part.inspect}"
     end
-    
-    def normalize_tools(tools)
-      return [] if tools.nil?
-      
-      if tools.is_a?(Array)
-        tools.map { |tool| normalize_tool(tool) }
-      else
-        [normalize_tool(tools)]
+
+    def compact_content(content)
+      flattened = content.flatten
+      return flattened.first if flattened.length == 1 && flattened.first.is_a?(String)
+
+      flattened.map do |part|
+        part.is_a?(String) ? { type: "text", text: part } : part
       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}"
+
+    def normalize_tools(tools)
+      Array(tools).map do |tool|
+        raise Error, "Tool shortcuts are not supported. Pass OpenAI-compatible tool definitions as hashes." unless tool.is_a?(Hash)
+
+        stringify_keys(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"
+      raise Error, "Config must be a Hash" unless config.is_a?(Hash)
+
+      config.each_with_object({}) do |(key, value), normalized|
+        openai_key = case key.to_sym
+                     when :max_output_tokens
+                       :max_tokens
+                     else
+                       key
+                     end
+        normalized[openai_key] = value
       end
     end
-    
+
     def make_request(request_body)
-      uri = URI(client.config.api_url("models/#{model_id}:generateContent"))
+      uri = URI(client.config.api_url("chat/completions"))
       http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = true
+      http.use_ssl = uri.scheme == "https"
       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)
-      
+
+      begin
+        response = http.request(request)
+      rescue OpenSSL::SSL::SSLError => e
+        raise Error, "SSL error while connecting to #{uri.host}:#{uri.port}. If this is a local OpenAI-compatible server, use http:// instead of https:// in base_url. #{e.message}"
+      rescue Net::OpenTimeout, Net::ReadTimeout => e
+        raise Error, "Request timed out while connecting to #{uri.host}:#{uri.port}. Check that the server is running and responding. #{e.message}"
+      rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH, SocketError => e
+        raise Error, "Could not connect to #{uri.host}:#{uri.port}. Check base_url and server status. #{e.message}"
+      end
+
       case response
       when Net::HTTPSuccess
         response
@@ -240,156 +189,41 @@ module Genai
         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
+      choice = data.fetch("choices", []).first
+      return "" unless choice
+
+      message = choice["message"] || {}
+      content = message["content"]
+      return content if content.is_a?(String)
+
+      Array(content).map { |part| part["text"] || part.dig("text", "value") }.compact.join
     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
+
+    def openai_message?(value)
+      value.is_a?(Hash) && (value.key?(:content) || value.key?("content"))
     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
+
+    def parts_message?(value)
+      value.is_a?(Hash) && (value.key?(:parts) || value.key?("parts"))
     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
+
+    def image_url?(text)
+      image_extensions = %w[.jpg .jpeg .png .gif .webp .bmp .tiff]
+      uri = URI.parse(text)
+      uri.is_a?(URI::HTTP) && image_extensions.any? { |ext| uri.path.downcase.end_with?(ext) }
+    rescue URI::InvalidURIError
+      false
+    end
+
+    def data_image?(text)
+      text.match?(/\Adata:image\/[a-zA-Z0-9.+-]+;base64,/)
+    end
+
+    def stringify_keys(hash)
+      hash.each_with_object({}) { |(key, value), result| result[key.to_s] = value }
     end
   end
-end 
+end

data/lib/genai/version.rb

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

data/lib/genai.rb

@@ -1,32 +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 
+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: "gpt-5.5", contents:, **options)
+      self.model(model).generate_content(contents: contents, **options)
+    end
+  end
+  
+  def self.new(**options)
+    Client.new(**options)
+  end
+end