@ai-sdk/google 4.0.102 → 4.0.103

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/google",
-  "version": "4.0.102",
+  "version": "4.0.103",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -35,8 +35,8 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/provider": "4.0.31",
-    "@ai-sdk/provider-utils": "5.0.65"
+    "@ai-sdk/provider": "4.0.32",
+    "@ai-sdk/provider-utils": "5.0.66"
   },
   "devDependencies": {
     "@ai-sdk/test-server": "2.0.4",

package/src/continue-google-stream.ts

@@ -1,5 +1,9 @@
 import type { ParseResult } from '@ai-sdk/provider-utils';
 
+export type GoogleStreamPart<T> =
+  | ParseResult<T>
+  | { type: 'continuation-start' };
+
 /**
  * Concatenates the event streams of a long decode response that spans several
  * requests (Gemini 4 long decode).
@@ -7,7 +11,9 @@ import type { ParseResult } from '@ai-sdk/provider-utils';
  * Events of the current stream are passed through unchanged. When an event
  * signals that the per-request cap was reached while budget remains
  * (`getContinuationToken` returns a token), the next request is sent with that
- * token once the current stream ends, and its events are appended. If the
+ * token once the current stream ends, and its events are appended after a
+ * `continuation-start` marker. The marker orders per-response state changes
+ * with buffered events, including when the new stream is empty. If the
  * continuation request fails, the error is emitted as a failed parse result
  * and the stream ends.
  */
@@ -21,11 +27,11 @@ export function continueGoogleStream<T>({
   continueStream: (
     continuationToken: string,
   ) => Promise<ReadableStream<ParseResult<T>>>;
-}): ReadableStream<ParseResult<T>> {
+}): ReadableStream<GoogleStreamPart<T>> {
   let reader = stream.getReader();
   let pendingContinuationToken: string | undefined;
 
-  return new ReadableStream<ParseResult<T>>({
+  return new ReadableStream<GoogleStreamPart<T>>({
     async pull(controller) {
       while (true) {
         const { done, value } = await reader.read();
@@ -51,6 +57,8 @@ export function continueGoogleStream<T>({
 
         try {
           reader = (await continueStream(continuationToken)).getReader();
+          controller.enqueue({ type: 'continuation-start' });
+          return;
         } catch (error) {
           // Surfaced as an `error` stream part, followed by the `finish` part
           // with the last continuation token so the caller can resume.

package/src/google-language-model.ts

@@ -33,11 +33,13 @@ import {
   zodSchema,
   type FetchFunction,
   type InferSchema,
-  type ParseResult,
   type Resolvable,
 } from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
-import { continueGoogleStream } from './continue-google-stream';
+import {
+  continueGoogleStream,
+  type GoogleStreamPart,
+} from './continue-google-stream';
 import {
   addGoogleUsageMetadata,
   convertGoogleUsage,
@@ -926,8 +928,9 @@ export class GoogleLanguageModel implements LanguageModelV4 {
       },
     });
 
+    // A clean end without the provider's completion signal is interrupted.
     let finishReason: LanguageModelV4FinishReason = {
-      unified: 'other',
+      unified: 'interrupted',
       raw: undefined,
     };
     let usage: GoogleUsageMetadata | undefined = undefined;
@@ -1005,7 +1008,7 @@ export class GoogleLanguageModel implements LanguageModelV4 {
     const result = {
       stream: response.pipeThrough(
         new TransformStream<
-          ParseResult<ChunkSchema>,
+          GoogleStreamPart<ChunkSchema>,
           LanguageModelV4StreamPart
         >({
           start(controller) {
@@ -1013,11 +1016,21 @@ export class GoogleLanguageModel implements LanguageModelV4 {
           },
 
           transform(chunk, controller) {
+            if ('type' in chunk) {
+              // Reset in stream order, after the prior response's buffered
+              // CONTINUATION chunk, rather than when the request starts.
+              finishReason = { unified: 'interrupted', raw: undefined };
+              return;
+            }
+
             if (options.includeRawChunks) {
               controller.enqueue({ type: 'raw', rawValue: chunk.rawValue });
             }
 
             if (!chunk.success) {
+              if (finishReason.unified === 'interrupted') {
+                finishReason = { unified: 'error', raw: undefined };
+              }
               controller.enqueue({ type: 'error', error: chunk.error });
               return;
             }

package/src/interactions/build-google-interactions-stream-transform.ts

@@ -152,6 +152,7 @@ export function buildGoogleInteractionsStreamTransform({
   let serviceTier: string | undefined = headerServiceTier;
   let finishStatus: GoogleInteractionsStatus | string | undefined;
   let hasFunctionCall = false;
+  let hasCompletionEvent = false;
 
   /*
    * Per-index open step slots. The Interactions API frames concurrent steps
@@ -838,6 +839,7 @@ export function buildGoogleInteractionsStreamTransform({
         }
 
         case 'interaction.completed': {
+          hasCompletionEvent = true;
           const event = value as Extract<
             GoogleInteractionsEvent,
             { event_type: 'interaction.completed' }
@@ -893,12 +895,17 @@ export function buildGoogleInteractionsStreamTransform({
     },
 
     flush(controller) {
+      const isInterrupted =
+        !hasCompletionEvent &&
+        (finishStatus == null || finishStatus === 'in_progress');
       const finishReason: LanguageModelV4FinishReason = {
-        unified: mapGoogleInteractionsFinishReason({
-          status: finishStatus,
-          hasFunctionCall,
-        }),
-        raw: finishStatus,
+        unified: isInterrupted
+          ? 'interrupted'
+          : mapGoogleInteractionsFinishReason({
+              status: finishStatus,
+              hasFunctionCall,
+            }),
+        raw: isInterrupted ? undefined : finishStatus,
       };
 
       const outputTokensByModality =