ruby-gemini-api 0.1.0

data/lib/gemini/files.rb

@@ -0,0 +1,149 @@
+module Gemini
+  class Files
+    # Base URL for File API
+    FILE_API_BASE_PATH = "files".freeze
+
+    def initialize(client:)
+      @client = client
+    end
+
+    # Method to upload a file
+    def upload(file:, display_name: nil)
+      # Check if file is valid
+      raise ArgumentError, "No file specified" unless file
+
+      # Get MIME type and size of the file
+      mime_type = determine_mime_type(file)
+      file.rewind
+      file_size = file.size
+
+      # Use filename as display_name if not specified
+      display_name ||= File.basename(file.path) if file.respond_to?(:path)
+      display_name ||= "uploaded_file"
+
+      # Headers for initial upload request (metadata definition)
+      headers = {
+        "X-Goog-Upload-Protocol" => "resumable",
+        "X-Goog-Upload-Command" => "start",
+        "X-Goog-Upload-Header-Content-Length" => file_size.to_s,
+        "X-Goog-Upload-Header-Content-Type" => mime_type,
+        "Content-Type" => "application/json"
+      }
+
+      # Add debug output
+      if ENV["DEBUG"]
+        puts "Request URL: https://generativelanguage.googleapis.com/upload/v1beta/files"
+        puts "Headers: #{headers.inspect}"
+        puts "API Key: #{@client.api_key[0..5]}..." if @client.api_key
+      end
+
+      # Send initial request to get upload URL
+      response = @client.conn.post("https://generativelanguage.googleapis.com/upload/v1beta/files") do |req|
+        req.headers = headers
+        req.params = { key: @client.api_key }
+        req.body = { file: { display_name: display_name } }.to_json
+      end
+
+      # Get upload URL from response headers
+      upload_url = response.headers["x-goog-upload-url"]
+      raise "Failed to obtain upload URL" unless upload_url
+
+      # Upload the file
+      file.rewind
+      file_data = file.read
+      upload_response = @client.conn.post(upload_url) do |req|
+        req.headers = {
+          "Content-Length" => file_size.to_s,
+          "X-Goog-Upload-Offset" => "0",
+          "X-Goog-Upload-Command" => "upload, finalize"
+        }
+        req.body = file_data
+      end
+
+      # Parse response as JSON
+      if upload_response.body.is_a?(String)
+        JSON.parse(upload_response.body)
+      elsif upload_response.body.is_a?(Hash)
+        upload_response.body
+      else
+        raise "Invalid response format: #{upload_response.body.class}"
+      end
+    end
+
+    # Method to get file metadata
+    def get(name:)
+      path = name.start_with?("files/") ? name : "files/#{name}"
+      @client.get(path: path)
+    end
+
+    # Method to get list of uploaded files
+    def list(page_size: nil, page_token: nil)
+      parameters = {}
+      parameters[:pageSize] = page_size if page_size
+      parameters[:pageToken] = page_token if page_token
+
+      @client.get(
+        path: FILE_API_BASE_PATH,
+        parameters: parameters
+      )
+    end
+
+    # Method to delete a file
+    def delete(name:)
+      path = name.start_with?("files/") ? name : "files/#{name}"
+      @client.delete(path: path)
+    end
+
+    private
+
+    # Simple MIME type determination from file extension
+    def determine_mime_type(file)
+      return "application/octet-stream" unless file.respond_to?(:path)
+
+      ext = File.extname(file.path).downcase
+      case ext
+      when ".jpg", ".jpeg"
+        "image/jpeg"
+      when ".png"
+        "image/png"
+      when ".gif"
+        "image/gif"
+      when ".webp"
+        "image/webp"
+      when ".wav"
+        "audio/wav"
+      when ".mp3"
+        "audio/mp3"
+      when ".aiff"
+        "audio/aiff"
+      when ".aac"
+        "audio/aac"
+      when ".ogg"
+        "audio/ogg"
+      when ".flac"
+        "audio/flac"
+      when ".mp4"
+        "video/mp4"
+      when ".avi"
+        "video/avi"
+      when ".mov"
+        "video/quicktime"
+      when ".mkv"
+        "video/x-matroska"
+      when ".pdf"
+        "application/pdf"
+      when ".txt"
+        "text/plain"
+      when ".doc", ".docx"
+        "application/msword"
+      when ".xlsx", ".xls"
+        "application/vnd.ms-excel"
+      when ".pptx", ".ppt"
+        "application/vnd.ms-powerpoint"
+      else
+        # Default value
+        "application/octet-stream"
+      end
+    end
+  end
+end

