@ai-sdk/google 3.0.71 → 3.0.72

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/google",
-  "version": "3.0.71",
+  "version": "3.0.72",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -36,8 +36,8 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/provider": "3.0.10",
-    "@ai-sdk/provider-utils": "4.0.27"
+    "@ai-sdk/provider-utils": "4.0.27",
+    "@ai-sdk/provider": "3.0.10"
   },
   "devDependencies": {
     "@types/node": "20.17.24",

package/src/interactions/cancel-google-interaction.ts

@@ -0,0 +1,60 @@
+import {
+  combineHeaders,
+  getRuntimeEnvironmentUserAgent,
+  withUserAgentSuffix,
+  type FetchFunction,
+} from '@ai-sdk/provider-utils';
+
+const getOriginalFetch = () => globalThis.fetch;
+
+/**
+ * Best-effort `POST /interactions/{id}/cancel` to stop a background interaction
+ * on Google's side after the caller has aborted locally. Errors and non-2xx
+ * responses are swallowed so a cancel failure cannot mask the original abort.
+ *
+ * Skips the request entirely if `interactionId` is missing/empty -- e.g. when
+ * the interaction was created with `store: false` and the API did not return an
+ * id.
+ */
+export async function cancelGoogleInteraction({
+  baseURL,
+  interactionId,
+  headers,
+  fetch = getOriginalFetch(),
+}: {
+  baseURL: string;
+  interactionId: string | null | undefined;
+  headers: Record<string, string | undefined>;
+  fetch?: FetchFunction;
+}): Promise<void> {
+  if (interactionId == null || interactionId.length === 0) {
+    return;
+  }
+
+  const url = `${baseURL}/interactions/${encodeURIComponent(interactionId)}/cancel`;
+
+  try {
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: withUserAgentSuffix(
+        combineHeaders({ 'Content-Type': 'application/json' }, headers),
+        getRuntimeEnvironmentUserAgent(),
+      ),
+      body: '{}',
+    });
+
+    /*
+     * Drain the body so undici/Node can return the connection to the pool.
+     * Errors (e.g. non-2xx, network failure) are intentionally ignored: this
+     * is a best-effort cleanup and must not throw past the caller, which is
+     * already handling an aborted/failed run.
+     */
+    try {
+      await response.text();
+    } catch {
+      // ignore
+    }
+  } catch {
+    // ignore -- cancel is best-effort
+  }
+}

package/src/interactions/google-interactions-language-model.ts

@@ -44,6 +44,7 @@ import {
   pollGoogleInteractionUntilTerminal,
 } from './poll-google-interactions';
 import { prepareGoogleInteractionsTools } from './prepare-google-interactions-tools';
