geminize 0.1.0

data/lib/geminize/models/conversation.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "time"
+require "json"
+
+module Geminize
+  module Models
+    # Represents a conversation with message history
+    class Conversation
+      # @return [String] Unique identifier for the conversation
+      attr_reader :id
+
+      # @return [String] Optional title for the conversation
+      attr_accessor :title
+
+      # @return [Time] When the conversation was created
+      attr_reader :created_at
+
+      # @return [Time] When the conversation was last updated
+      attr_reader :updated_at
+
+      # @return [Array<Message>] The messages in the conversation
+      attr_reader :messages
+
+      # @return [String, nil] System instruction to guide model behavior
+      attr_accessor :system_instruction
+
+      # Initialize a new conversation
+      # @param id [String, nil] Unique identifier for the conversation
+      # @param title [String, nil] Optional title for the conversation
+      # @param messages [Array<Message>, nil] Initial messages
+      # @param created_at [Time, nil] When the conversation was created
+      # @param system_instruction [String, nil] System instruction to guide model behavior
+      def initialize(id = nil, title = nil, messages = nil, created_at = nil, system_instruction = nil)
+        @id = id || SecureRandom.uuid
+        @title = title
+        @messages = messages || []
+        @created_at = created_at || Time.now
+        @updated_at = @created_at
+        @system_instruction = system_instruction
+      end
+
+      # Add a user message to the conversation
+      # @param content [String] The content of the message
+      # @return [UserMessage] The added message
+      def add_user_message(content)
+        message = UserMessage.new(content)
+        add_message(message)
+        @updated_at = Time.now
+        message
+      end
+
+      # Add a model message to the conversation
+      # @param content [String] The content of the message
+      # @return [ModelMessage] The added message
+      def add_model_message(content)
+        message = ModelMessage.new(content)
+        add_message(message)
+        @updated_at = Time.now
+        message
+      end
+
+      # Add a message to the conversation
+      # @param message [Message] The message to add
+      # @return [Message] The added message
+      def add_message(message)
+        @messages << message
+        @updated_at = Time.now
+        message
+      end
+
+      # Get the messages as an array of hashes for the API
+      # @return [Array<Hash>] The messages as hashes
+      def messages_as_hashes
+        @messages.map(&:to_hash)
+      end
+
+      # Get the last message in the conversation
+      # @return [Message, nil] The last message or nil if there are no messages
+      def last_message
+        @messages.last
+      end
+
+      # Check if the conversation has any messages
+      # @return [Boolean] True if the conversation has messages
+      def has_messages?
+        !@messages.empty?
+      end
+
+      # Get the number of messages in the conversation
+      # @return [Integer] The number of messages
+      def message_count
+        @messages.size
+      end
+
+      # Clear all messages from the conversation
+      # @return [self] The conversation instance
+      def clear
+        @messages = []
+        @updated_at = Time.now
+        self
+      end
+
+      # Convert the conversation to a hash
+      # @return [Hash] The conversation as a hash
+      def to_hash
+        {
+          id: @id,
+          title: @title,
+          created_at: @created_at.iso8601,
+          updated_at: @updated_at.iso8601,
+          messages: @messages.map(&:to_hash),
+          system_instruction: @system_instruction
+        }
+      end
+
+      # Alias for to_hash for consistency with Ruby conventions
+      # @return [Hash] The conversation as a hash
+      def to_h
+        to_hash
+      end
+
+      # Serialize the conversation to a JSON string
+      # @return [String] The conversation as a JSON string
+      def to_json(*args)
+        to_h.to_json(*args)
+      end
+
+      # Create a conversation from a hash
+      # @param hash [Hash] The hash to create the conversation from
+      # @return [Conversation] A new conversation object
+      def self.from_hash(hash)
+        id = hash["id"]
+        title = hash["title"]
+        created_at = hash["created_at"] ? Time.parse(hash["created_at"]) : Time.now
+        system_instruction = hash["system_instruction"]
+
+        messages = []
+        if hash["messages"]&.is_a?(Array)
+          messages = hash["messages"].map { |msg_hash| Message.from_hash(msg_hash) }
+        end
+
+        new(id, title, messages, created_at, system_instruction)
+      end
+
+      # Create a conversation from a JSON string
+      # @param json [String] The JSON string
+      # @return [Conversation] A new conversation object
+      def self.from_json(json)
+        hash = JSON.parse(json)
+        from_hash(hash)
+      end
+    end
+  end
+end