data/lib/gemini/http.rb

@@ -0,0 +1,226 @@
+require_relative "http_headers"
+
+module Gemini
+  module HTTP
+    include HTTPHeaders
+
+    def get(path:, parameters: nil)
+      # Gemini API requires API key as a parameter
+      params = (parameters || {}).merge(key: @api_key)
+      parse_json(conn.get(uri(path: path), params) do |req|
+        req.headers = headers
+      end&.body)
+    end
+
+    def post(path:)
+      parse_json(conn.post(uri(path: path)) do |req|
+        req.headers = headers
+        req.params = { key: @api_key }
+      end&.body)
+    end
+
+    def json_post(path:, parameters:, query_parameters: {})
+      # Check if there are streaming parameters
+      stream_proc = parameters[:stream] if parameters[:stream].respond_to?(:call)
+      
+      # Determine if we're in streaming mode
+      is_streaming = !stream_proc.nil?
+      
+      # For SSE streaming, add alt=sse to query parameters
+      if is_streaming
+        query_parameters = query_parameters.merge(alt: 'sse')
+      end
+      
+      # In Gemini API, API key is passed as a query parameter
+      query_params = query_parameters.merge(key: @api_key)
+      
+      # Streaming mode
+      if is_streaming
+        handle_streaming_request(path, parameters, query_params, stream_proc)
+      else
+        # Normal batch response mode
+        parse_json(conn.post(uri(path: path)) do |req|
+          configure_json_post_request(req, parameters)
+          req.params = req.params.merge(query_params)
+        end&.body)
+      end
+    end
+
+    def multipart_post(path:, parameters: nil)
+      parse_json(conn(multipart: true).post(uri(path: path)) do |req|
+        req.headers = headers.merge({ "Content-Type" => "multipart/form-data" })
+        req.params = { key: @api_key }
+        req.body = multipart_parameters(parameters)
+      end&.body)
+    end
+
+    def delete(path:)
+      parse_json(conn.delete(uri(path: path)) do |req|
+        req.headers = headers
+        req.params = { key: @api_key }
+      end&.body)
+    end
+
+    private
+    
+    # Process streaming request
+    def handle_streaming_request(path, parameters, query_params, stream_proc)
+      # Create a copy of request parameters
+      req_parameters = parameters.dup
+      
+      # Remove the streaming procedure (it would fail JSON serialization)
+      req_parameters.delete(:stream)
+      
+      # Variable to accumulate response for SSE streaming
+      accumulated_json = nil
+      
+      # Execute Faraday request
+      connection = conn
+      
+      begin
+        response = connection.post(uri(path: path)) do |req|
+          req.headers = headers
+          req.params = query_params
+          req.body = req_parameters.to_json
+          
+          # Callback to process SSE streaming events
+          req.options.on_data = proc do |chunk, _bytes, env|
+            if env && env.status != 200
+              raise_error = Faraday::Response::RaiseError.new
+              raise_error.on_complete(env.merge(body: try_parse_json(chunk)))
+            end
+            
+            # Process SSE format lines
+            process_sse_chunk(chunk, stream_proc) do |parsed_json|
+              # Save the first valid JSON
+              accumulated_json ||= parsed_json
+            end
+          end
+        end
+        
+        # Return the complete response
+        return accumulated_json || {}
+      rescue => e
+        log_streaming_error(e) if @log_errors
+        raise e
+      end
+    end
+    
+    # Process SSE chunk
+    def process_sse_chunk(chunk, user_proc)
+      # Split chunk into lines
+      chunk.each_line do |line|
+        # Only process lines that start with "data:"
+        if line.start_with?("data:")
+          # Remove "data:" prefix
+          data = line[5..-1].strip
+          
+          # Check for end marker
+          next if data == "[DONE]"
+          
+          begin
+            # Parse JSON
+            parsed_json = JSON.parse(data)
+            
+            # Pass parsed JSON to user procedure
+            user_proc.call(parsed_json)
+            
+            # Pass to caller
+            yield parsed_json if block_given?
+          rescue JSON::ParserError => e
+            log_json_error(e, data) if @log_errors
+          end
+        end
+      end
+    end
+    
+    # Log streaming error
+    def log_streaming_error(error)
+      STDERR.puts "[Gemini::HTTP] Streaming error: #{error.message}"
+      STDERR.puts error.backtrace.join("\n") if ENV["DEBUG"]
+    end
+    
+    # Log JSON parsing error
+    def log_json_error(error, data)
+      STDERR.puts "[Gemini::HTTP] JSON parsing error: #{error.message}, data: #{data[0..100]}..." if ENV["DEBUG"]
+    end
+
+    def parse_json(response)
+      return unless response
+      return response unless response.is_a?(String)
+
+      original_response = response.dup
+      if response.include?("}\n{")
+        # Convert multi-line JSON objects to JSON array
+        response = response.gsub("}\n{", "},{").prepend("[").concat("]")
+      end
+
+      JSON.parse(response)
+    rescue JSON::ParserError
+      original_response
+    end
+
+    # Generate procedure to handle streaming response
+    def to_json_stream(user_proc:)
+      proc do |chunk, _bytes, env|
+        if env && env.status != 200
+          raise_error = Faraday::Response::RaiseError.new
+          raise_error.on_complete(env.merge(body: try_parse_json(chunk)))
+        end
+
+        # Process according to Gemini API streaming response format
+        parsed_chunk = try_parse_json(chunk)
+        user_proc.call(parsed_chunk) if parsed_chunk
+      end
+    end
+
+    def conn(multipart: false)
+      connection = Faraday.new do |f|
+        f.options[:timeout] = @request_timeout
+        f.request(:multipart) if multipart
+        f.use Gemini::MiddlewareErrors if @log_errors
+        f.response :raise_error
+        f.response :json
+      end
+
+      @faraday_middleware&.call(connection)
+
+      connection
+    end
+
+    def uri(path:)
+      File.join(@uri_base, path)
+    end
+
+    def multipart_parameters(parameters)
+      parameters&.transform_values do |value|
+        next value unless value.respond_to?(:close) # File or IO object
+
+        # Get file path if available
+        path = value.respond_to?(:path) ? value.path : nil
+        # Pass empty string for MIME type
+        Faraday::UploadIO.new(value, "", path)
+      end
+    end
+
+    def configure_json_post_request(req, parameters)
+      req_parameters = parameters.dup
+
+      if parameters[:stream].respond_to?(:call)
+        req.options.on_data = to_json_stream(user_proc: parameters[:stream])
+        req_parameters[:stream] = true # Instruct Gemini API to stream
+      elsif parameters[:stream]
+        raise ArgumentError, "stream parameter must be a Proc or have a #call method"
+      end
+
+      req.headers = headers
+      req.body = req_parameters.to_json
+    end
+
+    def try_parse_json(maybe_json)
+      JSON.parse(maybe_json)
+    rescue JSON::ParserError
+      maybe_json
+    end
+  end
+end