+import { streamGoogleInteractionEvents } from './stream-google-interactions';
 import { synthesizeGoogleInteractionsAgentStream } from './synthesize-google-interactions-agent-stream';
 
 export type GoogleInteractionsConfig = {
@@ -278,12 +279,14 @@ export class GoogleInteractionsLanguageModel implements LanguageModelV3 {
      * Agent calls require `background: true` on the wire — otherwise the API
      * rejects them with `background=true is required for agent interactions.`
      * The server returns a non-terminal status (`in_progress`/`requires_action`)
-     * and the final outputs must be polled via `GET /interactions/{id}`. This
-     * is handled internally in `doGenerate` / `doStream` so the user-facing
-     * surface stays identical to model-id calls.
+     * and the final outputs are streamed via `GET /interactions/{id}?stream=true`
+     * (or polled via `GET /interactions/{id}`). This is handled internally in
+     * `doGenerate` / `doStream` so the user-facing surface stays identical to
+     * model-id calls.
      *
      * Model-id calls retain their original synchronous behavior — no
-     * `background` field is sent.
+     * `background` field is sent. (No documented model accepts `background:
+     * true` today; revisit when one does.)
      */
     const args: GoogleInteractionsRequestBody = pruneUndefined({
       ...(isAgent ? { agent: this.agent } : { model: this.modelId }),
@@ -460,14 +463,13 @@ export class GoogleInteractionsLanguageModel implements LanguageModelV3 {
 
     /*
      * Agent calls require `background: true`, which is incompatible with
-     * `stream: true` on POST. We drive the agent flow exactly like
-     * `doGenerate` (POST background -> poll GET) and synthesize a stream
-     * from the final polled outputs. The user-facing stream surface stays
-     * identical -- text-start / text-delta / text-end / finish parts are
-     * emitted in the same order as a true SSE response.
+     * `stream: true` on POST. Drive these via POST background -> GET stream
+     * (with terminal-status short-circuit). The user-facing stream surface
+     * stays identical -- text-start / text-delta / text-end / finish parts
+     * are emitted in the same order as a true SSE response.
      */
     if (isAgent) {
-      return this.doStreamAgent({
+      return this.doStreamBackground({
         args,
         warnings,
         url,
@@ -515,26 +517,24 @@ export class GoogleInteractionsLanguageModel implements LanguageModelV3 {
   }
 
   /*
-   * Drive the streaming surface for agent calls. Agent calls require
+   * Drive the streaming surface for agent calls. Agents require
    * `background: true`, which is incompatible with `stream: true` on POST.
    *
-   * In principle the API also exposes `GET /interactions/{id}?stream=true`
-   * to replay events as the agent runs. In practice the connection is
-   * idle for long stretches while the agent thinks (deep-research can run
-   * for a minute or more between SSE events), and undici's default body
-   * timeout terminates the request mid-flight with `UND_ERR_BODY_TIMEOUT`.
-   * Tuning the timeout per-call would require the caller to thread an
-   * `undici.Agent` through `fetch`, which contradicts the AI SDK's
-   * pluggable-fetch contract.
+   * Approach:
+   *   1. POST `/interactions` with `background: true`. The response includes
+   *      the interaction id and an initial (usually non-terminal) status.
+   *   2. If the POST status is already terminal (rare), synthesize a stream
+   *      from the polled outputs and we're done.
+   *   3. Otherwise open `GET /interactions/{id}?stream=true` and pipe the
+   *      SSE events through `buildGoogleInteractionsStreamTransform` so the
+   *      consumer receives text deltas / thinking summaries / tool events as
+   *      they happen instead of all at once at the end.
    *
-   * We therefore drive `doStream` exactly like `doGenerate` for agents:
-   * POST with `background: true`, poll `GET /interactions/{id}` until
-   * terminal, then synthesize the stream from the final outputs. The
-   * user-facing surface stays identical -- text-start / text-delta /
-   * text-end / finish parts arrive in the same order as a true SSE
-   * response, just buffered until the agent completes.
+   * The SSE connection can drop while the agent idles between events
+   * (`UND_ERR_BODY_TIMEOUT`); `streamGoogleInteractionEvents` handles the
+   * reconnect-with-`last_event_id` loop transparently.
    */
-  private async doStreamAgent({
+  private async doStreamBackground({
     args,
     warnings,
     url,
@@ -561,38 +561,64 @@ export class GoogleInteractionsLanguageModel implements LanguageModelV3 {
       fetch: this.config.fetch,
     });
 
-    let { responseHeaders: postHeaders, value: postResponse } = postResult;
+    const { responseHeaders: postHeaders, value: postResponse } = postResult;
     const interactionId = postResponse.id;
 
     if (interactionId == null || interactionId.length === 0) {
       throw new Error(
-        'google.interactions: agent POST response did not include an interaction id; cannot poll for the agent result.',
+        'google.interactions: background POST response did not include an interaction id; cannot stream the result.',
       );
     }
 
-    if (!isTerminalStatus(postResponse.status)) {
-      const polled = await pollGoogleInteractionUntilTerminal({
-        baseURL: this.config.baseURL,
-        interactionId,
-        headers: mergedHeaders,
-        fetch: this.config.fetch,
-        abortSignal: options.abortSignal,
-        timeoutMs: pollingTimeoutMs,
+    const headerServiceTier = postHeaders?.['x-gemini-service-tier'];
+
+    /*
+     * If the POST already returned a terminal status (e.g. cached, immediate
+     * failure, or `incomplete`), there is nothing to stream from the GET --
+     * synthesize directly from the response so the caller still gets a
+     * complete stream.
+     */
+    if (isTerminalStatus(postResponse.status)) {
+      const synthesized = synthesizeGoogleInteractionsAgentStream({
+        response: postResponse,
+        warnings,
+        generateId: this.config.generateId ?? defaultGenerateId,
+        includeRawChunks: options.includeRawChunks,
+        headerServiceTier,
       });
-      postResponse = polled.response;
-      postHeaders = polled.responseHeaders ?? postHeaders;
+      return {
+        stream: synthesized,
+        request: { body: args },
+        response: { headers: postHeaders },
+      };
     }
 
-    const stream = synthesizeGoogleInteractionsAgentStream({
-      response: postResponse,
+    /*
+     * `pollingTimeoutMs` is unused on the live-SSE path -- there's no poll
+     * loop to time out -- but we surface it as the per-attempt timeout for
+     * the AbortSignal-driven cancel that the caller already controls. Future
+     * iterations may use it as a backstop if the SSE+resume loop spins
+     * indefinitely.
+     */
+    void pollingTimeoutMs;
+
+    const events = streamGoogleInteractionEvents({
+      baseURL: this.config.baseURL,
+      interactionId,
+      headers: mergedHeaders,
+      fetch: this.config.fetch,
+      abortSignal: options.abortSignal,
+    });
+
+    const transform = buildGoogleInteractionsStreamTransform({
       warnings,
       generateId: this.config.generateId ?? defaultGenerateId,
       includeRawChunks: options.includeRawChunks,
-      headerServiceTier: postHeaders?.['x-gemini-service-tier'],
+      serviceTier: headerServiceTier,
     });
 
     return {
-      stream,
+      stream: events.pipeThrough(transform),
       request: { body: args },
       response: { headers: postHeaders },
     };

package/src/interactions/poll-google-interactions.ts

@@ -2,9 +2,11 @@ import {
   createJsonResponseHandler,
   delay,
   getFromApi,
+  isAbortError,
   type FetchFunction,
 } from '@ai-sdk/provider-utils';
 import { googleFailedResponseHandler } from '../google-error';
+import { cancelGoogleInteraction } from './cancel-google-interaction';
 import {
   googleInteractionsResponseSchema,
   type GoogleInteractionsResponse,
@@ -73,38 +75,55 @@ export async function pollGoogleInteractionUntilTerminal({
   let nextDelayMs = initialDelayMs;
   const url = `${baseURL}/interactions/${encodeURIComponent(interactionId)}`;
 
-  while (true) {
-    if (abortSignal?.aborted) {
-      throw new DOMException('Polling was aborted', 'AbortError');
-    }
+  /*
+   * When the caller aborts, fire a best-effort `POST /interactions/{id}/cancel`
+   * so the run stops billing on Google's side. Wrap every exit path that's
+   * triggered by an abort -- the explicit `abortSignal.aborted` check, the
+   * AbortError thrown by `delay()`, and any AbortError thrown by `getFromApi`.
+   */
+  const cancelOnServer = () =>
+    cancelGoogleInteraction({ baseURL, interactionId, headers, fetch });
 
-    if (Date.now() - startedAt > timeoutMs) {
-      throw new Error(
-        `google.interactions: timed out polling interaction ${interactionId} after ${timeoutMs}ms.`,
-      );
-    }
+  try {
+    while (true) {
+      if (abortSignal?.aborted) {
+        await cancelOnServer();
+        throw new DOMException('Polling was aborted', 'AbortError');
+      }
 
-    await delay(nextDelayMs, { abortSignal });
+      if (Date.now() - startedAt > timeoutMs) {
+        throw new Error(
+          `google.interactions: timed out polling interaction ${interactionId} after ${timeoutMs}ms.`,
+        );
+      }
 
-    const {
-      value: response,
-      rawValue: rawResponse,
-      responseHeaders,
-    } = await getFromApi({
-      url,
-      headers,
-      failedResponseHandler: googleFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler(
-        googleInteractionsResponseSchema,
-      ),
-      abortSignal,
-      fetch,
-    });
+      await delay(nextDelayMs, { abortSignal });
 
-    if (isTerminalStatus(response.status)) {
-      return { response, rawResponse, responseHeaders };
-    }
+      const {
+        value: response,
+        rawValue: rawResponse,
+        responseHeaders,
+      } = await getFromApi({
+        url,
+        headers,
+        failedResponseHandler: googleFailedResponseHandler,
+        successfulResponseHandler: createJsonResponseHandler(
+          googleInteractionsResponseSchema,
+        ),
+        abortSignal,
+        fetch,
+      });
 
-    nextDelayMs = Math.min(nextDelayMs * 2, maxDelayMs);
+      if (isTerminalStatus(response.status)) {
+        return { response, rawResponse, responseHeaders };
+      }
+
+      nextDelayMs = Math.min(nextDelayMs * 2, maxDelayMs);
+    }
+  } catch (error) {
+    if (isAbortError(error)) {
+      await cancelOnServer();
+    }
+    throw error;
   }
 }

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

@@ -0,0 +1,239 @@
+import {
+  createEventSourceResponseHandler,
+  delay,
+  getFromApi,
+  isAbortError,
+  type FetchFunction,
+  type ParseResult,
+} from '@ai-sdk/provider-utils';
+import { googleFailedResponseHandler } from '../google-error';
+import { cancelGoogleInteraction } from './cancel-google-interaction';
+import {
+  googleInteractionsEventSchema,
+  type GoogleInteractionsEvent,
+} from './google-interactions-api';
+
+const DEFAULT_MAX_RETRIES = 3;
+const DEFAULT_RETRY_DELAY_MS = 500;
+
+/**
+ * Connects to `GET {baseURL}/interactions/{id}?stream=true` and surfaces the
+ * server-sent events as a `ReadableStream<ParseResult<GoogleInteractionsEvent>>`
+ * so the existing `buildGoogleInteractionsStreamTransform` can consume them
+ * unchanged.
+ *
+ * The connection can drop mid-run: deep-research agents idle for long
+ * stretches between SSE events and undici's default body timeout terminates
+ * the request with `UND_ERR_BODY_TIMEOUT`. We track the last seen `event_id`
+ * and reconnect with `?last_event_id=<id>` on any unexpected end. After
+ * `maxRetries` consecutive failures the stream errors out so the caller can
+ * decide whether to fall back to polling.
+ *
+ * The stream completes cleanly when an `interaction.complete` event with a
+ * terminal status arrives, or when an `error` event arrives.
+ */
+export function streamGoogleInteractionEvents({
+  baseURL,
+  interactionId,
+  headers,
+  fetch,
+  abortSignal,
+  maxRetries = DEFAULT_MAX_RETRIES,
+  retryDelayMs = DEFAULT_RETRY_DELAY_MS,
+}: {
+  baseURL: string;
+  interactionId: string;
+  headers: Record<string, string | undefined>;
+  fetch?: FetchFunction;
+  abortSignal?: AbortSignal;
+  maxRetries?: number;
+  retryDelayMs?: number;
+}): ReadableStream<ParseResult<GoogleInteractionsEvent>> {
+  if (interactionId.length === 0) {
+    throw new Error(
+      'google.interactions: cannot stream a background interaction without an id.',
+    );
+  }
+
+  const eventSourceHeaders = {
+    ...headers,
+    accept: 'text/event-stream',
+  };
+
+  let lastEventId: string | undefined;
+  let complete = false;
+  let attempt = 0;
+  let receivedAnyEventThisAttempt = false;
+  let currentReader:
+    | ReadableStreamDefaultReader<ParseResult<GoogleInteractionsEvent>>
+    | undefined;
+
+  /*
+   * Forwards `cancel()` from the consumer (and the upstream `abortSignal`) to
+   * any in-flight `getFromApi` or `delay` so the loop unblocks immediately
+   * instead of waiting for the next iteration to notice a flag.
+   */
+  const internalAbort = new AbortController();
+  const upstreamAbortHandler = () => internalAbort.abort();
+  if (abortSignal != null) {
+    if (abortSignal.aborted) {
+      internalAbort.abort();
+    } else {
+      abortSignal.addEventListener('abort', upstreamAbortHandler, {
+        once: true,
+      });
+    }
+  }
+  const effectiveSignal = internalAbort.signal;
+
+  function buildUrl(): string {
+    const base = `${baseURL}/interactions/${encodeURIComponent(interactionId)}`;
+    const params = new URLSearchParams({ stream: 'true' });
+    if (lastEventId != null) {
+      params.set('last_event_id', lastEventId);
+    }
+    return `${base}?${params.toString()}`;
+  }
+
+  async function openReader() {
+    const { value: stream } = await getFromApi({
+      url: buildUrl(),
+      headers: eventSourceHeaders,
+      failedResponseHandler: googleFailedResponseHandler,
+      successfulResponseHandler: createEventSourceResponseHandler(
+        googleInteractionsEventSchema,
+      ),
+      abortSignal: effectiveSignal,
+      fetch,
+    });
+    return stream.getReader();
+  }
+
+  return new ReadableStream<ParseResult<GoogleInteractionsEvent>>({
+    async start(controller) {
+      try {
+        while (!complete && !effectiveSignal.aborted) {
+          if (currentReader == null) {
+            try {
+              currentReader = await openReader();
+              receivedAnyEventThisAttempt = false;
+            } catch (error) {
+              if (isAbortError(error) || effectiveSignal.aborted) {
+                controller.error(error);
+                return;
+              }
+              attempt++;
+              if (attempt >= maxRetries) {
+                controller.error(error);
+                return;
+              }
+              await delay(retryDelayMs * attempt, {
+                abortSignal: effectiveSignal,
+              });
+              continue;
+            }
+          }
+
+          try {
+            const { done, value } = await currentReader.read();
+            if (done) {
+              /*
+               * Underlying stream ended. If we already saw the terminal event
+               * we exit cleanly; otherwise this is an unexpected disconnect
+               * and we'll reconnect with `last_event_id`.
+               *
+               * If the connection closed without producing any events at all
+               * this attempt, count it as a failed attempt -- otherwise an
+               * empty/misbehaving server response would loop forever.
+               */
+              currentReader = undefined;
+              if (complete) break;
+              if (!receivedAnyEventThisAttempt) {
+                attempt++;
+                if (attempt >= maxRetries) {
+                  controller.error(
+                    new Error(
+                      'google.interactions: SSE stream closed without producing any events.',
+                    ),
+                  );
+                  return;
+                }
+                await delay(retryDelayMs * attempt, {
+                  abortSignal: effectiveSignal,
+                });
+              } else {
+                attempt = 0;
+              }
+              continue;
+            }
+
+            receivedAnyEventThisAttempt = true;
+
+            if (value.success) {
+              const ev = value.value as {
+                event_id?: string;
+                event_type?: string;
+              };
+              if (typeof ev.event_id === 'string' && ev.event_id.length > 0) {
+                lastEventId = ev.event_id;
+              }
+              if (
+                ev.event_type === 'interaction.complete' ||
+                ev.event_type === 'error'
+              ) {
+                complete = true;
+              }
+            }
+
+            controller.enqueue(value);
+          } catch (error) {
+            if (isAbortError(error) || effectiveSignal.aborted) {
+              controller.error(error);
+              return;
+            }
+            currentReader = undefined;
+            attempt++;
+            if (attempt >= maxRetries) {
+              controller.error(error);
+              return;
+            }
+            await delay(retryDelayMs * attempt, {
+              abortSignal: effectiveSignal,
+            });
+          }
+        }
+        controller.close();
+      } catch (error) {
+        controller.error(error);
+      } finally {
+        if (abortSignal != null) {
+          abortSignal.removeEventListener('abort', upstreamAbortHandler);
+        }
+        currentReader?.cancel().catch(() => {});
+        currentReader = undefined;
+
+        /*
+         * If we're exiting because the caller aborted (or the consumer
+         * cancelled the stream) before the agent finished, fire
+         * `POST /interactions/{id}/cancel` so the run stops billing on
+         * Google's side. Skipped when `complete` is set -- the agent already
+         * reported terminal status via `interaction.complete` / `error`.
+         */
+        if (effectiveSignal.aborted && !complete) {
+          await cancelGoogleInteraction({
+            baseURL,
+            interactionId,
+            headers,
+            fetch,
+          });
+        }
+      }
+    },
+
+    cancel() {
+      internalAbort.abort();
+      currentReader?.cancel().catch(() => {});
+      currentReader = undefined;
+    },
+  });
+}