@ai-sdk/google 4.0.71 → 4.0.73

package/docs/15-google.mdx

@@ -1186,6 +1186,50 @@ Gemini Live Translation accepts audio input and produces translated audio
 output. Text input, tools, and custom instructions are not supported by this
 model.
 
+### Gemini 3.8 Live
+
+`gemini-3.8-live` and `gemini-3.8-live-extended-thinking` are audio-only
+realtime models: request `outputModalities: ['audio']`, and add
+`outputAudioTranscription: {}` if you want the assistant's transcript as
+`audio-transcript-delta` events. Server-side voice activity detection and
+proactive audio are always on.
+
+`gemini-3.8-live-extended-thinking` reasons in the background while streaming
+audio. Google requires exactly one of `thinkingLevel` (`low`, `medium`, `high`)
+or `thinkingBudget` for it; the provider sends `thinkingLevel: 'low'` when you
+set neither. Override it through `providerOptions.google.thinkingConfig`:
+
+```ts
+import {
+  google,
+  type Experimental_GoogleRealtimeModelOptions as GoogleRealtimeModelOptions,
+} from '@ai-sdk/google';
+
+const token = await google.experimental_realtime.getToken({
+  model: 'gemini-3.8-live-extended-thinking',
+  sessionConfig: {
+    outputModalities: ['audio'],
+    outputAudioTranscription: {},
+    providerOptions: {
+      google: {
+        thinkingConfig: { thinkingLevel: 'high' },
+      } satisfies GoogleRealtimeModelOptions,
+    },
+  },
+});
+```
+
+Tools declared in the session config run asynchronously (`NON_BLOCKING`) by
+default on these models, so the model keeps talking while a tool call is in
+flight. Set `providerOptions.google.defaultToolBehavior: 'BLOCKING'` on
+`gemini-3.8-live` to make it wait for the result instead.
+
+On the extended thinking model, `turnComplete` (the `response-done` event) does
+not mean the model is idle. Watch the `interactionStatus` custom event: its
+`raw.interactionStatus` is `IN_PROGRESS`, `IDLE`, or `WAITING_FOR_INPUT`. A
+`waitingForInput` custom event is emitted when the model has stopped and needs
+user input to continue.
+
 ## Translation Models
 
 <Note type="warning">Speech translation is an experimental feature.</Note>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/google",
