genai-rb 0.0.2 → 0.2.0

data/lib/genai/chat.rb

@@ -1,233 +1,206 @@
-# 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
+module Genai
+  module ChatValidator
+    def self.validate_content(content)
+      message_content = content[:content] || content["content"]
+      return true if message_content.is_a?(String) && !message_content.empty?
+
+      parts = content[:parts] || content["parts"]
+      return false unless parts && !parts.empty?
+      parts.each do |part|
+        return false if part.empty?
+        text = part[:text] || part["text"]
+        return false if text && 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
+        role = comprehensive_history[i][:role] || comprehensive_history[i]["role"]
+
+        unless ["user", "model", "assistant", "system", "developer"].include?(role)
+          raise ArgumentError, "Unsupported role: #{role}"
+        end
+
+        if ["user", "system", "developer"].include?(role)
+          current_input = comprehensive_history[i]
+          curated_history << current_input
+          i += 1
+        else
+          current_output = []
+          is_valid = true
+          
+          while i < length
+            current_role = comprehensive_history[i][:role] || comprehensive_history[i]["role"]
+            break unless ["model", "assistant"].include?(current_role)
+
+            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
+      
+      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)
+      input_contents = if !automatic_function_calling_history.empty?
+        automatic_function_calling_history[@curated_history.length..-1] || [user_input]
+      else
+        [user_input]
+      end
+      
+      output_contents = model_output.empty? ? [{ role: "model", parts: [] }] : model_output
+      
+      @comprehensive_history.concat(input_contents)
+      @comprehensive_history.concat(output_contents)
+      
+      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)
+      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
+
+      model_instance = @client.model(@model)
+      response = model_instance.generate_content(
+        contents: @curated_history + [input_content],
+        config: config || @config
+      )
+
+      model_output = response.to_s.empty? ? [] : [{ role: "model", parts: [{ text: response.to_s }] }]
+
+      record_history(
+        user_input: input_content,
+        model_output: model_output,
+        is_valid: !response.to_s.empty?
+      )
+
+      response
+    end
+
+    def send_message_stream(message, config: nil)
+      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
+
+
+      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: "gpt-5.5", config: nil)
+      unless @user_sessions[user_id]
+        @user_sessions[user_id] = create(
+          model: model,
+          config: config || {
+            temperature: 0.7,
+            max_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

@@ -1,13 +1,13 @@
-require "net/http"
-require "json"
-
+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"
+      @api_key = api_key || ENV["OPENAI_API_KEY"]
+      @base_url = (base_url || ENV["OPENAI_BASE_URL"] || "https://api.openai.com/v1").sub(%r{/\z}, "")
       @timeout = timeout
       @max_retries = max_retries
       
@@ -15,18 +15,18 @@ module Genai
     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?
+      raise Error, "API key is required. Set OPENAI_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}"
+      "#{@base_url}/#{endpoint}"
     end
     
     def headers
       {
         "Content-Type" => "application/json",
-        "x-goog-api-key" => @api_key
+        "Authorization" => "Bearer #{@api_key}"
       }
     end
   end
-end 
+end