@ai-sdk/google 4.0.0-beta.8 → 4.0.0-beta.82

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

@@ -0,0 +1,242 @@
+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: long-running 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 streamEvent = value.value as {
+                event_id?: string;
+                event_type?: string;
+              };
+              if (
+                typeof streamEvent.event_id === 'string' &&
+                streamEvent.event_id.length > 0
+              ) {
+                lastEventId = streamEvent.event_id;
+              }
+              if (
+                streamEvent.event_type === 'interaction.completed' ||
+                streamEvent.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;
+    },
+  });
+}

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

@@ -0,0 +1,185 @@
+import type {
+  LanguageModelV4FinishReason,
+  LanguageModelV4StreamPart,
+  SharedV4ProviderMetadata,
+  SharedV4Warning,
+} from '@ai-sdk/provider';
+import { convertGoogleInteractionsUsage } from './convert-google-interactions-usage';
+import { type GoogleInteractionsResponse } from './google-interactions-api';
+import { mapGoogleInteractionsFinishReason } from './map-google-interactions-finish-reason';
+import { parseGoogleInteractionsOutputs } from './parse-google-interactions-outputs';
+
+/**
+ * Synthesizes a `LanguageModelV4StreamPart` stream from a fully-resolved
+ * Interaction response (i.e. the `response` returned after polling a
+ * `background: true` agent call to a terminal status).
+ *
+ * Agent calls cannot use SSE (`stream: true` is incompatible with
+ * `background: true`), so we deterministically replay the polled outputs as a
+ * stream sequence in the same order/shape `buildGoogleInteractionsStreamTransform`
+ * would produce. Each text/reasoning block is emitted as a single delta — the
+ * server has already produced the whole block by the time we synthesize.
+ */
+export function synthesizeGoogleInteractionsAgentStream({
+  response,
+  warnings,
+  generateId,
+  includeRawChunks,
+  headerServiceTier,
+}: {
+  response: GoogleInteractionsResponse;
+  warnings: Array<SharedV4Warning>;
+  generateId: () => string;
+  includeRawChunks?: boolean;
+  headerServiceTier?: string;
+}): ReadableStream<LanguageModelV4StreamPart> {
+  return new ReadableStream<LanguageModelV4StreamPart>({
+    start(controller) {
+      controller.enqueue({ type: 'stream-start', warnings });
+
+      const interactionId =
+        typeof response.id === 'string' && response.id.length > 0
+          ? response.id
+          : undefined;
+
+      let timestamp: Date | undefined;
+      const created = response.created;
+      if (typeof created === 'string') {
+        const parsed = new Date(created);
+        if (!Number.isNaN(parsed.getTime())) {
+          timestamp = parsed;
+        }
+      }
+
+      controller.enqueue({
+        type: 'response-metadata',
+        ...(interactionId != null ? { id: interactionId } : {}),
+        modelId: response.model ?? undefined,
+        ...(timestamp ? { timestamp } : {}),
+      });
+
+      if (includeRawChunks) {
+        controller.enqueue({ type: 'raw', rawValue: response });
+      }
+
+      const { content, hasFunctionCall } = parseGoogleInteractionsOutputs({
+        steps: response.steps ?? null,
+        generateId,
+        interactionId,
+      });
+
+      let blockCounter = 0;
+      const nextBlockId = () => `${interactionId ?? 'agent'}:${blockCounter++}`;
+
+      for (const part of content) {
+        switch (part.type) {
+          case 'text': {
+            const id = nextBlockId();
+            const providerMetadata = part.providerMetadata;
+            controller.enqueue({ type: 'text-start', id });
+            if (part.text.length > 0) {
+              controller.enqueue({ type: 'text-delta', id, delta: part.text });
+            }
+            controller.enqueue({
+              type: 'text-end',
+              id,
+              ...(providerMetadata ? { providerMetadata } : {}),
+            });
+            break;
+          }
+          case 'reasoning': {
+            const id = nextBlockId();
+            const providerMetadata = part.providerMetadata;
+            controller.enqueue({ type: 'reasoning-start', id });
+            if (part.text.length > 0) {
+              controller.enqueue({
+                type: 'reasoning-delta',
+                id,
+                delta: part.text,
+              });
+            }
+            controller.enqueue({
+              type: 'reasoning-end',
+              id,
+              ...(providerMetadata ? { providerMetadata } : {}),
+            });
+            break;
+          }
+          case 'tool-call': {
+            const providerMetadata = part.providerMetadata;
+            controller.enqueue({
+              type: 'tool-input-start',
+              id: part.toolCallId,
+              toolName: part.toolName,
+              ...(part.providerExecuted
+                ? { providerExecuted: part.providerExecuted }
+                : {}),
+            });
+            controller.enqueue({
+              type: 'tool-input-delta',
+              id: part.toolCallId,
+              delta: part.input,
+            });
+            controller.enqueue({
+              type: 'tool-input-end',
+              id: part.toolCallId,
+            });
+            controller.enqueue({
+              type: 'tool-call',
+              toolCallId: part.toolCallId,
+              toolName: part.toolName,
+              input: part.input,
+              ...(part.providerExecuted
+                ? { providerExecuted: part.providerExecuted }
+                : {}),
+              ...(providerMetadata ? { providerMetadata } : {}),
+            });
+            break;
+          }
+          case 'tool-result': {
+            controller.enqueue({
+              type: 'tool-result',
+              toolCallId: part.toolCallId,
+              toolName: part.toolName,
+              result: part.result,
+            });
+            break;
+          }
+          case 'source':
+          case 'file': {
+            controller.enqueue(part);
+            break;
+          }
+          default:
+            break;
+        }
+      }
+
+      const serviceTier = response.service_tier ?? headerServiceTier;
+
+      const finishReason: LanguageModelV4FinishReason = {
+        unified: mapGoogleInteractionsFinishReason({
+          status: response.status,
+          hasFunctionCall,
+        }),
+        raw: response.status,
+      };
+
+      const providerMetadata: SharedV4ProviderMetadata = {
+        google: {
+          ...(interactionId != null ? { interactionId } : {}),
+          ...(serviceTier != null ? { serviceTier } : {}),
+        },
+      };
+
+      controller.enqueue({
+        type: 'finish',
+        finishReason,
+        usage: convertGoogleInteractionsUsage(response.usage),
+        providerMetadata,
+      });
+
+      controller.close();
+    },
+  });
+}

package/src/internal/index.ts

@@ -1,3 +1,4 @@
-export * from '../google-generative-ai-language-model';
+export * from '../google-language-model';
+export * from '../google-speech-model';
 export { googleTools } from '../google-tools';
-export type { GoogleGenerativeAIModelId } from '../google-generative-ai-options';
+export type { GoogleModelId } from '../google-language-model-options';

package/src/{map-google-generative-ai-finish-reason.ts → map-google-finish-reason.ts}

@@ -1,12 +1,12 @@
-import { LanguageModelV3FinishReason } from '@ai-sdk/provider';
+import type { LanguageModelV4FinishReason } from '@ai-sdk/provider';
 
-export function mapGoogleGenerativeAIFinishReason({
+export function mapGoogleFinishReason({
   finishReason,
   hasToolCalls,
 }: {
   finishReason: string | null | undefined;
   hasToolCalls: boolean;
-}): LanguageModelV3FinishReason['unified'] {
+}): LanguageModelV4FinishReason['unified'] {
   switch (finishReason) {
     case 'STOP':
       return hasToolCalls ? 'tool-calls' : 'stop';