@ai-sdk/google 4.0.83 → 4.0.85

package/docs/15-google.mdx

@@ -135,10 +135,9 @@ The following optional provider options are available for Google models:
 
   Optional. Enable structured output. Default is true.
 
-  This is useful when the JSON Schema contains elements that are
-  not supported by the OpenAPI schema version that
-  Google uses. You can use this to disable
-  structured outputs if you need to.
+  You can disable structured outputs when a schema is not supported or exceeds
+  Google's schema complexity limits. The model will still be instructed to
+  return JSON, but the schema will not be sent to Google.
 
   See [Troubleshooting: Schema Limitations](#schema-limitations) for more details.
 
@@ -995,14 +994,21 @@ Example response excerpt:
 
 #### Schema Limitations
 
-The Google Generative AI API uses a subset of the OpenAPI 3.0 schema,
-which does not support features such as unions.
-The errors that you get in this case look like this:
+The Google Generative AI API supports a subset of JSON Schema. Google notes that
+[very large or deeply nested schemas may be rejected](https://ai.google.dev/gemini-api/docs/structured-output#limitations).
+When a schema exceeds Google's complexity limit, the API may return the following
+generic error:
 
-`GenerateContentRequest.generation_config.response_schema.properties[occupation].type: must be specified`
+`Request contains an invalid argument.`
+
+You can work around this by simplifying the schema sent to Google. For example,
+remove unnecessary constraints or reduce nesting while preserving the fields
+and types the model needs to generate. If you need stricter client-side
+validation than the schema sent to Google, use [`jsonSchema`](/docs/reference/ai-sdk-core/json-schema)
+with a custom validation function or validate the generated output separately.
 
 By default, structured outputs are enabled (and for tool calling they are required).
-You can disable structured outputs for object generation as a workaround:
+You can also disable provider-enforced structured outputs for object generation:
 
 ```ts highlight="3,8"
 const { output } = await generateText({
@@ -1032,10 +1038,9 @@ const { output } = await generateText({
 });
 ```
 
-The following Zod features are known to not work with Google:
-
-- `z.union`
-- `z.record`
+When `structuredOutputs` is `false`, Google still receives the JSON response MIME type
+but not the schema. Describe the required schema in your prompt. AI SDK
+will still validate the response against the schema in `Output.object`.
 
 ### Model Capabilities
 
@@ -1147,6 +1152,18 @@ emitted as custom events. Inspect `rawType` for `goAway`,
 `sessionResumptionUpdate`, and `generationComplete` and use the event's `raw`
 payload for provider-specific details.
 
+With input audio transcription enabled, `parseServerEvent` emits
+`input-transcription-completed` events with a stable `itemId` for each user
+utterance. Each `transcript` contains the accumulated text so far. If you consume
+these events directly, replace the text for that `itemId` with `transcript` on
+each event. The realtime session handles this automatically.
+
+Google's `finished` transcription marker ends an utterance even when the marker
+contains no text. For payloads without this marker, response completion and
+interruption provide fallback boundaries. These fallback boundaries cannot
+unambiguously associate all delayed transcription fragments. Input item IDs use
+their own sequence and need not match the model's response IDs.
+
 ### Live Translation
 
 Use `gemini-3.5-live-translate-preview` for low-latency speech-to-speech

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/google",
-  "version": "4.0.83",
+  "version": "4.0.85",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -36,7 +36,7 @@
   },
   "dependencies": {
     "@ai-sdk/provider": "4.0.19",
-    "@ai-sdk/provider-utils": "5.0.50"
+    "@ai-sdk/provider-utils": "5.0.51"
   },
   "devDependencies": {
     "@ai-sdk/test-server": "2.0.2",

package/src/google-provider.ts

@@ -266,7 +266,7 @@ export function createGoogle(
         }),
         ...options.headers,
       },
-      `ai-sdk/google/${VERSION}`,
+      `ai-sdk-google/${VERSION}`,
     );
 
   const getSupportedUrls = (

package/src/realtime/google-realtime-event-mapper.ts

@@ -25,8 +25,8 @@ type GoogleRealtimeServerContent = {
       text?: string;
     }>;
   };
-  outputTranscription?: { text?: string };
-  inputTranscription?: { text?: string };
+  outputTranscription?: { text?: string; finished?: boolean };
+  inputTranscription?: { text?: string; finished?: boolean };
   turnComplete?: boolean;
   waitingForInput?: boolean;
 };
@@ -38,7 +38,7 @@ type GoogleRealtimeWireEvent = {
   };
   toolCallCancellation?: unknown;
   serverContent?: GoogleRealtimeServerContent;
