@mastra/voice-google-gemini-live 0.13.0 → 0.14.0-alpha.0

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # @mastra/voice-google-gemini-live
 
+## 0.14.0-alpha.0
+
+### Minor Changes
+
+- Added `sendContext()` method to `GeminiLiveVoice` for seeding conversation history into a fresh voice session without triggering a model response. This lets apps replay prior turns from Mastra Memory (or any external store) on a cold connect so the model has full context before the user speaks — enabling seamless handoff between text chat and voice on a shared thread. ([#18286](https://github.com/mastra-ai/mastra/pull/18286))
+
+  **Usage:**
+
+  ```ts
+  await voice.connect();
+
+  await voice.sendContext([
+    { role: 'user', content: 'What is the weather?' },
+    { role: 'assistant', content: 'It is 72°F in San Francisco.' },
+  ]);
+
+  // Model stays silent until the user actually speaks
+  await voice.send(micStream);
+  ```
+
+### Patch Changes
+
+- Fix resumeSession() always timing out. Session resumption now works end-to-end: new sessions request server-issued tokens, inbound handles are stored and emitted, and resuming reconnects with the correct handle in the setup frame. ([#18190](https://github.com/mastra-ai/mastra/pull/18190))
+
+- Fixed realtime audio streaming being immediately rejected by the Gemini Live API. Audio frames now use the current API format, replacing a deprecated payload shape that caused the connection to close on the first frame. ([#18291](https://github.com/mastra-ai/mastra/pull/18291))
+
+  The `session` event for disconnections now includes `code` and `reason` fields, so consumers can see why the server closed the connection.
+
 ## 0.13.0
 
 ### Minor Changes

package/dist/docs/SKILL.md

@@ -3,7 +3,7 @@ name: mastra-voice-google-gemini-live
 description: Documentation for @mastra/voice-google-gemini-live. Use when working with @mastra/voice-google-gemini-live APIs, configuration, or implementation.
 metadata:
   package: "@mastra/voice-google-gemini-live"
-  version: "0.13.0"
+  version: "0.14.0-alpha.0"
 ---
 
 ## When to use

package/dist/docs/assets/SOURCE_MAP.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.13.0",
+  "version": "0.14.0-alpha.0",
   "package": "@mastra/voice-google-gemini-live",
   "exports": {},
   "modules": {}

package/dist/docs/references/reference-voice-google-gemini-live.md

@@ -146,6 +146,28 @@ Converts text to speech and sends it to the model. Can accept either a string or
 
 Returns: `Promise<void>` (responses are emitted via `speaker` and `writing` events)
 
+### `sendContext()`
+
+Sends conversation history into the live session without triggering a model response. Use this to seed prior turns (e.g. from Mastra Memory) on a cold connect so the model has context before the user speaks.
+
+```typescript
+await voice.sendContext([
+  { role: 'user', content: 'What is the weather?' },
+  { role: 'assistant', content: 'It is 72°F in San Francisco.' },
+])
+
+// Model stays silent until the user actually speaks.
+await voice.send(micStream)
+```
+
+**turns** (`IncrementalTurn[]`): Prior conversation turns to seed into the session. Each turn has a \`role\` ("user" or "assistant") and \`content\` string. Both roles are supported on newer models (e.g. \`gemini-2.5-flash-native-audio-preview-12-2025\`). Some older models only accept user-role turns.
+
+**options** (`object`): Optional configuration.
+
+**options.turnComplete** (`boolean`): Whether to mark the turn as complete and trigger a model response.
+
+Returns: `Promise<void>`
+
 ### `listen()`
 
 Processes audio input for speech recognition. Takes a readable stream of audio data and returns the transcribed text.

package/dist/index.cjs

@@ -580,12 +580,10 @@ var AudioStreamManager = class {
     } else {
       return {
         realtime_input: {
-          media_chunks: [
-            {
-              mime_type: "audio/pcm",
-              data: audioData
-            }
-          ]
+          audio: {
+            mime_type: "audio/pcm",
+            data: audioData
+          }
         }
       };
     }
@@ -1808,13 +1806,9 @@ var GeminiLiveVoice = class _GeminiLiveVoice extends MastraVoice {
       this.connectionManager.setWebSocket(this.ws);
       this.setupEventListeners();
       await this.connectionManager.waitForOpen();
-      if (this.isResuming && this.sessionHandle) {
-        await this.sendSessionResumption();
-      } else {
-        this.sendInitialConfig();
-        this.sessionStartTime = Date.now();
-        this.sessionId = crypto.randomUUID();
-      }
+      this.sendInitialConfig();
+      this.sessionStartTime = Date.now();
+      this.sessionId = crypto.randomUUID();
       await this.waitForSessionCreated();
       this.state = "connected";
       this.emit("session", {
@@ -1852,10 +1846,6 @@ var GeminiLiveVoice = class _GeminiLiveVoice extends MastraVoice {
       clearTimeout(this.sessionDurationTimeout);
       this.sessionDurationTimeout = void 0;
     }
-    if (this.options.sessionConfig?.enableResumption && this.sessionId) {
-      this.sessionHandle = this.sessionId;
-      this.log("Session handle saved for resumption", { handle: this.sessionHandle });
-    }
     if (this.ws) {
       this.connectionManager.close();
       this.ws = void 0;
@@ -1930,6 +1920,56 @@ var GeminiLiveVoice = class _GeminiLiveVoice extends MastraVoice {
       throw this.createAndEmitError("audio_processing_error" /* AUDIO_PROCESSING_ERROR */, "Failed to send text message", error);
     }
   }
+  /**
+   * Send conversation history into the live session without triggering a model response.
+   *
+   * Maps to a single Gemini Live `client_content` frame with `turnComplete` defaulting
+   * to `false`, which loads the turns into context silently. The model only responds
+   * once a subsequent turn completes (e.g. via {@link speak} or user audio).
+   *
+   * @param turns Prior conversation turns to seed into the session.
+   * @param options.turnComplete Whether to mark the turn as complete (default `false`).
+   *
+   * @example
+   * ```typescript
+   * await voice.connect();
+   *
+   * // Replay prior conversation without triggering a reply.
+   * await voice.sendContext([
+   *   { role: 'user', content: 'What is the weather?' },
+   *   { role: 'assistant', content: 'It is 72°F in San Francisco.' },
+   * ]);
+   *
+   * // Agent stays silent until the user actually speaks.
+   * await voice.send(micStream);
+   * ```
+   */
+  async sendContext(turns, options) {
+    this.validateConnectionState();
+    if (!turns || turns.length === 0) {
+      this.log("sendContext called with empty turns, skipping");
+      return;
+    }
+    const message = {
+      client_content: {
+        turns: turns.map((t) => ({
+          role: t.role === "assistant" ? "model" : "user",
+          parts: [{ text: t.content }]
+        })),
+        turnComplete: options?.turnComplete ?? false
+      }
+    };
+    try {
+      this.sendEvent("client_content", message);
+      this.log("Context seeded", { turnCount: turns.length, turnComplete: options?.turnComplete ?? false });
+      for (const turn of turns) {
+        this.addToContext(turn.role, turn.content);
+      }
+    } catch (error) {
+      this.log("Failed to send context", error);
+      throw this.createAndEmitError("audio_processing_error" /* AUDIO_PROCESSING_ERROR */, "Failed to send context", error);
+    }
+  }
   /**
    * Send audio stream for processing
    */
@@ -2267,30 +2307,6 @@ var GeminiLiveVoice = class _GeminiLiveVoice extends MastraVoice {
    * Send session resumption message
    * @private
    */
-  async sendSessionResumption() {
-    if (!this.sessionHandle) {
-      throw new Error("No session handle available for resumption");
-    }
-    const context = this.contextManager.getContextArray();
-    const resumeMessage = {
-      session_resume: {
-        handle: this.sessionHandle,
-        ...context.length > 0 && {
-          context
-        }
-      }
-    };
-    try {
-      if (this.ws?.readyState !== ws.WebSocket.OPEN) {
-        throw new Error("WebSocket not ready for session resumption");
-      }
-      this.sendEvent("session_resume", resumeMessage);
-      this.log("Session resumption message sent", { handle: this.sessionHandle });
-    } catch (error) {
-      this.log("Failed to send session resumption", error);
-      throw new Error(`Failed to send session resumption: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-  }
   /**
    * Start monitoring session duration
    * @private
@@ -2362,7 +2378,7 @@ var GeminiLiveVoice = class _GeminiLiveVoice extends MastraVoice {
     this.ws.on("close", (code, reason) => {
       this.log("WebSocket connection closed", { code, reason: reason.toString() });
       this.state = "disconnected";
-      this.emit("session", { state: "disconnected" });
+      this.emit("session", { state: "disconnected", code, reason: reason.toString() });
     });
     this.ws.on("error", (error) => {
       this.log("WebSocket error", error);
@@ -2413,6 +2429,18 @@ var GeminiLiveVoice = class _GeminiLiveVoice extends MastraVoice {
     } else if (data.usageMetadata) {
       this.log("Processing usage metadata message");
       this.handleUsageUpdate(data);
+    }
+    if (data.sessionResumptionUpdate) {
+      this.log("Processing session resumption update", data.sessionResumptionUpdate);
+      if (data.sessionResumptionUpdate.resumable && data.sessionResumptionUpdate.newHandle) {
+        this.sessionHandle = data.sessionResumptionUpdate.newHandle;
+        this.log("Session handle updated from server", { handle: this.sessionHandle });
+        this.emit("sessionHandle", {
+          handle: this.sessionHandle,
+          expiresAt: new Date(Date.now() + 2 * 60 * 60 * 1e3)
+          // 2h TTL for AI Studio
+        });
+      }
     } else if (data.sessionEnd) {
       this.log("Processing session end message");
       this.handleSessionEnd(data);
@@ -2820,6 +2848,11 @@ var GeminiLiveVoice = class _GeminiLiveVoice extends MastraVoice {
         // event declared in `GeminiLiveEventMap`.
         realtime_input_config: {
           activity_handling: "START_OF_ACTIVITY_INTERRUPTS"
+        },
+        // Session resumption: empty object requests server-issued tokens on new sessions;
+        // { handle } resumes a previous session. Only included when enableResumption is set.
+        ...this.options.sessionConfig?.enableResumption && {
+          session_resumption: this.isResuming && this.sessionHandle ? { handle: this.sessionHandle } : {}
         }
       }
     };