@ai-sdk/google 3.0.71 → 3.0.72

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @ai-sdk/google
 
+## 3.0.72
+
+### Patch Changes
+
+- b3642fe: feat(provider/google): support cancelling long-running Interactions API agents via AbortSignal, and process their intermittent stream
+
 ## 3.0.71
 
 ### Patch Changes

package/dist/index.js

@@ -27,10 +27,10 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/google-provider.ts
-var import_provider_utils21 = require("@ai-sdk/provider-utils");
+var import_provider_utils23 = require("@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
 var import_provider = require("@ai-sdk/provider");
@@ -3023,7 +3023,7 @@ var googleVideoModelOptionsSchema = (0, import_provider_utils15.lazySchema)(
 );
 
 // src/interactions/google-interactions-language-model.ts
-var import_provider_utils20 = require("@ai-sdk/provider-utils");
+var import_provider_utils22 = require("@ai-sdk/provider-utils");
 
 // src/interactions/convert-google-interactions-usage.ts
 function convertGoogleInteractionsUsage(usage) {
@@ -4632,7 +4632,39 @@ function parseGoogleInteractionsOutputs({
 }
 
 // src/interactions/poll-google-interactions.ts
+var import_provider_utils20 = require("@ai-sdk/provider-utils");
+
+// src/interactions/cancel-google-interaction.ts
 var import_provider_utils19 = require("@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: (0, import_provider_utils19.withUserAgentSuffix)(
+        (0, import_provider_utils19.combineHeaders)({ "Content-Type": "application/json" }, headers),
+        (0, import_provider_utils19.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);
@@ -4658,34 +4690,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 (0, import_provider_utils20.delay)(nextDelayMs, { abortSignal });
+      const {
+        value: response,
+        rawValue: rawResponse,
+        responseHeaders
+      } = await (0, import_provider_utils20.getFromApi)({
+        url,
+        headers,
+        failedResponseHandler: googleFailedResponseHandler,
+        successfulResponseHandler: (0, import_provider_utils20.createJsonResponseHandler)(
+          googleInteractionsResponseSchema
+        ),
+        abortSignal,
+        fetch
+      });
+      if (isTerminalStatus(response.status)) {
+        return { response, rawResponse, responseHeaders };
+      }
+      nextDelayMs = Math.min(nextDelayMs * 2, maxDelayMs);
     }
-    await (0, import_provider_utils19.delay)(nextDelayMs, { abortSignal });
-    const {
-      value: response,
-      rawValue: rawResponse,
-      responseHeaders
-    } = await (0, import_provider_utils19.getFromApi)({
-      url,
-      headers,
-      failedResponseHandler: googleFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils19.createJsonResponseHandler)(
-        googleInteractionsResponseSchema
-      ),
-      abortSignal,
-      fetch
-    });
-    if (isTerminalStatus(response.status)) {
-      return { response, rawResponse, responseHeaders };
+  } catch (error) {
+    if ((0, import_provider_utils20.isAbortError)(error)) {
+      await cancelOnServer();
     }
-    nextDelayMs = Math.min(nextDelayMs * 2, maxDelayMs);
+    throw error;
   }
 }
 
@@ -4837,6 +4878,169 @@ function prepareGoogleInteractionsTools({
   };
 }
 
+// src/interactions/stream-google-interactions.ts
+var import_provider_utils21 = require("@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 (0, import_provider_utils21.getFromApi)({
+      url: buildUrl(),
+      headers: eventSourceHeaders,
+      failedResponseHandler: googleFailedResponseHandler,
+      successfulResponseHandler: (0, import_provider_utils21.createEventSourceResponseHandler)(
+        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 ((0, import_provider_utils21.isAbortError)(error) || effectiveSignal.aborted) {
+                controller.error(error);
+                return;
+              }
+              attempt++;
+              if (attempt >= maxRetries) {
+                controller.error(error);
+                return;
+              }
+              await (0, import_provider_utils21.delay)(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 (0, import_provider_utils21.delay)(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 ((0, import_provider_utils21.isAbortError)(error) || effectiveSignal.aborted) {
+              controller.error(error);
+              return;
+            }
+            currentReader = void 0;
+            attempt++;
+            if (attempt >= maxRetries) {
+              controller.error(error);
+              return;
+            }
+            await (0, import_provider_utils21.delay)(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,
@@ -5012,7 +5216,7 @@ var GoogleInteractionsLanguageModel = class {
   async getArgs(options) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t;
     const warnings = [];
-    const opts = await (0, import_provider_utils20.parseProviderOptions)({
+    const opts = await (0, import_provider_utils22.parseProviderOptions)({
       provider: "google",
       providerOptions: options.providerOptions,
       schema: googleInteractionsLanguageModelOptions
@@ -5150,16 +5354,16 @@ 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 = (0, import_provider_utils20.combineHeaders)(
-      this.config.headers ? await (0, import_provider_utils20.resolve)(this.config.headers) : void 0,
+    const mergedHeaders = (0, import_provider_utils22.combineHeaders)(
+      this.config.headers ? await (0, import_provider_utils22.resolve)(this.config.headers) : void 0,
       options.headers
     );
-    const postResult = await (0, import_provider_utils20.postJsonToApi)({
+    const postResult = await (0, import_provider_utils22.postJsonToApi)({
       url,
       headers: mergedHeaders,
       body: args,
       failedResponseHandler: googleFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils20.createJsonResponseHandler)(
+      successfulResponseHandler: (0, import_provider_utils22.createJsonResponseHandler)(
         googleInteractionsResponseSchema
       ),
       abortSignal: options.abortSignal,
@@ -5186,7 +5390,7 @@ var GoogleInteractionsLanguageModel = class {
     const interactionId = typeof response.id === "string" && response.id.length > 0 ? response.id : void 0;
     const { content, hasFunctionCall } = parseGoogleInteractionsOutputs({
       outputs: (_b = response.outputs) != null ? _b : null,
-      generateId: (_c = this.config.generateId) != null ? _c : import_provider_utils20.generateId,
+      generateId: (_c = this.config.generateId) != null ? _c : import_provider_utils22.generateId,
       interactionId
     });
     const finishReason = {
@@ -5230,12 +5434,12 @@ var GoogleInteractionsLanguageModel = class {
     var _a;
     const { args, warnings, isAgent, pollingTimeoutMs } = await this.getArgs(options);
     const url = `${this.config.baseURL}/interactions`;
-    const mergedHeaders = (0, import_provider_utils20.combineHeaders)(
-      this.config.headers ? await (0, import_provider_utils20.resolve)(this.config.headers) : void 0,
+    const mergedHeaders = (0, import_provider_utils22.combineHeaders)(
+      this.config.headers ? await (0, import_provider_utils22.resolve)(this.config.headers) : void 0,
       options.headers
     );
     if (isAgent) {
-      return this.doStreamAgent({
+      return this.doStreamBackground({
         args,
         warnings,
         url,
@@ -5245,12 +5449,12 @@ var GoogleInteractionsLanguageModel = class {
       });
     }
     const body = { ...args, stream: true };
-    const { responseHeaders, value: response } = await (0, import_provider_utils20.postJsonToApi)({
+    const { responseHeaders, value: response } = await (0, import_provider_utils22.postJsonToApi)({
       url,
       headers: mergedHeaders,
       body,
       failedResponseHandler: googleFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils20.createEventSourceResponseHandler)(
+      successfulResponseHandler: (0, import_provider_utils22.createEventSourceResponseHandler)(
         googleInteractionsEventSchema
       ),
       abortSignal: options.abortSignal,
@@ -5259,7 +5463,7 @@ var GoogleInteractionsLanguageModel = class {
     const headerServiceTier = responseHeaders == null ? void 0 : responseHeaders["x-gemini-service-tier"];
     const transform = buildGoogleInteractionsStreamTransform({
       warnings,
-      generateId: (_a = this.config.generateId) != null ? _a : import_provider_utils20.generateId,
+      generateId: (_a = this.config.generateId) != null ? _a : import_provider_utils22.generateId,
       includeRawChunks: options.includeRawChunks,
       serviceTier: headerServiceTier
     });
@@ -5270,26 +5474,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,
@@ -5298,45 +5500,55 @@ var GoogleInteractionsLanguageModel = class {
     pollingTimeoutMs
   }) {
     var _a, _b;
-    const postResult = await (0, import_provider_utils20.postJsonToApi)({
+    const postResult = await (0, import_provider_utils22.postJsonToApi)({
       url,
       headers: mergedHeaders,
       body: args,
       failedResponseHandler: googleFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils20.createJsonResponseHandler)(
+      successfulResponseHandler: (0, import_provider_utils22.createJsonResponseHandler)(
         googleInteractionsResponseSchema
       ),
       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 : import_provider_utils22.generateId,
+        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 : import_provider_utils20.generateId,
+      generateId: (_b = this.config.generateId) != null ? _b : import_provider_utils22.generateId,
       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 }
     };
@@ -5354,11 +5566,11 @@ function pruneUndefined(obj) {
 // src/google-provider.ts
 function createGoogleGenerativeAI(options = {}) {
   var _a, _b;
-  const baseURL = (_a = (0, import_provider_utils21.withoutTrailingSlash)(options.baseURL)) != null ? _a : "https://generativelanguage.googleapis.com/v1beta";
+  const baseURL = (_a = (0, import_provider_utils23.withoutTrailingSlash)(options.baseURL)) != null ? _a : "https://generativelanguage.googleapis.com/v1beta";
   const providerName = (_b = options.name) != null ? _b : "google.generative-ai";
-  const getHeaders = () => (0, import_provider_utils21.withUserAgentSuffix)(
+  const getHeaders = () => (0, import_provider_utils23.withUserAgentSuffix)(
     {
-      "x-goog-api-key": (0, import_provider_utils21.loadApiKey)({
+      "x-goog-api-key": (0, import_provider_utils23.loadApiKey)({
         apiKey: options.apiKey,
         environmentVariableName: "GOOGLE_GENERATIVE_AI_API_KEY",
         description: "Google Generative AI"
@@ -5373,7 +5585,7 @@ function createGoogleGenerativeAI(options = {}) {
       provider: providerName,
       baseURL,
       headers: getHeaders,
-      generateId: (_a2 = options.generateId) != null ? _a2 : import_provider_utils21.generateId,
+      generateId: (_a2 = options.generateId) != null ? _a2 : import_provider_utils23.generateId,
       supportedUrls: () => ({
         "*": [
           // Google Generative Language "files" endpoint
@@ -5408,7 +5620,7 @@ function createGoogleGenerativeAI(options = {}) {
       baseURL,
       headers: getHeaders,
       fetch: options.fetch,
-      generateId: (_a2 = options.generateId) != null ? _a2 : import_provider_utils21.generateId
+      generateId: (_a2 = options.generateId) != null ? _a2 : import_provider_utils23.generateId
     });
   };
   const createInteractionsModel = (modelIdOrAgent) => {
@@ -5419,7 +5631,7 @@ function createGoogleGenerativeAI(options = {}) {
         provider: `${providerName}.interactions`,
         baseURL,
         headers: getHeaders,
-        generateId: (_a2 = options.generateId) != null ? _a2 : import_provider_utils21.generateId,
+        generateId: (_a2 = options.generateId) != null ? _a2 : import_provider_utils23.generateId,
         fetch: options.fetch
       }
     );