@ai-sdk/google 4.0.0-canary.58 → 4.0.0-canary.60

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @ai-sdk/google
 
+## 4.0.0-canary.60
+
+### Patch Changes
+
+- 6a26901: feat(google): add `fileData` support to embedding model
+
+## 4.0.0-canary.59
+
+### Patch Changes
+
+- db394ab: feat(provider/google): support cancelling long-running Interactions API agents via AbortSignal, and process their intermittent stream
+- Updated dependencies [ca446f8]
+  - @ai-sdk/provider-utils@5.0.0-canary.38
+
 ## 4.0.0-canary.58
 
 ### Patch Changes

package/dist/index.d.ts

@@ -228,6 +228,11 @@ declare const googleEmbeddingModelOptions: _ai_sdk_provider_utils.LazySchema<{
             mimeType: string;
             data: string;
         };
+    } | {
+        fileData: {
+            fileUri: string;
+            mimeType: string;
+        };
     })[] | null)[] | undefined;
 }>;
 type GoogleEmbeddingModelOptions = InferSchema<typeof googleEmbeddingModelOptions>;

package/dist/index.js

@@ -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 ? "4.0.0-canary.58" : "0.0.0-test";
+var VERSION = true ? "4.0.0-canary.60" : "0.0.0-test";
 
 // src/google-embedding-model.ts
 import {
@@ -63,6 +63,12 @@ var googleEmbeddingContentPartSchema = z2.union([
       mimeType: z2.string(),
       data: z2.string()
     })
+  }),
+  z2.object({
+    fileData: z2.object({
+      fileUri: z2.string(),
+      mimeType: z2.string()
+    })
   })
 ]);
 var googleEmbeddingModelOptions = lazySchema2(
@@ -3462,8 +3468,8 @@ var googleOperationSchema = z17.object({
 
 // src/interactions/google-interactions-language-model.ts
 import {
-  combineHeaders as combineHeaders6,
-  createEventSourceResponseHandler as createEventSourceResponseHandler2,
+  combineHeaders as combineHeaders7,
+  createEventSourceResponseHandler as createEventSourceResponseHandler3,
   createJsonResponseHandler as createJsonResponseHandler7,
   generateId as defaultGenerateId2,
   parseProviderOptions as parseProviderOptions6,
@@ -5074,8 +5080,45 @@ function parseGoogleInteractionsOutputs({
 import {
   createJsonResponseHandler as createJsonResponseHandler6,
   delay as delay3,
-  getFromApi as getFromApi3
+  getFromApi as getFromApi3,
+  isAbortError
+} from "@ai-sdk/provider-utils";
+
+// src/interactions/cancel-google-interaction.ts
+import {
+  combineHeaders as combineHeaders6,
+  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(
+        combineHeaders6({ "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);
@@ -5101,34 +5144,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 delay3(nextDelayMs, { abortSignal });
+      const {
+        value: response,
+        rawValue: rawResponse,
+        responseHeaders
+      } = await getFromApi3({
+        url,
+        headers,
+        failedResponseHandler: googleFailedResponseHandler,
+        successfulResponseHandler: createJsonResponseHandler6(
+          googleInteractionsResponseSchema
+        ),
+        abortSignal,
+        fetch
+      });
+      if (isTerminalStatus(response.status)) {
+        return { response, rawResponse, responseHeaders };
+      }
+      nextDelayMs = Math.min(nextDelayMs * 2, maxDelayMs);
     }
-    await delay3(nextDelayMs, { abortSignal });
-    const {
-      value: response,
-      rawValue: rawResponse,
-      responseHeaders
-    } = await getFromApi3({
-      url,
-      headers,
-      failedResponseHandler: googleFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler6(
-        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;
   }
 }
 
@@ -5280,6 +5332,174 @@ function prepareGoogleInteractionsTools({
   };
 }
 
+// src/interactions/stream-google-interactions.ts
+import {
+  createEventSourceResponseHandler as createEventSourceResponseHandler2,
+  delay as delay4,
+  getFromApi as getFromApi4,
+  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 getFromApi4({
+      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 delay4(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 delay4(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 delay4(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,
@@ -5608,7 +5828,7 @@ var GoogleInteractionsLanguageModel = class _GoogleInteractionsLanguageModel {
     var _a, _b, _c, _d, _e, _f;
     const { args, warnings, isAgent, pollingTimeoutMs } = await this.getArgs(options);
     const url = `${this.config.baseURL}/interactions`;
-    const mergedHeaders = combineHeaders6(
+    const mergedHeaders = combineHeaders7(
       this.config.headers ? await resolve5(this.config.headers) : void 0,
       options.headers
     );
@@ -5688,12 +5908,12 @@ var GoogleInteractionsLanguageModel = class _GoogleInteractionsLanguageModel {
     var _a;
     const { args, warnings, isAgent, pollingTimeoutMs } = await this.getArgs(options);
     const url = `${this.config.baseURL}/interactions`;
-    const mergedHeaders = combineHeaders6(
+    const mergedHeaders = combineHeaders7(
       this.config.headers ? await resolve5(this.config.headers) : void 0,
       options.headers
     );
     if (isAgent) {
-      return this.doStreamAgent({
+      return this.doStreamBackground({
         args,
         warnings,
         url,
@@ -5708,7 +5928,7 @@ var GoogleInteractionsLanguageModel = class _GoogleInteractionsLanguageModel {
       headers: mergedHeaders,
       body,
       failedResponseHandler: googleFailedResponseHandler,
-      successfulResponseHandler: createEventSourceResponseHandler2(
+      successfulResponseHandler: createEventSourceResponseHandler3(
         googleInteractionsEventSchema
       ),
       abortSignal: options.abortSignal,
@@ -5728,26 +5948,24 @@ var GoogleInteractionsLanguageModel = class _GoogleInteractionsLanguageModel {
     };
   }
   /*
-   * 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,
@@ -5767,34 +5985,44 @@ var GoogleInteractionsLanguageModel = class _GoogleInteractionsLanguageModel {
       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 }
     };
@@ -5814,7 +6042,7 @@ function createGoogle(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,