data/lib/geminize/models/embedding_request.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+module Geminize
+  module Models
+    # Represents a request for embedding generation from the Gemini API
+    class EmbeddingRequest
+      attr_reader :text, :model_name, :task_type, :dimensions, :title
+
+      # Task type constants
+      TASK_TYPE_UNSPECIFIED = "TASK_TYPE_UNSPECIFIED"
+      RETRIEVAL_QUERY = "RETRIEVAL_QUERY"
+      RETRIEVAL_DOCUMENT = "RETRIEVAL_DOCUMENT"
+      SEMANTIC_SIMILARITY = "SEMANTIC_SIMILARITY"
+      CLASSIFICATION = "CLASSIFICATION"
+      CLUSTERING = "CLUSTERING"
+      QUESTION_ANSWERING = "QUESTION_ANSWERING"
+      FACT_VERIFICATION = "FACT_VERIFICATION"
+      CODE_RETRIEVAL_QUERY = "CODE_RETRIEVAL_QUERY"
+
+      # Supported task types for embeddings
+      TASK_TYPES = [
+        TASK_TYPE_UNSPECIFIED, # Default unspecified type
+        RETRIEVAL_QUERY,       # For embedding queries for retrieval
+        RETRIEVAL_DOCUMENT,    # For embedding documents for retrieval
+        SEMANTIC_SIMILARITY,   # For embeddings that will be compared for similarity
+        CLASSIFICATION,        # For embeddings that will be used for classification
+        CLUSTERING,            # For embeddings that will be clustered
+        QUESTION_ANSWERING,    # For embeddings used in question answering
+        FACT_VERIFICATION,     # For embeddings used in fact verification
+        CODE_RETRIEVAL_QUERY   # For embeddings used in code retrieval
+      ].freeze
+
+      # Initialize a new embedding request
+      # @param model_name [String] The model name to use
+      # @param text [String, Array<String>] The input text(s) to embed
+      # @param task_type [String] The embedding task type
+      # @param params [Hash] Additional parameters
+      # @option params [Integer] :dimensions Desired dimensionality of the embeddings
+      # @option params [String] :title Optional title for the request
+      def initialize(text = nil, model_name = nil, **options)
+        # Support both old positional params and new named params
+        if text.nil? && model_name.nil?
+          # New named parameters style
+          @model_name = options.delete(:model_name)
+          @text = options.delete(:text)
+        else
+          # Old positional parameters style
+          @text = text
+          @model_name = model_name
+        end
+
+        @task_type = options[:task_type] || RETRIEVAL_DOCUMENT
+        @dimensions = options[:dimensions]
+        @title = options[:title]
+
+        validate!
+      end
+
+      # Get the request as a hash
+      # @return [Hash] The request hash
+      def to_hash
+        if batch?
+          build_batch_request
+        else
+          build_single_request
+        end
+      end
+
+      # Alias for to_hash
+      def to_h
+        to_hash
+      end
+
+      # Check if this request contains multiple texts
+      # @return [Boolean] True if the request contains multiple texts
+      def batch?
+        @text.is_a?(Array)
+      end
+
+      # Alias for batch?
+      alias_method :multiple?, :batch?
+
+      # Create a single request hash for the given text
+      # @param text_input [String] The text to create a request for
+      # @return [Hash] The request hash for a single text
+      def single_request_hash(text_input)
+        request = {
+          model: @model_name,
+          content: {
+            parts: [
+              {
+                text: text_input.to_s
+              }
+            ]
+          },
+          taskType: @task_type
+        }
+
+        # Add title if provided
+        request[:content][:title] = @title if @title
+
+        # Add optional parameters if they exist
+        request[:dimensions] = @dimensions if @dimensions
+
+        request
+      end
+
+      private
+
+      # Validate the request parameters
+      # @raise [Geminize::ValidationError] If any parameter is invalid
+      # @return [Boolean] true if all parameters are valid
+      def validate!
+        validate_text!
+        validate_model_name!
+        validate_dimensions!
+        validate_task_type!
+        true
+      end
+
+      # Validate input text
+      # @raise [Geminize::ValidationError] If text is invalid
+      def validate_text!
+        if @text.nil?
+          raise Geminize::ValidationError.new("text cannot be nil", "INVALID_ARGUMENT")
+        end
+
+        if @text.is_a?(Array)
+          if @text.empty?
+            raise Geminize::ValidationError.new("Text array cannot be empty", "INVALID_ARGUMENT")
+          end
+
+          @text.each_with_index do |t, index|
+            if t.nil? || (t.is_a?(String) && t.empty?)
+              raise Geminize::ValidationError.new("Text at index #{index} cannot be nil or empty", "INVALID_ARGUMENT")
+            end
+          end
+        elsif @text.is_a?(String) && @text.empty?
+          raise Geminize::ValidationError.new("Text cannot be empty", "INVALID_ARGUMENT")
+        end
+      end
+
+      # Validate the model name
+      # @raise [Geminize::ValidationError] If model name is invalid
+      def validate_model_name!
+        if @model_name.nil?
+          raise Geminize::ValidationError.new("model_name cannot be nil", "INVALID_ARGUMENT")
+        end
+
+        if @model_name.is_a?(String) && @model_name.empty?
+          raise Geminize::ValidationError.new("Model name cannot be empty", "INVALID_ARGUMENT")
+        end
+      end
+
+      # Validate dimensions if provided
+      # @raise [Geminize::ValidationError] If dimensions are invalid
+      def validate_dimensions!
+        return if @dimensions.nil?
+
+        Validators.validate_positive_integer!(@dimensions, "Dimensions")
+      end
+
+      # Validate task type if provided
+      # @raise [Geminize::ValidationError] If task type is invalid
+      def validate_task_type!
+        return if @task_type.nil?
+
+        unless TASK_TYPES.include?(@task_type)
+          task_types_str = TASK_TYPES.map { |t| "\"#{t}\"" }.join(", ")
+          raise Geminize::ValidationError.new(
+            "task_type must be one of: #{task_types_str}",
+            "INVALID_ARGUMENT"
+          )
+        end
+      end
+
+      # Create a single request hash
+      # @return [Hash] The request hash for a single text
+      def build_single_request
+        request = {
+          model: @model_name,
+          content: {
+            parts: [
+              {
+                text: @text.to_s
+              }
+            ]
+          },
+          taskType: @task_type
+        }
+
+        # Add title if provided
+        request[:content][:title] = @title if @title
+
+        # Add optional parameters if they exist
+        request[:dimensions] = @dimensions if @dimensions
+
+        request
+      end
+
+      # Create a batch request hash
+      # @return [Hash] The request hash for a batch of texts
+      def build_batch_request
+        {
+          requests: @text.map do |text_item|
+            {
+              model: "models/#{@model_name}",
+              content: {
+                parts: [
+                  {
+                    text: text_item
+                  }
+                ]
+              },
+              taskType: @task_type
+            }
+          end
+        }
+      end
+    end
+  end
+end