data/lib/gemini/http_headers.rb

@@ -0,0 +1,24 @@
+module Gemini
+  module HTTPHeaders
+    def add_headers(headers)
+      @extra_headers = extra_headers.merge(headers.transform_keys(&:to_s))
+    end
+
+    private
+
+    def headers
+      default_headers.merge(extra_headers)
+    end
+
+    def default_headers
+      {
+        "Content-Type" => "application/json",
+        "User-Agent" => "ruby-gemini/#{Gemini::VERSION}"
+      }
+    end
+
+    def extra_headers
+      @extra_headers ||= {}
+    end
+  end
+end

data/lib/gemini/images.rb

@@ -0,0 +1,122 @@
+module Gemini
+  class Images
+    def initialize(client:)
+      @client = client
+    end
+
+    # 画像を生成するメインメソッド
+    def generate(parameters: {})
+      prompt = parameters[:prompt]
+      raise ArgumentError, "prompt parameter is required" unless prompt
+
+      # モデルの決定（デフォルトはGemini 2.0）
+      model = parameters[:model] || "gemini-2.0-flash-exp-image-generation"
+      
+      # モデルに応じた画像生成処理
+      if model.start_with?("imagen")
+        # Imagen 3を使用
+        response = imagen_generate(prompt, parameters)
+      else
+        # Gemini 2.0を使用
+        response = gemini_generate(prompt, parameters)
+      end
+      
+      # レスポンスをラップして返す
+      Gemini::Response.new(response)
+    end
+    
+    private
+    
+    # Gemini 2.0モデルを使用した画像生成
+    def gemini_generate(prompt, parameters)
+      # パラメータの準備
+      model = parameters[:model] || "gemini-2.0-flash-exp-image-generation"
+      
+      # サイズパラメータの処理（現在はGemini APIでは使用しない）
+      # aspect_ratio = process_size_parameter(parameters[:size])
+      
+      # 生成設定の構築
+      generation_config = {
+        "responseModalities" => ["Text", "Image"]
+      }
+      
+      # リクエストパラメータの構築
+      request_params = {
+        "contents" => [{
+          "parts" => [
+            {"text" => prompt}
+          ]
+        }],
+        "generationConfig" => generation_config
+      }
+      
+      # API呼び出し
+      @client.json_post(
+        path: "models/#{model}:generateContent",
+        parameters: request_params
+      )
+    end
+    
+    # Imagen 3モデルを使用した画像生成
+    def imagen_generate(prompt, parameters)
+      # モデル名の取得（デフォルトはImagen 3の標準モデル）
+      model = parameters[:model] || "imagen-3.0-generate-002"
+      
+      # サイズパラメータからアスペクト比を取得
+      aspect_ratio = process_size_parameter(parameters[:size])
+      
+      # 画像生成数の設定
+      sample_count = parameters[:n] || parameters[:sample_count] || 1
+      sample_count = [[sample_count.to_i, 1].max, 4].min # 1〜4の範囲に制限
+      
+      # 人物生成の設定
+      person_generation = parameters[:person_generation] || "ALLOW_ADULT"
+      
+      # リクエストパラメータの構築
+      request_params = {
+        "instances" => [
+          {
+            "prompt" => prompt
+          }
+        ],
+        "parameters" => {
+          "sampleCount" => sample_count
+        }
+      }
+      
+      # アスペクト比が指定されている場合は追加
+      request_params["parameters"]["aspectRatio"] = aspect_ratio if aspect_ratio
+      
+      # 人物生成設定を追加
+      request_params["parameters"]["personGeneration"] = person_generation
+      
+      # API呼び出し
+      @client.json_post(
+        path: "models/#{model}:predict",
+        parameters: request_params
+      )
+    end
+    
+    # サイズパラメータからアスペクト比を決定
+    def process_size_parameter(size)
+      return nil unless size
+      
+      case size.to_s
+      when "256x256", "512x512", "1024x1024"
+        "1:1"
+      when "256x384", "512x768", "1024x1536"
+        "3:4"
+      when "384x256", "768x512", "1536x1024"
+        "4:3"
+      when "256x448", "512x896", "1024x1792"
+        "9:16"
+      when "448x256", "896x512", "1792x1024"
+        "16:9"
+      when "1:1", "3:4", "4:3", "9:16", "16:9"
+        size.to_s
+      else
+        "1:1" # デフォルト
+      end
+    end
+  end
+end