-  "version": "4.0.71",
+  "version": "4.0.73",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -35,8 +35,8 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/provider": "4.0.15",
-    "@ai-sdk/provider-utils": "5.0.41"
+    "@ai-sdk/provider": "4.0.16",
+    "@ai-sdk/provider-utils": "5.0.42"
   },
   "devDependencies": {
     "@ai-sdk/test-server": "2.0.1",

package/src/google-language-model.ts

@@ -726,9 +726,12 @@ export class GoogleLanguageModel implements LanguageModelV4 {
       raw: undefined,
     };
     let usage: GoogleUsageMetadata | undefined = undefined;
-    let providerMetadata: SharedV4ProviderMetadata | undefined = undefined;
+    let promptFeedback: PromptFeedbackSchema | null = null;
     let lastGroundingMetadata: GroundingMetadataSchema | null = null;
     let lastUrlContextMetadata: UrlContextMetadataSchema | null = null;
+    let lastSafetyRatings: SafetyRatingSchema[] | null = null;
+    let lastFinishMessage: string | null = null;
+    let confirmedPromptBlockReason: string | undefined;
 
     const generateId = this.config.generateId;
     let hasToolCalls = false;
@@ -825,38 +828,48 @@ export class GoogleLanguageModel implements LanguageModelV4 {
               usage = usageMetadata;
             }
 
-            const candidate = value.candidates?.[0];
+            if (
+              value.promptFeedback != null &&
+              confirmedPromptBlockReason == null
+            ) {
+              promptFeedback = value.promptFeedback;
 
-            // sometimes the API returns an empty candidates array
-            if (candidate == null) {
-              const promptBlockReason = value.promptFeedback?.blockReason;
-              if (promptBlockReason != null) {
+              if (
+                isConfirmedPromptBlockReason(value.promptFeedback.blockReason)
+              ) {
+                confirmedPromptBlockReason = value.promptFeedback.blockReason;
                 finishReason = {
                   unified: 'content-filter',
-                  raw: promptBlockReason,
+                  raw: confirmedPromptBlockReason,
                 };
-                providerMetadata = wrapProviderMetadata({
-                  promptFeedback: value.promptFeedback ?? null,
-                  groundingMetadata: lastGroundingMetadata,
-                  urlContextMetadata: lastUrlContextMetadata,
-                  safetyRatings: null,
-                  usageMetadata: usageMetadata ?? null,
-                  finishMessage: null,
-                  serviceTier: usage?.serviceTier ?? null,
-                } satisfies GoogleProviderMetadata);
               }
-              return;
             }
 
-            const content = candidate.content;
+            const candidate = value.candidates?.[0];
 
-            if (candidate.groundingMetadata != null) {
-              lastGroundingMetadata = candidate.groundingMetadata;
+            if (candidate != null) {
+              if (candidate.groundingMetadata != null) {
+                lastGroundingMetadata = candidate.groundingMetadata;
+              }
+              if (candidate.urlContextMetadata != null) {
+                lastUrlContextMetadata = candidate.urlContextMetadata;
+              }
+              if (candidate.safetyRatings != null) {
+                lastSafetyRatings = candidate.safetyRatings;
+              }
+              if (candidate.finishMessage != null) {
+                lastFinishMessage = candidate.finishMessage;
+              }
             }
-            if (candidate.urlContextMetadata != null) {
-              lastUrlContextMetadata = candidate.urlContextMetadata;
+
+            // A confirmed prompt block is terminal for generated content, but
+            // later chunks can still contribute usage and provider metadata.
+            if (confirmedPromptBlockReason != null || candidate == null) {
+              return;
             }
 
+            const content = candidate.content;
+
             const sources = extractSources({
               groundingMetadata: candidate.groundingMetadata,
               generateId,
@@ -1222,32 +1235,14 @@ export class GoogleLanguageModel implements LanguageModelV4 {
               }
             }
 
-            const promptBlockReason = value.promptFeedback?.blockReason;
-            const isPromptBlocked =
-              candidate.finishReason == null && promptBlockReason != null;
-            const rawFinishReason =
-              candidate.finishReason ?? promptBlockReason ?? undefined;
-
-            if (rawFinishReason != null) {
+            if (candidate.finishReason != null) {
               finishReason = {
-                unified: isPromptBlocked
-                  ? 'content-filter'
-                  : mapGoogleFinishReason({
-                      finishReason: rawFinishReason,
-                      hasToolCalls,
-                    }),
-                raw: rawFinishReason,
+                unified: mapGoogleFinishReason({
+                  finishReason: candidate.finishReason,
+                  hasToolCalls,
+                }),
+                raw: candidate.finishReason,
               };
-
-              providerMetadata = wrapProviderMetadata({
-                promptFeedback: value.promptFeedback ?? null,
-                groundingMetadata: lastGroundingMetadata,
-                urlContextMetadata: lastUrlContextMetadata,
-                safetyRatings: candidate.safetyRatings ?? null,
-                usageMetadata: usageMetadata ?? null,
-                finishMessage: candidate.finishMessage ?? null,
-                serviceTier: usage?.serviceTier ?? null,
-              } satisfies GoogleProviderMetadata);
             }
           },
 
@@ -1269,7 +1264,15 @@ export class GoogleLanguageModel implements LanguageModelV4 {
               type: 'finish',
               finishReason,
               usage: convertGoogleUsage(usage),
-              providerMetadata,
+              providerMetadata: wrapProviderMetadata({
+                promptFeedback,
+                groundingMetadata: lastGroundingMetadata,
+                urlContextMetadata: lastUrlContextMetadata,
+                safetyRatings: lastSafetyRatings,
+                usageMetadata: usage ?? null,
+                finishMessage: lastFinishMessage,
+                serviceTier: usage?.serviceTier ?? null,
+              } satisfies GoogleProviderMetadata),
             });
           },
         }),
@@ -1794,3 +1797,14 @@ const chunkSchema = lazySchema(() =>
 );
 
 type ChunkSchema = InferSchema<typeof chunkSchema>;
+
+function isConfirmedPromptBlockReason(
+  blockReason: string | null | undefined,
+): blockReason is string {
+  return (
+    blockReason != null &&
+    blockReason !== '' &&
+    blockReason !== 'BLOCK_REASON_UNSPECIFIED' &&
+    blockReason !== 'BLOCKED_REASON_UNSPECIFIED'
+  );
+}

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

@@ -17,6 +17,7 @@ type GoogleRealtimeFunctionCall = {
 
 type GoogleRealtimeServerContent = {
   generationComplete?: boolean;
+  interactionStatus?: string;
   interrupted?: boolean;
   modelTurn?: {
     parts?: Array<{
@@ -27,6 +28,7 @@ type GoogleRealtimeServerContent = {
   outputTranscription?: { text?: string };
   inputTranscription?: { text?: string };
   turnComplete?: boolean;
+  waitingForInput?: boolean;
 };
 
 type GoogleRealtimeWireEvent = {
@@ -232,6 +234,30 @@ export class GoogleRealtimeEventMapper {
       });
     }
 
+    // `interactionStatus` (IN_PROGRESS | IDLE | WAITING_FOR_INPUT) is the definitive
+    // session-activity signal for background-reasoning models: `turnComplete`
+    // no longer implies the model is idle, since asynchronous tool calls and
+    // audio may still follow. Surface it as a custom event so clients can
+    // coordinate state on it.
+    if (serverContent.interactionStatus != null) {
+      events.push({
+        type: 'custom',
+        rawType: 'interactionStatus',
+        raw,
+      });
+    }
+
+    // `waitingForInput` is the always-on Proactive Audio turn-taking signal:
+    // the model has yielded the floor and is not generating because it
+    // expects the user to continue.
+    if (serverContent.waitingForInput) {
+      events.push({
+        type: 'custom',
+        rawType: 'waitingForInput',
+        raw,
+      });
+    }
+
     if (serverContent.turnComplete) {
       if (this.hasAudio) {
         events.push({
@@ -377,6 +403,16 @@ async function serializeFunctionCallOutput(
   };
 }
 
+/**
+ * Live models that reason in the background (e.g. `gemini-3.8-live-extended-thinking`).
+ * Google requires exactly one of `thinkingLevel` / `thinkingBudget` in their setup and
+ * rejects `thinkingConfig` on every other Live model.
+ */
+function isThinkingLiveModel(modelId: string): boolean {
+  const modelName = modelId.split('/').at(-1)?.toLowerCase() ?? '';
+  return /^gemini-\d+\.\d+-live\b.*thinking/.test(modelName);
+}
+
 /**
  * Builds a Google-specific session configuration from a normalized config.
  * Used to construct the `bidiGenerateContentSetup` payload for auth token creation.
@@ -389,6 +425,11 @@ export function buildGoogleSessionConfig(
     model: getModelPath(modelId),
   };
 
+  const { google, ...restProviderOptions } = config?.providerOptions ?? {};
+  const googleOptions = isRecord(google)
+    ? (google as GoogleRealtimeModelOptions)
+    : undefined;
+
   const generationConfig: Record<string, unknown> = {};
 
   if (config?.outputModalities != null) {
@@ -424,6 +465,9 @@ export function buildGoogleSessionConfig(
           name: tool.name,
           description: tool.description,
           parametersJsonSchema: tool.parameters,
+          ...(googleOptions?.defaultToolBehavior != null
+            ? { behavior: googleOptions.defaultToolBehavior }
+            : {}),
         })),
       },
     ];
@@ -437,16 +481,28 @@ export function buildGoogleSessionConfig(
     setup.outputAudioTranscription = {};
   }
 
+  // Default to the lowest-latency thinking level so a session on a
+  // background-reasoning model works without provider options. Merged last so
+  // it survives a raw `providerOptions.generationConfig`.
+  const thinkingConfig =
+    googleOptions?.thinkingConfig ??
+    (isThinkingLiveModel(modelId)
+      ? { thinkingLevel: 'low' as const }
+      : undefined);
+  const applyThinkingConfig = () => {
+    if (thinkingConfig == null) return;
+    const target = isRecord(setup.generationConfig)
+      ? setup.generationConfig
+      : generationConfig;
+    setup.generationConfig = { ...target, thinkingConfig };
+  };
+
   if (config?.providerOptions == null) {
+    applyThinkingConfig();
     return setup;
   }
 
-  const { google, ...providerOptions } = config.providerOptions;
-  Object.assign(setup, providerOptions);
-
-  const googleOptions = isRecord(google)
-    ? (google as GoogleRealtimeModelOptions)
-    : undefined;
+  Object.assign(setup, restProviderOptions);
 
   if (googleOptions?.translationConfig != null) {
     const target = isRecord(setup.generationConfig)
@@ -458,5 +514,6 @@ export function buildGoogleSessionConfig(
     };
   }
 
+  applyThinkingConfig();
   return setup;
 }

package/src/realtime/google-realtime-model-options.ts

@@ -20,4 +20,43 @@ export type GoogleRealtimeModelOptions = {
      */
     echoTargetLanguage?: boolean;
   };
+
+  /**
+   * Gemini Live thinking configuration.
+   *
+   * Supported by Live models with background reasoning (e.g.
+   * `gemini-3.8-live-extended-thinking`), which can process multi-step
+   * reasoning and function calls while streaming audio responses. Not
+   * supported by latency-optimized models (e.g. `gemini-3.8-live`).
+   */
+  thinkingConfig?: {
+    /**
+     * Thinking effort level. Background-reasoning Live models require exactly
+     * one of `thinkingLevel` or `thinkingBudget`; when neither is set, the
+     * provider sends `thinkingLevel: 'low'` on those models.
+     */
+    thinkingLevel?: 'low' | 'medium' | 'high';
+
+    /**
+     * Token budget for background thinking. Mutually exclusive with
+     * `thinkingLevel`; setting it suppresses the default level.
+     */
+    thinkingBudget?: number;
+
+    /**
+     * Whether thought summaries should be included in the response.
+     */
+    includeThoughts?: boolean;
+  };
+
+  /**
+   * Default `behavior` stamped onto every function declaration in the
+   * session setup.
+   *
+   * Gemini 3.8 Live models default to `NON_BLOCKING` (asynchronous) function
+   * calling. Set to `BLOCKING` for synchronous calls on models that support it
+   * (e.g. `gemini-3.8-live`); background-reasoning models accept only
+   * `NON_BLOCKING`.
+   */
+  defaultToolBehavior?: 'BLOCKING' | 'NON_BLOCKING';
 };