Class: Geminize::Chat

Inherits:
Object
  • Object
show all
Defined in:
lib/geminize/chat.rb

Overview

Class for chat functionality

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(conversation = nil, client = nil, options = {}) ⇒ Chat

Initialize a new chat instance

Parameters:

  • conversation (Geminize::Models::Conversation, nil) (defaults to: nil) —

    The conversation to use

  • client (Geminize::Client, nil) (defaults to: nil) —

    The client to use (optional)

  • options (Hash) (defaults to: {}) —

    Additional options



16
17
18
19
20
 
# File 'lib/geminize/chat.rb', line 16

def initialize(conversation = nil, client = nil, options = {})
  @conversation = conversation || Models::Conversation.new
  @client = client || Client.new(options)
  @options = options
end

Instance Attribute Details

#client ⇒ Geminize::Client (readonly)

Returns The client instance.

Returns:



7
8
9
 
# File 'lib/geminize/chat.rb', line 7

def client
  @client
end

#conversation ⇒ Models::Conversation (readonly)

Returns The current conversation.

Returns:



10
11
12
 
# File 'lib/geminize/chat.rb', line 10

def conversation
  @conversation
end

Class Method Details

.new_conversation(title = nil, system_instruction = nil) ⇒ Chat

Create a new conversation

Parameters:

  • title (String, nil) (defaults to: nil) —

    Optional title for the conversation

  • system_instruction (String, nil) (defaults to: nil) —

    Optional system instruction

Returns:

  • (Chat) —

    A new chat instance with a fresh conversation



92
93
94
95
96
 
# File 'lib/geminize/chat.rb', line 92

def self.new_conversation(title = nil, system_instruction = nil)
  # Create a conversation with explicit parameters
  conversation = Models::Conversation.new(nil, title, nil, nil, system_instruction)
  new(conversation)
end

Instance Method Details

#generate_response(chat_request) ⇒ Models::ChatResponse

Generate a response based on the current conversation

Parameters:

Returns:

Raises:



76
77
78
79
80
81
82
83
84
85
86
 
# File 'lib/geminize/chat.rb', line 76

def generate_response(chat_request)
  model_name = chat_request.model_name
  endpoint = RequestBuilder.build_text_generation_endpoint(model_name)

  # Create payload with conversation history
  payload = RequestBuilder.build_chat_request(chat_request, @conversation.messages_as_hashes)

  # Send request to API
  response_data = @client.post(endpoint, payload)
  Models::ChatResponse.from_hash(response_data)
end

#send_message(content, model_name = nil, params = {}) ⇒ Models::ChatResponse

Send a user message and get a model response

Parameters:

  • content (String) —

    The content of the user message

  • model_name (String, nil) (defaults to: nil) —

    The model to use (optional)

  • params (Hash) (defaults to: {}) —

    Additional generation parameters

Options Hash (params):

  • :temperature (Float) —

    Controls randomness (0.0-1.0)

  • :max_tokens (Integer) —

    Maximum tokens to generate

  • :top_p (Float) —

    Top-p value for nucleus sampling (0.0-1.0)

  • :top_k (Integer) —

    Top-k value for sampling

  • :stop_sequences (Array<String>) —

    Stop sequences to end generation

  • :system_instruction (String) —

    System instruction to guide model behavior

Returns:

Raises:



34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
# File 'lib/geminize/chat.rb', line 34

def send_message(content, model_name = nil, params = {})
  # Add user message to conversation
  @conversation.add_user_message(content)

  # Create the chat request
  request_params = params.dup

  # Only include system_instruction in params if explicitly provided or set in conversation
  if params[:system_instruction] || @conversation.system_instruction
    request_params[:system_instruction] = params[:system_instruction] || @conversation.system_instruction
  end

  chat_request = Models::ChatRequest.new(
    content,
    model_name || Geminize.configuration.default_model,
    nil, # user_id
    request_params
  )

  # Generate the response using the conversation history
  response = generate_response(chat_request)

  # Extract and add the model's response to the conversation
  if response.has_text?
    @conversation.add_model_message(response.text)
  end

  response
end

#set_system_instruction(instruction) ⇒ self

Set a system instruction for the conversation

Parameters:

  • instruction (String) —

    The system instruction

Returns:

  • (self) —

    The chat instance



67
68
69
70
 
# File 'lib/geminize/chat.rb', line 67

def set_system_instruction(instruction)
  @conversation.system_instruction = instruction
  self
end