data/lib/gemini/messages.rb

@@ -0,0 +1,131 @@
+module Gemini
+  class Messages
+    def initialize(client:)
+      @client = client
+      @message_store = {} # Store messages by thread ID
+    end
+
+    # List messages in a thread
+    def list(thread_id:, parameters: {})
+      # Internal implementation: Get messages for the thread from message store
+      messages = get_thread_messages(thread_id)
+      
+      # OpenAI-like response format
+      {
+        "object" => "list",
+        "data" => messages,
+        "first_id" => messages.first&.dig("id"),
+        "last_id" => messages.last&.dig("id"),
+        "has_more" => false
+      }
+    end
+
+    # Retrieve a specific message
+    def retrieve(thread_id:, id:)
+      messages = get_thread_messages(thread_id)
+      message = messages.find { |m| m["id"] == id }
+      
+      raise Error.new("Message not found", "message_not_found") unless message
+      message
+    end
+
+    # Create a new message
+    def create(thread_id:, parameters: {})
+      # Check if thread exists (raise exception if not)
+      validate_thread_exists(thread_id)
+      
+      message_id = SecureRandom.uuid
+      created_at = Time.now.to_i
+      
+      # Build message data from parameters
+      message = {
+        "id" => message_id,
+        "object" => "thread.message",
+        "created_at" => created_at,
+        "thread_id" => thread_id,
+        "role" => parameters[:role] || "user",
+        "content" => format_content(parameters[:content])
+      }
+      
+      # Add message to thread
+      add_message_to_thread(thread_id, message)
+      
+      message
+    end
+
+    # Modify a message
+    def modify(thread_id:, id:, parameters: {})
+      message = retrieve(thread_id: thread_id, id: id)
+      
+      # Apply modifiable parameters
+      message["metadata"] = parameters[:metadata] if parameters[:metadata]
+      
+      message
+    end
+
+    # Delete a message (logical deletion)
+    def delete(thread_id:, id:)
+      message = retrieve(thread_id: thread_id, id: id)
+      
+      # Set logical deletion flag
+      message["deleted"] = true
+      
+      { "id" => id, "object" => "thread.message.deleted", "deleted" => true }
+    end
+
+    private
+
+    # Get thread messages (internal method)
+    def get_thread_messages(thread_id)
+      validate_thread_exists(thread_id)
+      @message_store[thread_id] ||= []
+      @message_store[thread_id].reject { |m| m["deleted"] }
+    end
+
+    # Add message to thread (internal method)
+    def add_message_to_thread(thread_id, message)
+      @message_store[thread_id] ||= []
+      @message_store[thread_id] << message
+      message
+    end
+
+    # Validate thread exists (internal method)
+    def validate_thread_exists(thread_id)
+      begin
+        @client.threads.retrieve(id: thread_id)
+      rescue => e
+        raise Error.new("Thread not found", "thread_not_found")
+      end
+    end
+
+    # Convert content to Gemini API format (internal method)
+    def format_content(content)
+      case content
+      when String
+        [{ "type" => "text", "text" => { "value" => content } }]
+      when Array
+        content.map do |item|
+          if item.is_a?(String)
+            { "type" => "text", "text" => { "value" => item } }
+          else
+            item
+          end
+        end
+      when Hash
+        [content]
+      else
+        [{ "type" => "text", "text" => { "value" => content.to_s } }]
+      end
+    end
+  end
+
+  # Error class
+  class Error < StandardError
+    attr_reader :code
+    
+    def initialize(message, code = nil)
+      super(message)
+      @code = code
+    end
+  end
+end

data/lib/gemini/models.rb

@@ -0,0 +1,20 @@
+module Gemini
+  class Models
+    def initialize(client:)
+      @client = client
+    end
+
+    def list
+      @client.get(path: "models")
+    end
+
+    def retrieve(id:)
+      @client.get(path: "models/#{id}")
+    end
+
+    # Stub for compatibility, as Gemini API currently doesn't provide model deletion
+    def delete(id:)
+      raise NotImplementedError, "Model deletion is not supported in Gemini API"
+    end
+  end
+end