ruby-gemini-api 1.0.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 92b2d6f35fbff3fda1457ef3244ae730ee99e156909c310b62878540d47d4076
-  data.tar.gz: 710191ae9ac4f136ea586782be43b8aa18390d74a8ba1d844a9524fc120fdaa4
+  metadata.gz: cd1be2a2b81543d21686e9d4ade4de2e6aa42ea8b26abc4bb0929e9aa77fada0
+  data.tar.gz: 9b96121c0a8a68220e4e368057424211e29e0652f28f1812b56049842d31c5c9
 SHA512:
-  metadata.gz: 31a2f84ff0f7d9d5127fe3cfa2eba75c2395cc4105e5faa6d45b472ccc4dc8e6502f28635f6a7dfce0c071e445010af9a1781c833a18c6f491f55b9e2989957b
-  data.tar.gz: 499e659d3a3284f461deede5fbcaff16ebb3476ced2c3c5c44d4d5e333d3751e45483ed221a654b0b560651127496933342e0fed5bfea8307de40edab80faa21
+  metadata.gz: be505ec75d011d31cd3c741924b2e845024d4bccdc36b3fbdfa63e0468771a45f7dd4abbc31ec6ade82ff4e992b46bd9e3aa65a06bd874a73a799f1cdb246bed
+  data.tar.gz: edcc02ff33b17e56a004836b2c55c7a133d883bc38c9f67893f3d3a59afb239bf7329454ef8278cf618e2d393867e445dc88bf539350999258c856f02c775b69

data/CHANGELOG.md

@@ -1,5 +1,48 @@
 ## [Unreleased]
 
+## [1.2.0] - 2026-05-14
+
+### Added
+- TTS (speech generation) API support
+  - `client.tts.generate(text, voice:)` and `client.generate_speech(text, voice:)` shortcut
+  - Single-speaker mode via `voice:` and multi-speaker mode via `multi_speaker: [{ speaker:, voice: }, ...]`
+  - 30 prebuilt voices exposed as `Gemini::TTS::VOICES`
+  - Default model `gemini-2.5-flash-preview-tts` (override via `model:`)
+  - `Response` helpers: `#audio_data`, `#audio_mime_type`, `#audio_response?`, `#save_audio(path)` which auto-wraps L16 PCM in a RIFF/WAVE header
+  - Demos: `tts_demo.rb` / `tts_demo_ja.rb`
+- `countTokens` API support
+  - `client.tokens.count(input, ...)` and `client.count_tokens(input, ...)` shortcut
+  - Accepts String / Array / Hash inputs, full `contents:` array, plus optional `system_instruction:`, `tools:`, `generation_config:`, `cached_content:` (auto-wraps payload in `generateContentRequest` when extra fields are present)
+  - `Response` helpers: `#count_tokens`, `#prompt_tokens_details`, `#cached_content_token_count`, `#count_tokens_response?`
+  - Demos: `count_tokens_demo.rb` / `count_tokens_demo_ja.rb`
+
+## [1.1.0] - 2026-04-29
+
+### Added
+- Live API support for real-time bidirectional audio/video/text conversations over WebSocket
+  - `Gemini::Live::Session` with event-driven API (`:setup_complete`, `:text`, `:audio`, `:tool_call`, `:turn_complete`, `:interrupted`, `:usage_metadata`, `:session_resumption`, `:go_away`, `:close`, `:error`)
+  - `Gemini::Live::Configuration` with response modality, voice, system instruction, tools, context-window compression, session resumption, manual VAD, output audio transcription
+  - `Gemini::Live::MessageBuilder` for setup, clientContent, realtimeInput, activity start/end, and tool response messages
+- Live API audio demos: `live_audio_demo.rb` (low-latency streaming), `live_audio_simple.rb`
+- Manual VAD (Voice Activity Detection) support via `automatic_activity_detection: false`
+- Live API Function Calling
+  - `Session#send_realtime_text(text)` — universal text input via `realtimeInput.text`, required by newer Live models such as `gemini-3.1-flash-live-preview`
+  - `MessageBuilder.realtime_text(text)` builder
+  - Async (NON_BLOCKING) function call support: `MessageBuilder.tool_response` validates and normalizes the `scheduling` field (`INTERRUPT`, `WHEN_IDLE`, `SILENT`), accepted either inside the response payload or as a top-level shortcut
+  - Demos: `live_function_calling_demo.rb` / `live_function_calling_demo_ja.rb`
+- Embeddings API support (`embedContent` and `batchEmbedContents`)
+  - `client.embeddings_api.create(input:, ...)` for single embeddings
+  - `client.embeddings_api.batch_create(inputs:, ...)` for batch embeddings
+  - `client.embed_content(input, ...)` shortcut that auto-routes Array inputs to batch
+  - Optional parameters: `task_type` (RETRIEVAL_QUERY, RETRIEVAL_DOCUMENT, SEMANTIC_SIMILARITY, CLASSIFICATION, CLUSTERING, QUESTION_ANSWERING, FACT_VERIFICATION, CODE_RETRIEVAL_QUERY), `title` (RETRIEVAL_DOCUMENT only), `output_dimensionality`
+  - Default model: `gemini-embedding-001`
+- `Response` helpers for embeddings: `#embedding`, `#embeddings`, `#embedding_dimension`, `#embedding_response?`
+- Demos: `embeddings_demo.rb` / `embeddings_demo_ja.rb`
+
+### Notes
+- Verified Live model compatibility on the `bidiGenerateContent` endpoint: only the native-audio variants and `gemini-3.1-flash-live-preview` are deployed today. The latter requires `realtimeInput.text` (i.e., `Session#send_realtime_text`) and `AUDIO` modality. The `gemini-2.5-flash-live-preview` model name listed in the public tools docs is not yet deployed.
+- `MessageBuilder.realtime_input` (legacy `mediaChunks` path) is documented as deprecated by the upstream API; prefer `realtime_text` going forward.
+
 ## [1.0.0] - 2026-01-28
 
 ### Added