-  inputTranscription?: { text?: string };
+  inputTranscription?: { text?: string; finished?: boolean };
   goAway?: { timeLeft?: string };
   sessionResumptionUpdate?: {
     newHandle?: string;
@@ -56,6 +56,11 @@ type GoogleRealtimeWireEvent = {
  */
 export class GoogleRealtimeEventMapper {
   private turnCounter = 0;
+  private inputTranscriptionCounter = 0;
+  private inputTranscriptionBuffer = '';
+  private inputTranscriptionBoundary: 'none' | 'interrupted' | 'turn-complete' =
+    'none';
+  private preserveInputTranscriptionAcrossTurnComplete = false;
   private hasAudio = false;
   private hasText = false;
   private hasTranscript = false;
@@ -71,12 +76,11 @@ export class GoogleRealtimeEventMapper {
   }
 
   /**
-   * Rolls over to the next turn lazily, only once new model content actually
-   * arrives. `turnComplete` merely marks the current turn closed; the counter
-   * is not advanced until the next response begins. This keeps a transcript
-   * that arrives shortly after `turnComplete` attached to the turn it belongs
-   * to, since Google delivers transcription independently with no guaranteed
-   * ordering relative to `turnComplete`.
+   * Rolls over to the next turn lazily, once model content for the next turn
+   * arrives. `turnComplete` merely marks the current turn closed.
+   * This keeps an output transcript that arrives shortly after `turnComplete`
+   * attached to the turn it belongs to, since Google delivers transcription
+   * independently with no guaranteed ordering relative to `turnComplete`.
    */
   private beginTurnIfClosed(): void {
     if (!this.turnClosed) return;
@@ -85,6 +89,63 @@ export class GoogleRealtimeEventMapper {
     this.hasText = false;
     this.hasTranscript = false;
     this.turnClosed = false;
+    // Once the next response starts, its completion must delimit its own
+    // input even if the interrupted response never sent a turnComplete.
+    this.preserveInputTranscriptionAcrossTurnComplete = false;
+  }
+
+  // Google streams input transcription as a sequence of non-accumulating
+  // fragments for a single user utterance (e.g. "The quick brown fox",
+  // " jumps over the", " lazy dog."). Concatenate consecutive fragments into
+  // one running transcript under a stable synthetic id so the realtime reducer
+  // (which overwrites the message for a given id) surfaces them as a single
+  // coherent user message rather than one message per fragment. Google's
+  // `finished` signal is the authoritative utterance boundary. For older
+  // payloads without that signal, response boundaries remain a fallback.
+  //
+  // Input transcriptions can arrive independently of response turn events, so
+  // their synthetic IDs use a sequence independent of `turnCounter`.
+  private accumulateInputTranscription({
+    text,
+    finished,
+  }: {
+    text?: string;
+    finished?: boolean;
+  }): { itemId: string; transcript: string } | undefined {
+    // Google can send `finished` separately from text. Process it even when
+    // text is absent or empty, without emitting an empty user message.
+    if (!text) {
+      if (finished === true) {
+        this.finishInputTranscription();
+      }
+      return undefined;
+    }
+
+    const hasFinishedSignal = finished != null;
+    if (
+      this.inputTranscriptionBuffer !== '' &&
+      (this.inputTranscriptionBoundary === 'interrupted' ||
+        (this.inputTranscriptionBoundary === 'turn-complete' &&
+          !hasFinishedSignal))
+    ) {
+      this.finishInputTranscription();
+    }
+    this.inputTranscriptionBoundary = 'none';
+    this.inputTranscriptionBuffer += text;
+    const result = {
+      itemId: `google-input-${this.inputTranscriptionCounter}`,
+      transcript: this.inputTranscriptionBuffer,
+    };
+    if (finished === true) {
+      this.finishInputTranscription();
+    }
+    return result;
+  }
+
+  private finishInputTranscription(): void {
+    if (this.inputTranscriptionBuffer === '') return;
+    this.inputTranscriptionCounter++;
+    this.inputTranscriptionBuffer = '';
   }
 
   parseServerEvent(
@@ -151,13 +212,17 @@ export class GoogleRealtimeEventMapper {
       return this.parseServerContent(data.serverContent, raw);
     }
 
-    if (data.inputTranscription?.text != null) {
-      return {
-        type: 'input-transcription-completed',
-        itemId: `google-input-${this.turnCounter}`,
-        transcript: data.inputTranscription.text,
-        raw,
-      };
+    if (data.inputTranscription != null) {
+      const transcription = this.accumulateInputTranscription(
+        data.inputTranscription,
+      );
+      if (transcription != null) {
+        return {
+          type: 'input-transcription-completed',
+          ...transcription,
+          raw,
+        };
+      }
     }
 
     return { type: 'custom', rawType: String(Object.keys(data)[0]), raw };
@@ -170,6 +235,12 @@ export class GoogleRealtimeEventMapper {
     const events: RealtimeModelV4ServerEvent[] = [];
 
     if (serverContent.interrupted) {
+      // A barge-in ends the current user utterance; the next input
+      // transcription fragment belongs to a fresh utterance. The interrupted
+      // response's trailing turnComplete must not split that new utterance.
+      this.inputTranscriptionBoundary = 'interrupted';
+      this.preserveInputTranscriptionAcrossTurnComplete = true;
+      this.turnClosed = true;
       events.push({
         type: 'speech-started',
         raw,
@@ -214,13 +285,17 @@ export class GoogleRealtimeEventMapper {
       });
     }
 
-    if (serverContent.inputTranscription?.text) {
-      events.push({
-        type: 'input-transcription-completed',
-        itemId: `google-input-${this.turnCounter}`,
-        transcript: serverContent.inputTranscription.text,
-        raw,
-      });
+    if (serverContent.inputTranscription != null) {
+      const transcription = this.accumulateInputTranscription(
+        serverContent.inputTranscription,
+      );
+      if (transcription != null) {
+        events.push({
+          type: 'input-transcription-completed',
+          ...transcription,
+          raw,
+        });
+      }
     }
 
     // `generationComplete` means generation has stopped, but playback and the
@@ -292,6 +367,17 @@ export class GoogleRealtimeEventMapper {
       // Mark the turn closed but defer advancing the counter until the next
       // response actually begins (see `beginTurnIfClosed`).
       this.turnClosed = true;
+      if (this.preserveInputTranscriptionAcrossTurnComplete) {
+        this.preserveInputTranscriptionAcrossTurnComplete = false;
+      } else {
+        // For payloads without `finished`, the completed response remains the
+        // fallback signal that the next transcription is a new utterance.
+        // A transcription carrying `finished` can still arrive late and close
+        // the preceding utterance after this response boundary.
+        if (this.inputTranscriptionBoundary !== 'interrupted') {
+          this.inputTranscriptionBoundary = 'turn-complete';
+        }
+      }
     }
 
     if (events.length === 0) {