Class: Geminize::TextGeneration

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

Overview

Class for text generation functionality

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

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

Initialize a new text generation instance

Parameters:

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

    The client to use (optional)

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

    Additional options



12
13
14
15
 
# File 'lib/geminize/text_generation.rb', line 12

def initialize(client = nil, options = {})
  @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/text_generation.rb', line 7

def client
  @client
end

Instance Method Details

#cancel_streaming ⇒ Boolean

Cancel the current streaming operation, if any

Returns:

  • (Boolean) —

    true if a streaming operation was cancelled, false if none was in progress



179
180
181
182
183
184
 
# File 'lib/geminize/text_generation.rb', line 179

def cancel_streaming
  return false unless @client

  # Set the cancel_streaming flag to true on the client
  @client.cancel_streaming = true
end

#generate(content_request) ⇒ Geminize::Models::ContentResponse

Generate text based on a content request

Parameters:

Returns:

Raises:



21
22
23
24
25
26
27
28
 
# File 'lib/geminize/text_generation.rb', line 21

def generate(content_request)
  model_name = content_request.model_name
  endpoint = RequestBuilder.build_text_generation_endpoint(model_name)
  payload = RequestBuilder.build_text_generation_request(content_request)

  response_data = @client.post(endpoint, payload)
  Models::ContentResponse.from_hash(response_data)
end

#generate_text(prompt, model_name = nil, params = {}) ⇒ Geminize::Models::ContentResponse

Generate text from a prompt string with optional parameters

Parameters:

  • prompt (String) —

    The input prompt

  • 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:



42
43
44
45
46
47
48
49
50
51
52
 
# File 'lib/geminize/text_generation.rb', line 42

def generate_text(prompt, model_name = nil, params = {})
  model = model_name || Geminize.configuration.default_model

  content_request = Models::ContentRequest.new(
    prompt,
    model,
    params
  )

  generate(content_request)
end

#generate_text_multimodal(prompt, images, model_name = nil, params = {}) ⇒ Geminize::Models::ContentResponse

Generate content with both text and images

Examples:

Generate with an image file

generate_text_multimodal("Describe this image", [{source_type: 'file', data: 'path/to/image.jpg'}])

Generate with multiple images

generate_text_multimodal("Compare these images", [
  {source_type: 'file', data: 'path/to/image1.jpg'},
  {source_type: 'url', data: 'https://example.com/image2.jpg'}
])

Parameters:

  • prompt (String) —

    The input prompt text

  • images (Array<Hash>) —

    Array of image data hashes

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

    The model to use (optional)

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

    Additional generation parameters

Options Hash (images):

  • :source_type (Hash) —

    Source type for image ('file', 'bytes', or 'url')

  • :data (String) —

    File path, raw bytes, or URL depending on source_type

  • :mime_type (String) —

    MIME type for the image (optional for file and url)

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

Returns:

Raises:



126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
 
# File 'lib/geminize/text_generation.rb', line 126

def generate_text_multimodal(prompt, images, model_name = nil, params = {})
  # Create a new content request with the prompt text
  content_request = Models::ContentRequest.new(
    prompt,
    model_name || Geminize.configuration.default_model,
    params
  )

  # Add each image to the request based on its source type
  images.each do |image|
    case image[:source_type]
    when "file"
      content_request.add_image_from_file(image[:data])
    when "bytes"
      content_request.add_image_from_bytes(image[:data], image[:mime_type])
    when "url"
      content_request.add_image_from_url(image[:data])
    else
      raise Geminize::ValidationError.new(
        "Invalid image source type: #{image[:source_type]}. Must be 'file', 'bytes', or 'url'",
        "INVALID_ARGUMENT"
      )
    end
  end

  # Generate content with the constructed multimodal request
  generate(content_request)
end

#generate_text_stream(prompt, model_name = nil, params = {}) {|chunk| ... }

This method returns an undefined value.

Generate a streaming text response from a prompt string with optional parameters

Examples:

Generate text with streaming, yielding each chunk

text_generation.generate_text_stream("Tell me a story") do |chunk|
  puts chunk
end

Generate text with incremental mode

accumulated_text = ""
text_generation.generate_text_stream("Tell me a story", nil, stream_mode: :incremental) do |text|
  # text contains the full response so far
  print "\r#{text}"
end

Generate text with delta mode (only new content)

text_generation.generate_text_stream("Tell me a story", nil, stream_mode: :delta) do |new_text|
  # new_text contains only the new content in this chunk
  print new_text
end

Parameters:

  • prompt (String) —

    The input prompt

  • 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

  • :stream_mode (Symbol) —

    Mode for processing stream chunks (:raw, :incremental, or :delta)

  • :system_instruction (String) —

    System instruction to guide model behavior

Yields:

  • (chunk) —

    Yields each chunk of the streaming response

Yield Parameters:

  • chunk (String, Hash, StreamResponse) —

    A chunk of the response

Raises:



84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
 
# File 'lib/geminize/text_generation.rb', line 84

def generate_text_stream(prompt, model_name = nil, params = {}, &block)
  raise ArgumentError, "A block is required for streaming" unless block_given?

  # Extract stream processing mode
  stream_mode = params.delete(:stream_mode) || :incremental
  unless [:raw, :incremental, :delta].include?(stream_mode)
    raise ArgumentError, "Invalid stream_mode. Must be :raw, :incremental, or :delta"
  end

  # Create the content request
  content_request = Models::ContentRequest.new(
    prompt,
    model_name || Geminize.configuration.default_model,
    params
  )

  # Generate with streaming
  generate_stream(content_request, stream_mode, &block)
end

#generate_with_retries(content_request, max_retries = 3, retry_delay = 1.0) ⇒ Geminize::Models::ContentResponse

Generate text with retries for transient errors

Parameters:

  • content_request (Geminize::Models::ContentRequest) —

    The content request

  • max_retries (Integer) (defaults to: 3) —

    Maximum number of retry attempts

  • retry_delay (Float) (defaults to: 1.0) —

    Delay between retries in seconds

Returns:

Raises:



161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
 
# File 'lib/geminize/text_generation.rb', line 161

def generate_with_retries(content_request, max_retries = 3, retry_delay = 1.0)
  retries = 0

  begin
    generate(content_request)
  rescue Geminize::RateLimitError, Geminize::ServerError => e
    if retries < max_retries
      retries += 1
      sleep retry_delay * retries # Exponential backoff
      retry
    else
      raise e
    end
  end
end