@ai-sdk/google 4.0.111 → 4.0.112

package/docs/15-google.mdx

@@ -1358,6 +1358,8 @@ When the serialized batch creation body is under 20 MB, the provider sends the r
 
 ## Realtime Models
 
+For a trusted [server-owned connection](/docs/ai-sdk-core/realtime#server-owned-connections), `getServerWebSocketConfig()` uses the unconstrained Gemini Live endpoint with resolved API-key headers. Use `createServerEventParser()` once per socket. Completion-frame usage is attached to `response-done`; independently delivered usage uses `custom` events with `rawType: 'usageMetadata'` and typed `usage`, without inferring a response association. Gross totals never substitute for missing modality counts.
+
 <Note type="warning">Realtime is an experimental feature.</Note>
 
 You can create models that call the [Gemini Live API](https://ai.google.dev/gemini-api/docs/live)
@@ -2514,6 +2516,11 @@ the provider passes those bytes through unchanged. Older models return raw PCM,
 which the provider wraps in a WAV container. Write `result.audio.uint8Array`
 directly to disk without adding another WAV header.
 
+Set `language` to a supported BCP-47 language code, such as `en-US` or `de-DE`.
+The provider forwards explicit codes unchanged as `speechConfig.languageCode`
+for both single- and multi-speaker requests. Omit `language` or set it to `'auto'`
+to let Gemini detect the language from the input text.
+
 Gemini 3.8 supports the following `outputFormat` values:
 
 | Format | Values                 | Result                       |
@@ -2614,9 +2621,8 @@ Older models continue to use labelled transcripts, such as
 `multiSpeakerVoiceConfig` and without `turns`.
 
 <Note>
-  Gemini TTS models do not support the `speed` or `language` options; passing
-  them adds a warning to `result.warnings`. Language is detected automatically
-  from the input text.
+  Gemini TTS models do not support the `speed` option; passing it adds a warning
+  to `result.warnings`.
 </Note>
 
 ### Model Capabilities

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/google",
-  "version": "4.0.111",
+  "version": "4.0.112",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -35,8 +35,8 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/provider": "4.0.35",
-    "@ai-sdk/provider-utils": "5.0.74"
+    "@ai-sdk/provider": "4.0.36",
+    "@ai-sdk/provider-utils": "5.0.75"
   },
   "devDependencies": {
     "@ai-sdk/test-server": "2.0.4",

package/src/convert-to-google-messages.ts

@@ -466,7 +466,7 @@ export function convertToGoogleMessages(
 
               switch (part.type) {
                 case 'text': {
-                  return part.text.length === 0
+                  return part.text.length === 0 && thoughtSignature == null
                     ? undefined
                     : {
                         text: part.text,
@@ -475,7 +475,7 @@ export function convertToGoogleMessages(
                 }
 
                 case 'reasoning': {
-                  return part.text.length === 0
+                  return part.text.length === 0 && thoughtSignature == null
                     ? undefined
                     : {
                         text: part.text,

package/src/google-language-model.ts

@@ -978,6 +978,19 @@ export class GoogleLanguageModel implements LanguageModelV4 {
         return;
       }
 
+      // Finalized partial-argument calls also separate surrounding blocks.
+      if (currentTextBlockId !== null) {
+        controller.enqueue({ type: 'text-end', id: currentTextBlockId });
+        currentTextBlockId = null;
+      }
+      if (currentReasoningBlockId !== null) {
+        controller.enqueue({
+          type: 'reasoning-end',
+          id: currentReasoningBlockId,
+        });
+        currentReasoningBlockId = null;
+      }
+
       const { finalJSON, closingDelta } = active.accumulator.finalize();
 
       if (closingDelta.length > 0) {
@@ -1182,16 +1195,40 @@ export class GoogleLanguageModel implements LanguageModelV4 {
                     : undefined;
 
                   if (part.text.length === 0) {
-                    if (
-                      thoughtSignatureMetadata != null &&
-                      currentTextBlockId !== null
-                    ) {
-                      controller.enqueue({
-                        type: 'text-delta',
-                        id: currentTextBlockId,
-                        delta: '',
-                        providerMetadata: thoughtSignatureMetadata,
-                      });
+                    if (thoughtSignatureMetadata != null) {
+                      if (currentTextBlockId !== null) {
+                        controller.enqueue({
+                          type: 'text-delta',
+                          id: currentTextBlockId,
+                          delta: '',
+                          providerMetadata: thoughtSignatureMetadata,
+                        });
+                      } else {
+                        if (currentReasoningBlockId !== null) {
+                          controller.enqueue({
+                            type: 'reasoning-end',
+                            id: currentReasoningBlockId,
+                          });
+                          currentReasoningBlockId = null;
+                        }
+
+                        // Keep the signature in position without merging later content.
+                        const id = String(blockCounter++);
+                        const type =
+                          part.thought === true ? 'reasoning' : 'text';
+                        controller.enqueue({
+                          type: `${type}-start`,
+                          id,
+                          providerMetadata: thoughtSignatureMetadata,
+                        });
+                        controller.enqueue({
+                          type: `${type}-delta`,
+                          id,
+                          delta: '',
+                          providerMetadata: thoughtSignatureMetadata,
+                        });
+                        controller.enqueue({ type: `${type}-end`, id });
+                      }
                     }
                   } else if (part.thought === true) {
                     // End any active text block before starting reasoning
@@ -1316,67 +1353,108 @@ export class GoogleLanguageModel implements LanguageModelV4 {
                     providerMetadata: serverMeta,
                   });
                   lastServerToolCallId = undefined;
-                }
-              }
+                } else if ('functionCall' in part) {
+                  const providerMeta = part.thoughtSignature
+                    ? wrapProviderMetadata({
+                        thoughtSignature: part.thoughtSignature,
+                      })
+                    : undefined;
 
-              // Handle streaming and complete function calls
-              for (const part of parts) {
-                if (!('functionCall' in part)) continue;
-
-                const providerMeta = part.thoughtSignature
-                  ? wrapProviderMetadata({
-                      thoughtSignature: part.thoughtSignature,
-                    })
-                  : undefined;
-
-                const isStreamingChunk =
-                  part.functionCall.partialArgs != null ||
-                  (part.functionCall.name != null &&
-                    part.functionCall.willContinue === true);
-                const isTerminalChunk =
-                  part.functionCall.name == null &&
-                  part.functionCall.args == null &&
-                  part.functionCall.partialArgs == null &&
-                  part.functionCall.willContinue == null;
-                const isCompleteCall =
-                  part.functionCall.name != null &&
-                  part.functionCall.args != null &&
-                  part.functionCall.partialArgs == null;
-                // Single-chunk no-args call: `{ name: 'X' }` with no `args`,
-                // `partialArgs`, or `willContinue`. Carries `thoughtSignature`.
-                const isNoArgsCompleteCall =
-                  part.functionCall.name != null &&
-                  part.functionCall.args == null &&
-                  part.functionCall.partialArgs == null &&
-                  part.functionCall.willContinue !== true;
-
-                if (isStreamingChunk) {
-                  if (part.functionCall.name != null) {
-                    const toolCallId = part.functionCall.id || generateId();
-                    const accumulator = new GoogleJSONAccumulator();
-                    activeStreamingToolCalls.push({
-                      toolCallId,
-                      toolName: part.functionCall.name,
-                      accumulator,
-                      providerMetadata: providerMeta,
-                    });
+                  const isStreamingChunk =
+                    part.functionCall.partialArgs != null ||
+                    (part.functionCall.name != null &&
+                      part.functionCall.willContinue === true);
+                  const isTerminalChunk =
+                    part.functionCall.name == null &&
+                    part.functionCall.args == null &&
+                    part.functionCall.partialArgs == null &&
+                    part.functionCall.willContinue == null;
+                  const isCompleteCall =
+                    part.functionCall.name != null &&
+                    part.functionCall.args != null &&
+                    part.functionCall.partialArgs == null;
+                  // Single-chunk no-args call: `{ name: 'X' }` with no `args`,
+                  // `partialArgs`, or `willContinue`. Carries `thoughtSignature`.
+                  const isNoArgsCompleteCall =
+                    part.functionCall.name != null &&
+                    part.functionCall.args == null &&
+                    part.functionCall.partialArgs == null &&
+                    part.functionCall.willContinue !== true;
+
+                  if (
+                    !isStreamingChunk &&
+                    (isCompleteCall || isNoArgsCompleteCall)
+                  ) {
+                    if (currentTextBlockId !== null) {
+                      controller.enqueue({
+                        type: 'text-end',
+                        id: currentTextBlockId,
+                      });
+                      currentTextBlockId = null;
+                    }
+                    if (currentReasoningBlockId !== null) {
+                      controller.enqueue({
+                        type: 'reasoning-end',
+                        id: currentReasoningBlockId,
+                      });
+                      currentReasoningBlockId = null;
+                    }
+                  }
 
-                    controller.enqueue({
-                      type: 'tool-input-start',
-                      id: toolCallId,
-                      toolName: part.functionCall.name,
-                      providerMetadata: providerMeta,
-                    });
+                  if (isStreamingChunk) {
+                    if (part.functionCall.name != null) {
+                      const toolCallId = part.functionCall.id || generateId();
+                      const accumulator = new GoogleJSONAccumulator();
+                      activeStreamingToolCalls.push({
+                        toolCallId,
+                        toolName: part.functionCall.name,
+                        accumulator,
+                        providerMetadata: providerMeta,
+                      });
+
+                      controller.enqueue({
+                        type: 'tool-input-start',
+                        id: toolCallId,
+                        toolName: part.functionCall.name,
+                        providerMetadata: providerMeta,
+                      });
 
-                    if (part.functionCall.partialArgs != null) {
+                      if (part.functionCall.partialArgs != null) {
+                        const partialArgs = part.functionCall
+                          .partialArgs as PartialArg[];
+                        const { textDelta } =
+                          accumulator.processPartialArgs(partialArgs);
+                        if (textDelta.length > 0) {
+                          controller.enqueue({
+                            type: 'tool-input-delta',
+                            id: toolCallId,
+                            delta: textDelta,
+                            providerMetadata: providerMeta,
+                          });
+                        }
+                        if (
+                          part.functionCall.willContinue !== true &&
+                          partialArgs.every(arg => arg.willContinue !== true)
+                        ) {
+                          finishActiveStreamingToolCall(controller);
+                        }
+                      }
+                    } else if (
+                      part.functionCall.partialArgs != null &&
+                      activeStreamingToolCalls.length > 0
+                    ) {
+                      const active =
+                        activeStreamingToolCalls[
+                          activeStreamingToolCalls.length - 1
+                        ];
                       const partialArgs = part.functionCall
                         .partialArgs as PartialArg[];
                       const { textDelta } =
-                        accumulator.processPartialArgs(partialArgs);
+                        active.accumulator.processPartialArgs(partialArgs);
                       if (textDelta.length > 0) {
                         controller.enqueue({
                           type: 'tool-input-delta',
-                          id: toolCallId,
+                          id: active.toolCallId,
                           delta: textDelta,
                           providerMetadata: providerMeta,
                         });
@@ -1389,100 +1467,74 @@ export class GoogleLanguageModel implements LanguageModelV4 {
                       }
                     }
                   } else if (
-                    part.functionCall.partialArgs != null &&
+                    isTerminalChunk &&
                     activeStreamingToolCalls.length > 0
                   ) {
-                    const active =
-                      activeStreamingToolCalls[
-                        activeStreamingToolCalls.length - 1
-                      ];
-                    const partialArgs = part.functionCall
-                      .partialArgs as PartialArg[];
-                    const { textDelta } =
-                      active.accumulator.processPartialArgs(partialArgs);
-                    if (textDelta.length > 0) {
-                      controller.enqueue({
-                        type: 'tool-input-delta',
-                        id: active.toolCallId,
-                        delta: textDelta,
-                        providerMetadata: providerMeta,
-                      });
-                    }
-                    if (
-                      part.functionCall.willContinue !== true &&
-                      partialArgs.every(arg => arg.willContinue !== true)
-                    ) {
-                      finishActiveStreamingToolCall(controller);
-                    }
-                  }
-                } else if (
-                  isTerminalChunk &&
-                  activeStreamingToolCalls.length > 0
-                ) {
-                  finishActiveStreamingToolCall(controller);
-                } else if (isCompleteCall) {
-                  const toolCallId = part.functionCall.id || generateId();
-                  const toolName = part.functionCall.name!;
-                  const args =
-                    typeof part.functionCall.args === 'string'
-                      ? part.functionCall.args
-                      : JSON.stringify(part.functionCall.args ?? {});
+                    finishActiveStreamingToolCall(controller);
+                  } else if (isCompleteCall) {
+                    const toolCallId = part.functionCall.id || generateId();
+                    const toolName = part.functionCall.name!;
+                    const args =
+                      typeof part.functionCall.args === 'string'
+                        ? part.functionCall.args
+                        : JSON.stringify(part.functionCall.args ?? {});
 
-                  controller.enqueue({
-                    type: 'tool-input-start',
-                    id: toolCallId,
-                    toolName,
-                    providerMetadata: providerMeta,
-                  });
+                    controller.enqueue({
+                      type: 'tool-input-start',
+                      id: toolCallId,
+                      toolName,
+                      providerMetadata: providerMeta,
+                    });
 
-                  controller.enqueue({
-                    type: 'tool-input-delta',
-                    id: toolCallId,
-                    delta: args,
-                    providerMetadata: providerMeta,
-                  });
+                    controller.enqueue({
+                      type: 'tool-input-delta',
+                      id: toolCallId,
+                      delta: args,
+                      providerMetadata: providerMeta,
+                    });
 
-                  controller.enqueue({
-                    type: 'tool-input-end',
-                    id: toolCallId,
-                    providerMetadata: providerMeta,
-                  });
+                    controller.enqueue({
+                      type: 'tool-input-end',
+                      id: toolCallId,
+                      providerMetadata: providerMeta,
+                    });
 
-                  controller.enqueue({
-                    type: 'tool-call',
-                    toolCallId,
-                    toolName,
-                    input: args,
-                    providerMetadata: providerMeta,
-                  });
+                    controller.enqueue({
+                      type: 'tool-call',
+                      toolCallId,
+                      toolName,
+                      input: args,
+                      providerMetadata: providerMeta,
+                    });
 
-                  hasToolCalls = true;
-                } else if (isNoArgsCompleteCall) {
-                  const toolCallId = part.functionCall.id || generateId();
-                  const toolName = part.functionCall.name!;
+                    hasToolCalls = true;
+                  } else if (isNoArgsCompleteCall) {
+                    const toolCallId = part.functionCall.id || generateId();
+                    const toolName = part.functionCall.name!;
 
-                  controller.enqueue({
-                    type: 'tool-input-start',
-                    id: toolCallId,
-                    toolName,
-                    providerMetadata: providerMeta,
-                  });
+                    controller.enqueue({
+                      type: 'tool-input-start',
+                      id: toolCallId,
+                      toolName,
+                      providerMetadata: providerMeta,
+                    });
 
-                  controller.enqueue({
-                    type: 'tool-input-end',
-                    id: toolCallId,
-                    providerMetadata: providerMeta,
-                  });
+                    controller.enqueue({
+                      type: 'tool-input-end',
+                      id: toolCallId,
+                      providerMetadata: providerMeta,
+                    });
 
-                  controller.enqueue({
-                    type: 'tool-call',
-                    toolCallId,
-                    toolName,
-                    input: '{}',
-                    providerMetadata: providerMeta,
-                  });
+                    controller.enqueue({
+                      type: 'tool-call',
+                      toolCallId,
+                      toolName,
+                      input: '{}',
+                      providerMetadata: providerMeta,
+                    });
 
-                  hasToolCalls = true;
+                    hasToolCalls = true;
+                  }
                 }
               }
             }

package/src/google-speech-model.ts

@@ -128,9 +128,16 @@ export class GoogleSpeechModel implements SpeechModelV4 {
 
     // Multi-speaker (provider option) takes precedence over the single voice.
     const multiSpeakerVoiceConfig = googleOptions?.multiSpeakerVoiceConfig;
+    const languageCode = language === 'auto' ? undefined : language;
     const speechConfig = multiSpeakerVoiceConfig
-      ? { multiSpeakerVoiceConfig }
-      : { voiceConfig: { prebuiltVoiceConfig: { voiceName: voice } } };
+      ? {
+          multiSpeakerVoiceConfig,
+          ...(languageCode != null && { languageCode }),
+        }
+      : {
+          voiceConfig: { prebuiltVoiceConfig: { voiceName: voice } },
+          ...(languageCode != null && { languageCode }),
+        };
 
     // Older models expect directions in the prompt. Prepending them to a
     // labelled multi-speaker transcript would break speaker parsing.
@@ -217,16 +224,6 @@ export class GoogleSpeechModel implements SpeechModelV4 {
       });
     }
 
-    if (language != null) {
-      warnings.push({
-        type: 'unsupported',
-        feature: 'language',
-        details:
-          'Google Gemini TTS models do not support the `language` option. ' +
-          'Language is detected automatically from the input text.',
-      });
-    }
-
     const formats: Record<string, string> = usesStructuredSpeech
       ? {
           wav: 'AUDIO_WAV',

package/src/google-video-model.ts

@@ -232,7 +232,7 @@ export class GoogleVideoModel implements VideoModelV4 {
       parameters.durationSeconds = options.duration;
     }
 
-    if (options.seed) {
+    if (options.seed != null) {
       parameters.seed = options.seed;
     }
 

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

@@ -4,6 +4,7 @@ import type {
   Experimental_RealtimeModelV4FunctionCallOutput as RealtimeModelV4FunctionCallOutput,
   Experimental_RealtimeModelV4ServerEvent as RealtimeModelV4ServerEvent,
   Experimental_RealtimeModelV4SessionConfig as RealtimeModelV4SessionConfig,
+  Experimental_RealtimeModelV4Usage as RealtimeModelV4Usage,
 } from '@ai-sdk/provider';
 import { isRecord, safeParseJSON } from '@ai-sdk/provider-utils';
 import { getModelPath } from '../get-model-path';
@@ -31,6 +32,22 @@ type GoogleRealtimeServerContent = {
   waitingForInput?: boolean;
 };
 
+type GoogleRealtimeTokenDetail = {
+  modality?: string;
+  tokenCount?: number;
+};
+
+type GoogleRealtimeUsageMetadata = {
+  promptTokenCount?: number;
+  responseTokenCount?: number;
+  totalTokenCount?: number;
+  toolUsePromptTokenCount?: number;
+  thoughtsTokenCount?: number;
+  cachedContentTokenCount?: number;
+  promptTokensDetails?: GoogleRealtimeTokenDetail[];
+  responseTokensDetails?: GoogleRealtimeTokenDetail[];
+};
+
 type GoogleRealtimeWireEvent = {
   setupComplete?: unknown;
   toolCall?: {
@@ -38,6 +55,7 @@ type GoogleRealtimeWireEvent = {
   };
   toolCallCancellation?: unknown;
   serverContent?: GoogleRealtimeServerContent;
+  usageMetadata?: GoogleRealtimeUsageMetadata;
   inputTranscription?: { text?: string; finished?: boolean };
   goAway?: { timeLeft?: string };
   sessionResumptionUpdate?: {
@@ -150,6 +168,37 @@ export class GoogleRealtimeEventMapper {
 
   parseServerEvent(
     raw: unknown,
+  ): RealtimeModelV4ServerEvent | RealtimeModelV4ServerEvent[] {
+    const events = this.parseEvent(raw);
+    const usage = mapGoogleUsage(
+      (raw as GoogleRealtimeWireEvent).usageMetadata,
+    );
+    if (usage == null) return events;
+    const list = Array.isArray(events) ? events : [events];
+    // Only a shared wire frame establishes an association with a completion.
+    if (list.some(event => event.type === 'response-done')) {
+      const mapped = list.map(event =>
+        event.type === 'response-done' ? { ...event, usage } : event,
+      );
+      return Array.isArray(events) ? mapped : mapped[0];
+    }
+    const update: RealtimeModelV4ServerEvent = {
+      type: 'custom',
+      rawType: 'usageMetadata',
+      usage,
+      raw,
+    };
+    if (
+      list.length === 1 &&
+      list[0].type === 'custom' &&
+      list[0].rawType === 'usageMetadata'
+    )
+      return update;
+    return [...list, update];
+  }
+
+  private parseEvent(
+    raw: unknown,
   ): RealtimeModelV4ServerEvent | RealtimeModelV4ServerEvent[] {
     const data = raw as GoogleRealtimeWireEvent;
 
@@ -448,6 +497,80 @@ export class GoogleRealtimeEventMapper {
   }
 }
 
+/**
+ * Maps Gemini Live `usageMetadata` to normalized usage. Google reports usage
+ * per modality in `promptTokensDetails` / `responseTokensDetails`.
+ *
+ * Field names are Live-API-specific: the Live `UsageMetadata` uses
+ * `responseTokenCount` / `responseTokensDetails` for output, NOT the
+ * `candidatesTokenCount` / `candidatesTokensDetails` of the regular
+ * `generateContent` response (see google-language-model.ts). Do not "align"
+ * these to `candidates*` — they are different wire shapes.
+ *
+ * Gross totals preserve provider counts even when modality details are absent
+ * or contain modalities without a dedicated normalized bucket. Never guess a
+ * text/audio split from those totals.
+ */
+function mapGoogleUsage(
+  usageMetadata: GoogleRealtimeUsageMetadata | undefined,
+): RealtimeModelV4Usage | undefined {
+  if (usageMetadata == null) return undefined;
+
+  const input = sumByModality(usageMetadata.promptTokensDetails);
+  const output = sumByModality(usageMetadata.responseTokensDetails);
+
+  return compactUsage({
+    inputTokens:
+      usageMetadata.promptTokenCount != null
+        ? usageMetadata.promptTokenCount +
+          (usageMetadata.toolUsePromptTokenCount ?? 0)
+        : undefined,
+    outputTokens:
+      usageMetadata.responseTokenCount != null
+        ? usageMetadata.responseTokenCount +
+          (usageMetadata.thoughtsTokenCount ?? 0)
+        : undefined,
+    cachedInputTokens: usageMetadata.cachedContentTokenCount,
+    inputTextTokens: input.text,
+    inputAudioTokens: input.audio,
+    outputTextTokens: output.text,
+    outputAudioTokens: output.audio,
+  });
+}
+
+/** Aggregate Gemini per-modality token details into text/audio buckets. */
+function sumByModality(details: GoogleRealtimeTokenDetail[] | undefined): {
+  text?: number;
+  audio?: number;
+} {
+  if (details == null) return {};
+  const totals: { text?: number; audio?: number } = {};
+  for (const detail of details) {
+    const count = detail.tokenCount;
+    if (count == null) continue;
+    const modality = detail.modality?.toUpperCase();
+    if (modality === 'AUDIO') {
+      totals.audio = (totals.audio ?? 0) + count;
+    } else if (modality === 'TEXT') {
+      totals.text = (totals.text ?? 0) + count;
+    }
+  }
+  return totals;
+}
+
+/** Drop `undefined` fields; return `undefined` when nothing is observable. */
+function compactUsage(
+  usage: RealtimeModelV4Usage,
+): RealtimeModelV4Usage | undefined {
+  const result: RealtimeModelV4Usage = {};
+  for (const [key, value] of Object.entries(usage)) {
+    if (value != null) {
+      result[key as keyof RealtimeModelV4Usage] = value;
+    }
+  }
+  return Object.keys(result).length > 0 ? result : undefined;
+}
+
 /**
  * The value Gemini accepts for `functionResponse.response`.
  *