@ai-sdk/google 3.0.71 → 3.0.72

package/dist/index.mjs

@@ -3,11 +3,11 @@ import {
   generateId as generateId2,
   loadApiKey,
   withoutTrailingSlash,
-  withUserAgentSuffix
+  withUserAgentSuffix as withUserAgentSuffix2
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "3.0.71" : "0.0.0-test";
+var VERSION = true ? "3.0.72" : "0.0.0-test";
 
 // src/google-generative-ai-embedding-model.ts
 import {
@@ -3078,8 +3078,8 @@ var googleVideoModelOptionsSchema = lazySchema12(
 
 // src/interactions/google-interactions-language-model.ts
 import {
-  combineHeaders as combineHeaders5,
-  createEventSourceResponseHandler as createEventSourceResponseHandler2,
+  combineHeaders as combineHeaders6,
+  createEventSourceResponseHandler as createEventSourceResponseHandler3,
   createJsonResponseHandler as createJsonResponseHandler6,
   generateId as defaultGenerateId2,
   parseProviderOptions as parseProviderOptions5,
@@ -4703,8 +4703,45 @@ function parseGoogleInteractionsOutputs({
 import {
   createJsonResponseHandler as createJsonResponseHandler5,
   delay as delay2,
-  getFromApi as getFromApi2
+  getFromApi as getFromApi2,
+  isAbortError
+} from "@ai-sdk/provider-utils";
+
+// src/interactions/cancel-google-interaction.ts
+import {
+  combineHeaders as combineHeaders5,
+  getRuntimeEnvironmentUserAgent,
+  withUserAgentSuffix
 } from "@ai-sdk/provider-utils";
+var getOriginalFetch = () => globalThis.fetch;
+async function cancelGoogleInteraction({
+  baseURL,
+  interactionId,
+  headers,
+  fetch = getOriginalFetch()
+}) {
+  if (interactionId == null || interactionId.length === 0) {
+    return;
+  }
+  const url = `${baseURL}/interactions/${encodeURIComponent(interactionId)}/cancel`;
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: withUserAgentSuffix(
+        combineHeaders5({ "Content-Type": "application/json" }, headers),
+        getRuntimeEnvironmentUserAgent()
+      ),
+      body: "{}"
+    });
+    try {
+      await response.text();
+    } catch (e) {
+    }
+  } catch (e) {
+  }
+}
+
+// src/interactions/poll-google-interactions.ts
 var TERMINAL_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "cancelled", "incomplete"]);
 function isTerminalStatus(status) {
   return status != null && TERMINAL_STATUSES.has(status);
@@ -4730,34 +4767,43 @@ async function pollGoogleInteractionUntilTerminal({
   const startedAt = Date.now();
   let nextDelayMs = initialDelayMs;
   const url = `${baseURL}/interactions/${encodeURIComponent(interactionId)}`;
-  while (true) {
-    if (abortSignal == null ? void 0 : abortSignal.aborted) {
-      throw new DOMException("Polling was aborted", "AbortError");
-    }
-    if (Date.now() - startedAt > timeoutMs) {
-      throw new Error(
-        `google.interactions: timed out polling interaction ${interactionId} after ${timeoutMs}ms.`
-      );
+  const cancelOnServer = () => cancelGoogleInteraction({ baseURL, interactionId, headers, fetch });
+  try {
+    while (true) {
+      if (abortSignal == null ? void 0 : abortSignal.aborted) {
+        await cancelOnServer();
+        throw new DOMException("Polling was aborted", "AbortError");
+      }
+      if (Date.now() - startedAt > timeoutMs) {
+        throw new Error(
+          `google.interactions: timed out polling interaction ${interactionId} after ${timeoutMs}ms.`
+        );
+      }
+      await delay2(nextDelayMs, { abortSignal });
+      const {
+        value: response,
+        rawValue: rawResponse,
+        responseHeaders
+      } = await getFromApi2({
+        url,
+        headers,
+        failedResponseHandler: googleFailedResponseHandler,
+        successfulResponseHandler: createJsonResponseHandler5(
+          googleInteractionsResponseSchema
+        ),
+        abortSignal,
+        fetch
+      });
+      if (isTerminalStatus(response.status)) {
+        return { response, rawResponse, responseHeaders };
+      }
+      nextDelayMs = Math.min(nextDelayMs * 2, maxDelayMs);
     }
-    await delay2(nextDelayMs, { abortSignal });
-    const {
-      value: response,
-      rawValue: rawResponse,
-      responseHeaders
-    } = await getFromApi2({
-      url,
-      headers,
-      failedResponseHandler: googleFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler5(
-        googleInteractionsResponseSchema
-      ),
-      abortSignal,
-      fetch
-    });
-    if (isTerminalStatus(response.status)) {
-      return { response, rawResponse, responseHeaders };
+  } catch (error) {
+    if (isAbortError(error)) {
+      await cancelOnServer();
     }
-    nextDelayMs = Math.min(nextDelayMs * 2, maxDelayMs);
+    throw error;
   }
 }
 
@@ -4909,6 +4955,174 @@ function prepareGoogleInteractionsTools({
   };
 }
 
+// src/interactions/stream-google-interactions.ts
+import {
+  createEventSourceResponseHandler as createEventSourceResponseHandler2,
+  delay as delay3,
+  getFromApi as getFromApi3,
+  isAbortError as isAbortError2
+} from "@ai-sdk/provider-utils";
+var DEFAULT_MAX_RETRIES = 3;
+var DEFAULT_RETRY_DELAY_MS = 500;
+function streamGoogleInteractionEvents({
+  baseURL,
+  interactionId,
+  headers,
+  fetch,
+  abortSignal,
+  maxRetries = DEFAULT_MAX_RETRIES,
+  retryDelayMs = DEFAULT_RETRY_DELAY_MS
+}) {
+  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;
+  let complete = false;
+  let attempt = 0;
+  let receivedAnyEventThisAttempt = false;
+  let currentReader;
+  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() {
+    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 getFromApi3({
+      url: buildUrl(),
+      headers: eventSourceHeaders,
+      failedResponseHandler: googleFailedResponseHandler,
+      successfulResponseHandler: createEventSourceResponseHandler2(
+        googleInteractionsEventSchema
+      ),
+      abortSignal: effectiveSignal,
+      fetch
+    });
+    return stream.getReader();
+  }
+  return new ReadableStream({
+    async start(controller) {
+      try {
+        while (!complete && !effectiveSignal.aborted) {
+          if (currentReader == null) {
+            try {
+              currentReader = await openReader();
+              receivedAnyEventThisAttempt = false;
+            } catch (error) {
+              if (isAbortError2(error) || effectiveSignal.aborted) {
+                controller.error(error);
+                return;
+              }
+              attempt++;
+              if (attempt >= maxRetries) {
+                controller.error(error);
+                return;
+              }
+              await delay3(retryDelayMs * attempt, {
+                abortSignal: effectiveSignal
+              });
+              continue;
+            }
+          }
+          try {
+            const { done, value } = await currentReader.read();
+            if (done) {
+              currentReader = void 0;
+              if (complete) break;
+              if (!receivedAnyEventThisAttempt) {
+                attempt++;
+                if (attempt >= maxRetries) {
+                  controller.error(
+                    new Error(
+                      "google.interactions: SSE stream closed without producing any events."
+                    )
+                  );
+                  return;
+                }
+                await delay3(retryDelayMs * attempt, {
+                  abortSignal: effectiveSignal
+                });
+              } else {
+                attempt = 0;
+              }
+              continue;
+            }
+            receivedAnyEventThisAttempt = true;
+            if (value.success) {
+              const ev = value.value;
+              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 (isAbortError2(error) || effectiveSignal.aborted) {
+              controller.error(error);
+              return;
+            }
+            currentReader = void 0;
+            attempt++;
+            if (attempt >= maxRetries) {
+              controller.error(error);
+              return;
+            }
+            await delay3(retryDelayMs * attempt, {
+              abortSignal: effectiveSignal
+            });
+          }
+        }
+        controller.close();
+      } catch (error) {
+        controller.error(error);
+      } finally {
+        if (abortSignal != null) {
+          abortSignal.removeEventListener("abort", upstreamAbortHandler);
+        }
+        currentReader == null ? void 0 : currentReader.cancel().catch(() => {
+        });
+        currentReader = void 0;
+        if (effectiveSignal.aborted && !complete) {
+          await cancelGoogleInteraction({
+            baseURL,
+            interactionId,
+            headers,
+            fetch
+          });
+        }
+      }
+    },
+    cancel() {
+      internalAbort.abort();
+      currentReader == null ? void 0 : currentReader.cancel().catch(() => {
+      });
+      currentReader = void 0;
+    }
+  });
+}
+
 // src/interactions/synthesize-google-interactions-agent-stream.ts
 function synthesizeGoogleInteractionsAgentStream({
   response,
@@ -5222,7 +5436,7 @@ var GoogleInteractionsLanguageModel = class {
     var _a, _b, _c, _d, _e, _f;
     const { args, warnings, isAgent, pollingTimeoutMs } = await this.getArgs(options);
     const url = `${this.config.baseURL}/interactions`;
-    const mergedHeaders = combineHeaders5(
+    const mergedHeaders = combineHeaders6(
       this.config.headers ? await resolve5(this.config.headers) : void 0,
       options.headers
     );
@@ -5302,12 +5516,12 @@ var GoogleInteractionsLanguageModel = class {
     var _a;
     const { args, warnings, isAgent, pollingTimeoutMs } = await this.getArgs(options);
     const url = `${this.config.baseURL}/interactions`;
-    const mergedHeaders = combineHeaders5(
+    const mergedHeaders = combineHeaders6(
       this.config.headers ? await resolve5(this.config.headers) : void 0,
       options.headers
     );
     if (isAgent) {
-      return this.doStreamAgent({
+      return this.doStreamBackground({
         args,
         warnings,
         url,
@@ -5322,7 +5536,7 @@ var GoogleInteractionsLanguageModel = class {
       headers: mergedHeaders,
       body,
       failedResponseHandler: googleFailedResponseHandler,
-      successfulResponseHandler: createEventSourceResponseHandler2(
+      successfulResponseHandler: createEventSourceResponseHandler3(
         googleInteractionsEventSchema
       ),
       abortSignal: options.abortSignal,
@@ -5342,26 +5556,24 @@ var GoogleInteractionsLanguageModel = class {
     };
   }
   /*
-   * 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.
    */
-  async doStreamAgent({
+  async doStreamBackground({
     args,
     warnings,
     url,
@@ -5381,34 +5593,44 @@ var GoogleInteractionsLanguageModel = class {
       abortSignal: options.abortSignal,
       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 == null ? void 0 : postHeaders["x-gemini-service-tier"];
+    if (isTerminalStatus(postResponse.status)) {
+      const synthesized = synthesizeGoogleInteractionsAgentStream({
+        response: postResponse,
+        warnings,
+        generateId: (_a = this.config.generateId) != null ? _a : defaultGenerateId2,
+        includeRawChunks: options.includeRawChunks,
+        headerServiceTier
       });
-      postResponse = polled.response;
-      postHeaders = (_a = polled.responseHeaders) != null ? _a : postHeaders;
+      return {
+        stream: synthesized,
+        request: { body: args },
+        response: { headers: postHeaders }
+      };
     }
-    const stream = synthesizeGoogleInteractionsAgentStream({
-      response: postResponse,
+    void pollingTimeoutMs;
+    const events = streamGoogleInteractionEvents({
+      baseURL: this.config.baseURL,
+      interactionId,
+      headers: mergedHeaders,
+      fetch: this.config.fetch,
+      abortSignal: options.abortSignal
+    });
+    const transform = buildGoogleInteractionsStreamTransform({
       warnings,
       generateId: (_b = this.config.generateId) != null ? _b : defaultGenerateId2,
       includeRawChunks: options.includeRawChunks,
-      headerServiceTier: postHeaders == null ? void 0 : postHeaders["x-gemini-service-tier"]
+      serviceTier: headerServiceTier
     });
     return {
-      stream,
+      stream: events.pipeThrough(transform),
       request: { body: args },
       response: { headers: postHeaders }
     };
@@ -5428,7 +5650,7 @@ function createGoogleGenerativeAI(options = {}) {
   var _a, _b;
   const baseURL = (_a = withoutTrailingSlash(options.baseURL)) != null ? _a : "https://generativelanguage.googleapis.com/v1beta";
   const providerName = (_b = options.name) != null ? _b : "google.generative-ai";
-  const getHeaders = () => withUserAgentSuffix(
+  const getHeaders = () => withUserAgentSuffix2(
     {
       "x-goog-api-key": loadApiKey({
         apiKey: options.apiKey,