data/README.md

@@ -30,6 +30,10 @@ This project is inspired by and pays homage to [ruby-openai](https://github.com/
 - Structured output with JSON schema and enum constraints
 - Document processing (PDFs and other formats)
 - Context caching for efficient processing
+- Text embeddings (single and batch) with task type, title, and output dimensionality control
+- Token counting (`countTokens`) for prompts, chat history, and full requests with system instruction / tools / cached content
+- Speech generation (TTS) with 30 prebuilt voices, single-speaker and multi-speaker modes, and one-line WAV file output
+- Live API: real-time bidirectional conversations with text/audio/video and function calling (sync and async)
 
 ### Function Calling
 
@@ -992,6 +996,450 @@ end
 
 For a complete example of context caching, check out the `demo/document_cache_demo.rb` file.
 
+### Live API (Real-time Conversations)
+
+The Gemini Live API provides bidirectional WebSocket-based real-time conversations with audio, video, and text support. The library wraps the protocol behind an event-driven `Gemini::Live::Session`.
+
+#### Basic Audio Conversation
+
+The default model (`gemini-2.5-flash-native-audio-preview-12-2025`) responds with audio. You receive Base64-encoded 24 kHz 16-bit PCM chunks via the `:audio` event.
+
+```ruby
+require 'gemini'
+require 'base64'
+
+client = Gemini::Client.new(ENV['GEMINI_API_KEY'])
+
+client.live.connect(
+  response_modality: "AUDIO",
+  voice_name: "Kore",
+  system_instruction: "You are a helpful assistant. Be brief."
+) do |session|
+  setup_complete = false
+  audio_chunks = []
+
+  session.on(:setup_complete) { setup_complete = true }
+  session.on(:audio)          { |data, _mime| audio_chunks << Base64.decode64(data) }
+  session.on(:turn_complete)  { puts "[#{audio_chunks.sum(&:bytesize)} bytes]" }
+  session.on(:error)          { |e| puts "Error: #{e.message}" }
+
+  sleep 0.05 until setup_complete
+
+  session.send_realtime_text("What is the capital of Japan?")
+  sleep 8
+end
+```
+
+For text-only responses, see the note below about Live model availability.
+
+#### Function Calling (Synchronous)
+
+The Live API supports function calling. Define your tools, register a `:tool_call` handler, and reply with `session.send_tool_response`.
+
+> **Note on Live model input format**
+> Newer Live models such as `gemini-3.1-flash-live-preview` reject the
+> legacy `clientContent.turns[]` payload that older models (including the
+> native-audio variants) accept. Use `session.send_realtime_text(...)`
+> instead of `session.send_text(...)`, which emits the universal
+> `realtimeInput.text` form and works on every currently-deployed Live
+> model. The `gemini-2.5-flash-live-preview` model name listed in the
+> public tools docs is not deployed on the `bidiGenerateContent` endpoint
+> at the time of writing.
+
+```ruby
+require 'base64'
+
+tools = [
+  {
+    functionDeclarations: [
+      {
+        name: "get_weather",
+        description: "Get the current weather for a location",
+        parameters: {
+          type: "object",
+          properties: {
+            location: { type: "string", description: "City name" }
+          },
+          required: ["location"]
+        }
+      }
+    ]
+  }
+]
+
+audio_chunks = []
+
+client.live.connect(
+  response_modality: "AUDIO",
+  voice_name: "Kore",
+  tools: tools,
+  system_instruction: "Use the available functions when asked about weather."
+) do |session|
+  session.on(:audio) { |data, _mime| audio_chunks << Base64.decode64(data) }
+
+  session.on(:tool_call) do |function_calls|
+    responses = function_calls.map do |call|
+      result = case call[:name]
+               when "get_weather"
+                 { temperature: 22, condition: "sunny", location: call[:args]["location"] }
+               end
+      { id: call[:id], name: call[:name], response: result }
+    end
+    session.send_tool_response(responses)
+  end
+
+  sleep 0.5  # wait for setup
+  session.send_realtime_text("What's the weather in Tokyo?")
+  sleep 18
+end
+
+# audio_chunks now contains 24 kHz, 16-bit PCM mono audio of the spoken reply.
+```
+
+A complete example is in `demo/live_function_calling_demo.rb`.
+
+#### Function Calling (Asynchronous / NON_BLOCKING)
+
+`gemini-2.5-flash-live-preview` supports asynchronous function calls. Mark a function declaration with `behavior: "NON_BLOCKING"` so the model can keep talking while the call runs, then control how the result is delivered back via `scheduling`.
+
+```ruby
+tools = [
+  {
+    functionDeclarations: [
+      {
+        name: "fetch_long_running_data",
+        behavior: "NON_BLOCKING",
+        description: "Slow data lookup",
+        parameters: { type: "object", properties: {} }
+      }
+    ]
+  }
+]
+
+session.on(:tool_call) do |function_calls|
+  responses = function_calls.map do |call|
+    {
+      id: call[:id],
+      name: call[:name],
+      response: { result: "data ready" },
+      scheduling: "INTERRUPT"  # or "WHEN_IDLE", "SILENT"
+    }
+  end
+  session.send_tool_response(responses)
+end
+```
+
+`scheduling` can also be placed inside the `response:` hash directly. Valid values: `INTERRUPT`, `WHEN_IDLE`, `SILENT`. The library validates and uppercases the value automatically; an unknown value raises `ArgumentError`.
+
+#### Built-in Tools
+
+Google Search grounding is supported in the Live API:
+
+```ruby
+client.live.connect(
+  model: "gemini-2.5-flash-live-preview",
+  tools: [{ google_search: {} }]
+) do |session|
+  # ...
+end
+```
+
+#### Supported Live API Models for Tools
+
+The public Live API tools docs list:
+
+| Model | Sync Function Calling | Async (NON_BLOCKING) | Google Search |
+|---|---|---|---|
+| `gemini-2.5-flash-live-preview` | ✓ | ✓ | ✓ |
+| `gemini-3.1-flash-live-preview` | ✓ | — | ✓ |
+
+In practice, on the `bidiGenerateContent` endpoint as of writing:
+
+- `gemini-3.1-flash-live-preview` is deployed and works with **AUDIO** response modality + tools, **but only when text input is sent via `session.send_realtime_text(...)`** (i.e., `realtimeInput.text`). It rejects the legacy `clientContent.turns[]` payload.
+- `gemini-2.5-flash-native-audio-preview-12-2025` (the library default) is deployed and accepts both `send_realtime_text` and `send_text` (legacy `clientContent.turns[]`).
+- `gemini-2.5-flash-live-preview` from the docs table is **not yet deployed**.
+
+Once a TEXT-modality-capable Live model ships, the same code works with `response_modality: "TEXT"` and the `voice_name:` argument removed.
+
+Demos available:
+
+- `demo/live_text_demo.rb` - Live API text conversation
+- `demo/live_audio_demo.rb` - Live API audio conversation
+- `demo/live_function_calling_demo.rb` - Live API function calling
+
+### Embeddings
+
+You can generate text embeddings using the Gemini Embeddings API. Embeddings are vector representations of text that can be used for semantic similarity, classification, clustering, retrieval, and more.
+
+#### Single Embedding
+
+```ruby
+require 'gemini'
+
+client = Gemini::Client.new(ENV['GEMINI_API_KEY'])
+
+response = client.embed_content(
+  "What is the meaning of life?",
+  model: "gemini-embedding-001"
+)
+
+if response.success?
+  puts "Dimension: #{response.embedding_dimension}"
+  puts "Vector (first 5 values): #{response.embedding.first(5).inspect}"
+end
+```
+
+#### Batch Embeddings
+
+Pass an Array of strings to embed multiple texts in a single batch request (uses `batchEmbedContents` under the hood):
+
+```ruby
+response = client.embed_content(
+  [
+    "I love programming in Ruby.",
+    "Rubies are red gemstones.",
+    "Python is also a programming language."
+  ],
+  model: "gemini-embedding-001",
+  task_type: :semantic_similarity
+)
+
+response.embeddings.each_with_index do |values, i|
+  puts "Embedding #{i}: dimension=#{values.size}"
+end
+```
+
+#### Task Type, Title, and Output Dimensionality
+
+You can specify a `task_type` to optimize the embedding for a particular downstream task. When `task_type: :retrieval_document` is used, you may also pass a `title`. Use `output_dimensionality` to truncate the vector length (recommended values: 768, 1536, 3072).
+
+```ruby
+response = client.embed_content(
+  "Ruby is a dynamic, open-source programming language.",
+  model: "gemini-embedding-001",
+  task_type: :retrieval_document,
+  title: "Ruby Overview",
+  output_dimensionality: 768
+)
+```
+
+Supported task types:
+
+- `RETRIEVAL_QUERY`
+- `RETRIEVAL_DOCUMENT`
+- `SEMANTIC_SIMILARITY`
+- `CLASSIFICATION`
+- `CLUSTERING`
+- `QUESTION_ANSWERING`
+- `FACT_VERIFICATION`
+- `CODE_RETRIEVAL_QUERY`
+
+You can pass them as a String, Symbol, or in any case (e.g. `:retrieval_query`, `"RETRIEVAL_QUERY"`).
+
+#### Direct Access via `embeddings_api`
+
+For more control, you can call the embeddings API directly:
+
+```ruby
+# Single
+client.embeddings_api.create(input: "Hello", model: "gemini-embedding-001")
+
+# Batch
+client.embeddings_api.batch_create(
+  inputs: ["First", "Second", "Third"],
+  model: "gemini-embedding-001",
+  task_type: :clustering
+)
+```
+
+#### Response Helpers
+
+The Response object exposes a few helpers for embedding payloads:
+
+```ruby
+response.embedding            # First embedding values (Array of Floats)
+response.embeddings           # All embedding value arrays (Array of Arrays)
+response.embedding_dimension  # Length of the first embedding vector
+response.embedding_response?  # true if the payload contains embedding data
+```
+
+A complete example is available in `demo/embeddings_demo.rb`.
+
+### Token Counting
+
+Estimate how many tokens an input would consume before sending it to a generation endpoint. Useful for cost/quota planning and for staying within a model's context window.
+
+#### Basic Usage
+
+```ruby
+require 'gemini'
+
+client = Gemini::Client.new(ENV['GEMINI_API_KEY'])
+
+response = client.count_tokens("The quick brown fox jumps over the lazy dog.")
+
+puts response.count_tokens             # => 9 (totalTokens)
+puts response.prompt_tokens_details    # => [{"modality"=>"TEXT", "tokenCount"=>9}]
+```
+
+By default the request goes to `gemini-2.5-flash`. Override it with `model:`:
+
+```ruby
+client.count_tokens("Hello", model: "gemini-2.5-pro")
+```
+
+#### Multi-turn Chat History
+
+Pass a fully formed `contents:` array (the same shape used by `generateContent`) to count tokens for an entire conversation:
+
+```ruby
+response = client.count_tokens(
+  contents: [
+    { role: "user",  parts: [{ text: "Hi, my name is Bob." }] },
+    { role: "model", parts: [{ text: "Hi Bob!" }] },
+    { role: "user",  parts: [{ text: "What's the weather like today?" }] }
+  ]
+)
+```
+
+#### With System Instruction, Tools, or Cached Content
+
+When you include `system_instruction:`, `tools:`, `generation_config:`, or `cached_content:`, the request is automatically wrapped as a `generateContentRequest` so the count reflects the full payload:
+
+```ruby
+response = client.count_tokens(
+  "What is the weather in Tokyo?",
+  system_instruction: "You are a concise weather assistant.",
+  tools: [
+    {
+      function_declarations: [
+        {
+          name: "get_weather",
+          description: "Get the current weather for a city.",
+          parameters: {
+            type: "object",
+            properties: { city: { type: "string" } },
+            required: ["city"]
+          }
+        }
+      ]
+    }
+  ]
+)
+
+puts response.count_tokens
+```
+
+#### Direct Access via `tokens`
+
+```ruby
+client.tokens.count("Hello", model: "gemini-2.5-flash")
+```
+
+#### Response Helpers
+
+```ruby
+response.count_tokens                # totalTokens from the API (Integer)
+response.prompt_tokens_details       # per-modality breakdown (Array<Hash>)
+response.cached_content_token_count  # tokens reused from cachedContent (Integer)
+response.count_tokens_response?      # true if the payload is a countTokens response
+```
+
+A complete example is available in `demo/count_tokens_demo.rb`.
+
+### Speech Generation (TTS)
+
+Generate spoken audio from text using Gemini's TTS preview models. The API returns 24 kHz, 16-bit, mono PCM (L16) audio; `Response#save_audio` wraps it in a RIFF/WAVE header so the result is directly playable.
+
+#### Single-Speaker
+
+```ruby
+require 'gemini'
+
+client = Gemini::Client.new(ENV['GEMINI_API_KEY'])
+
+response = client.generate_speech(
+  "Say cheerfully: Have a wonderful day!",
+  voice: "Kore"
+)
+
+if response.success?
+  response.save_audio("hello.wav")
+  puts response.audio_mime_type # => "audio/L16;codec=pcm;rate=24000"
+end
+```
+
+Phrase the prompt as an instruction to read text aloud (`Say ...:` / `Read the following:`); a bare phrase like `"Hello"` is treated as a chat message and rejected with a 400 error.
+
+#### Multi-Speaker
+
+Provide a `multi_speaker:` array to assign different voices to named speakers (up to 2 speakers in the current preview models). Reference the speakers by the same names in your prompt.
+
+```ruby
+script = <<~SCRIPT
+  TTS the following conversation between Joe and Jane:
+  Joe: How's it going today, Jane?
+  Jane: Not too bad, how about you?
+SCRIPT
+
+response = client.generate_speech(
+  script,
+  multi_speaker: [
+    { speaker: "Joe",  voice: "Kore" },
+    { speaker: "Jane", voice: "Puck" }
+  ]
+)
+
+response.save_audio("dialogue.wav")
+```
+
+#### Style Control
+
+You can steer tone, pace, and emotion in two ways.
+
+**1. Natural-language instruction** — describe the delivery as part of the prompt.
+
+```ruby
+client.generate_speech(
+  "Read this in a soft whisper: I have a secret... and you must never tell anyone.",
+  voice: "Zephyr"
+)
+```
+
+**2. Inline bracket tag** — put a directive like `[whispers]`, `[excited]`, `[laughs]`, `[sighs]`, `[shouting]`, etc. at the start of the text to apply that style to what follows.
+
+```ruby
+client.generate_speech(
+  "[whispers] I have a secret... and you must never tell anyone.",
+  voice: "Zephyr"
+)
+```
+
+Stick to **one style per call**: switching style mid-prompt (e.g. `[whispers] ... [excited] ...`) tends to leave the second segment in the first style or drop it entirely. If you need multiple styles, call `generate_speech` once per sentence and concatenate the audio yourself.
+
+#### Models and Voices
+
+- Default model: `gemini-2.5-flash-preview-tts` (override via `model:`)
+- Other models: `gemini-2.5-pro-preview-tts`, `gemini-3.1-flash-tts-preview`
+- 30 prebuilt voices are listed in `Gemini::TTS::VOICES` (Zephyr, Puck, Charon, Kore, Fenrir, Leda, Orus, Aoede, …). Unknown names raise `ArgumentError` at build time.
+
+#### Direct Access via `tts`
+
+```ruby
+client.tts.generate("Say hello.", voice: "Kore")
+```
+
+#### Response Helpers
+
+```ruby
+response.audio_data        # Base64-encoded PCM payload
+response.audio_mime_type   # e.g. "audio/L16;codec=pcm;rate=24000"
+response.audio_response?   # true if the payload contains audio inlineData
+response.save_audio(path)  # writes a playable .wav file and returns the path
+```
+
+A complete example is available in `demo/tts_demo.rb`.
+
 ### Structured Output with JSON Schema
 
 You can request responses in structured JSON format by specifying a JSON schema:
@@ -1232,6 +1680,10 @@ The gem includes several demo applications that showcase its functionality:
 - `demo/document_chat_demo.rb` - Document processing
 - `demo/document_conversation_demo.rb` - Conversation with documents
 - `demo/document_cache_demo.rb` - Document caching
+- `demo/embeddings_demo.rb` - Text embeddings (single and batch)
+- `demo/live_text_demo.rb` - Live API text conversation
+- `demo/live_audio_demo.rb` - Live API audio conversation
+- `demo/live_function_calling_demo.rb` - Live API function calling
 
 Run the demos with:
 
@@ -1286,6 +1738,9 @@ ruby demo/document_conversation_demo.rb path/to/document.pdf
 
 # Document caching and querying
 ruby demo/document_cache_demo.rb path/to/document.pdf
+
+# Text embeddings (single and batch)
+ruby demo/embeddings_demo.rb
 ```
 
 ## Models

data/lib/gemini/client.rb

@@ -70,6 +70,56 @@ module Gemini
       @cached_content ||= Gemini::CachedContent.new(client: self)
     end
 
+    # Live APIアクセサ
+    def live
+      @live ||= Gemini::Live.new(client: self)
+    end
+
+    # Embeddings APIアクセサ
+    def embeddings_api
+      @embeddings_api ||= Gemini::Embeddings.new(client: self)
+    end
+
+    # Token counting APIアクセサ
+    def tokens
+      @tokens ||= Gemini::Tokens.new(client: self)
+    end
+
+    # TTS (speech generation) APIアクセサ
+    def tts
+      @tts ||= Gemini::TTS.new(client: self)
+    end
+
+    # Convenience wrapper for TTS speech generation.
+    def generate_speech(text, voice: nil, multi_speaker: nil, model: Gemini::TTS::DEFAULT_MODEL,
+                        speech_config: nil, **parameters)
+      tts.generate(
+        text,
+        voice: voice,
+        multi_speaker: multi_speaker,
+        model: model,
+        speech_config: speech_config,
+        **parameters
+      )
+    end
+
+    # Convenience wrapper for countTokens.
+    # input can be a String, Array of parts/strings, Hash, or omitted when contents: is given.
+    def count_tokens(input = nil, model: Gemini::Tokens::DEFAULT_MODEL, contents: nil,
+                     system_instruction: nil, tools: nil, generation_config: nil,
+                     cached_content: nil, **parameters)
+      tokens.count(
+        input,
+        model: model,
+        contents: contents,
+        system_instruction: system_instruction,
+        tools: tools,
+        generation_config: generation_config,
+        cached_content: cached_content,
+        **parameters
+      )
+    end
+
     def reset_headers
       @extra_headers = {}
     end
@@ -112,10 +162,25 @@ module Gemini
       end
     end
     
-    # Method corresponding to OpenAI's embeddings
+    # Generate embeddings for the given input.
+    # input can be a String (single embed) or Array of Strings (batch embed).
+    # Supports task_type, title (RETRIEVAL_DOCUMENT only), and output_dimensionality.
+    def embed_content(input, model: Gemini::Embeddings::DEFAULT_MODEL, task_type: nil,
+                      title: nil, output_dimensionality: nil, **parameters)
+      embeddings_api.create(
+        input: input,
+        model: model,
+        task_type: task_type,
+        title: title,
+        output_dimensionality: output_dimensionality,
+        **parameters
+      )
+    end
+
+    # Method corresponding to OpenAI's embeddings (kept for compatibility)
     def embeddings(parameters: {})
-      model = parameters.delete(:model) || "text-embedding-model"
-      path = "models/#{model}:embedContent"
+      model = parameters.delete(:model) || Gemini::Embeddings::DEFAULT_MODEL
+      path = "models/#{model.to_s.delete_prefix("models/")}:embedContent"
       response = json_post(path: path, parameters: parameters)
       Gemini::Response.new(response)
     end