@ai-sdk/google 3.0.70 → 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.70" : "0.0.0-test";
+var VERSION = true ? "3.0.72" : "0.0.0-test";
 
 // src/google-generative-ai-embedding-model.ts
 import {
@@ -1499,7 +1499,7 @@ var GoogleGenerativeAILanguageModel = class {
     };
   }
   async doGenerate(options) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q;
     const { args, warnings, providerOptionsName } = await this.getArgs(options);
     const mergedHeaders = combineHeaders2(
       await resolve2(this.config.headers),
@@ -1567,12 +1567,12 @@ var GoogleGenerativeAILanguageModel = class {
             providerMetadata: thoughtSignatureMetadata
           });
         }
-      } else if ("functionCall" in part && part.functionCall.name != null && part.functionCall.args != null) {
+      } else if ("functionCall" in part && part.functionCall.name != null) {
         content.push({
           type: "tool-call",
           toolCallId: this.config.generateId(),
           toolName: part.functionCall.name,
-          input: JSON.stringify(part.functionCall.args),
+          input: JSON.stringify((_e = part.functionCall.args) != null ? _e : {}),
           providerMetadata: part.thoughtSignature ? {
             [providerOptionsName]: {
               thoughtSignature: part.thoughtSignature
@@ -1594,13 +1594,13 @@ var GoogleGenerativeAILanguageModel = class {
           } : void 0
         });
       } else if ("toolCall" in part && part.toolCall) {
-        const toolCallId = (_e = part.toolCall.id) != null ? _e : this.config.generateId();
+        const toolCallId = (_f = part.toolCall.id) != null ? _f : this.config.generateId();
         lastServerToolCallId = toolCallId;
         content.push({
           type: "tool-call",
           toolCallId,
           toolName: `server:${part.toolCall.toolType}`,
-          input: JSON.stringify((_f = part.toolCall.args) != null ? _f : {}),
+          input: JSON.stringify((_g = part.toolCall.args) != null ? _g : {}),
           providerExecuted: true,
           dynamic: true,
           providerMetadata: part.thoughtSignature ? {
@@ -1617,12 +1617,12 @@ var GoogleGenerativeAILanguageModel = class {
           }
         });
       } else if ("toolResponse" in part && part.toolResponse) {
-        const responseToolCallId = (_g = lastServerToolCallId != null ? lastServerToolCallId : part.toolResponse.id) != null ? _g : this.config.generateId();
+        const responseToolCallId = (_h = lastServerToolCallId != null ? lastServerToolCallId : part.toolResponse.id) != null ? _h : this.config.generateId();
         content.push({
           type: "tool-result",
           toolCallId: responseToolCallId,
           toolName: `server:${part.toolResponse.toolType}`,
-          result: (_h = part.toolResponse.response) != null ? _h : {},
+          result: (_i = part.toolResponse.response) != null ? _i : {},
           providerMetadata: part.thoughtSignature ? {
             [providerOptionsName]: {
               thoughtSignature: part.thoughtSignature,
@@ -1639,10 +1639,10 @@ var GoogleGenerativeAILanguageModel = class {
         lastServerToolCallId = void 0;
       }
     }
-    const sources = (_i = extractSources({
+    const sources = (_j = extractSources({
       groundingMetadata: candidate.groundingMetadata,
       generateId: this.config.generateId
-    })) != null ? _i : [];
+    })) != null ? _j : [];
     for (const source of sources) {
       content.push(source);
     }
@@ -1656,19 +1656,19 @@ var GoogleGenerativeAILanguageModel = class {
             (part) => part.type === "tool-call" && !part.providerExecuted
           )
         }),
-        raw: (_j = candidate.finishReason) != null ? _j : void 0
+        raw: (_k = candidate.finishReason) != null ? _k : void 0
       },
       usage: convertGoogleGenerativeAIUsage(usageMetadata),
       warnings,
       providerMetadata: {
         [providerOptionsName]: {
-          promptFeedback: (_k = response.promptFeedback) != null ? _k : null,
-          groundingMetadata: (_l = candidate.groundingMetadata) != null ? _l : null,
-          urlContextMetadata: (_m = candidate.urlContextMetadata) != null ? _m : null,
-          safetyRatings: (_n = candidate.safetyRatings) != null ? _n : null,
+          promptFeedback: (_l = response.promptFeedback) != null ? _l : null,
+          groundingMetadata: (_m = candidate.groundingMetadata) != null ? _m : null,
+          urlContextMetadata: (_n = candidate.urlContextMetadata) != null ? _n : null,
+          safetyRatings: (_o = candidate.safetyRatings) != null ? _o : null,
           usageMetadata: usageMetadata != null ? usageMetadata : null,
-          finishMessage: (_o = candidate.finishMessage) != null ? _o : null,
-          serviceTier: (_p = response.serviceTier) != null ? _p : null
+          finishMessage: (_p = candidate.finishMessage) != null ? _p : null,
+          serviceTier: (_q = response.serviceTier) != null ? _q : null
         }
       },
       request: { body: args },
@@ -1927,6 +1927,7 @@ var GoogleGenerativeAILanguageModel = class {
                 const isStreamingChunk = part.functionCall.partialArgs != null || part.functionCall.name != null && part.functionCall.willContinue === true;
                 const isTerminalChunk = part.functionCall.name == null && part.functionCall.args == null && part.functionCall.partialArgs == null && part.functionCall.willContinue == null;
                 const isCompleteCall = part.functionCall.name != null && part.functionCall.args != null && part.functionCall.partialArgs == null;
+                const isNoArgsCompleteCall = part.functionCall.name != null && part.functionCall.args == null && part.functionCall.partialArgs == null && part.functionCall.willContinue !== true;
                 if (isStreamingChunk) {
                   if (part.functionCall.name != null && part.functionCall.willContinue === true) {
                     const toolCallId = generateId3();
@@ -2023,6 +2024,28 @@ var GoogleGenerativeAILanguageModel = class {
                     providerMetadata: providerMeta
                   });
                   hasToolCalls = true;
+                } else if (isNoArgsCompleteCall) {
+                  const toolCallId = generateId3();
+                  const toolName = part.functionCall.name;
+                  controller.enqueue({
+                    type: "tool-input-start",
+                    id: toolCallId,
+                    toolName,
+                    providerMetadata: providerMeta
+                  });
+                  controller.enqueue({
+                    type: "tool-input-end",
+                    id: toolCallId,
+                    providerMetadata: providerMeta
+                  });
+                  controller.enqueue({
+                    type: "tool-call",
+                    toolCallId,
+                    toolName,
+                    input: "{}",
+                    providerMetadata: providerMeta
+                  });
+                  hasToolCalls = true;
                 }
               }
             }
@@ -3055,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,
@@ -4680,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);
@@ -4707,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;
   }
 }
 
@@ -4886,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,
@@ -5199,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
     );
@@ -5279,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,
@@ -5299,7 +5536,7 @@ var GoogleInteractionsLanguageModel = class {
       headers: mergedHeaders,
       body,
       failedResponseHandler: googleFailedResponseHandler,
-      successfulResponseHandler: createEventSourceResponseHandler2(
+      successfulResponseHandler: createEventSourceResponseHandler3(
         googleInteractionsEventSchema
       ),
       abortSignal: options.abortSignal,
@@ -5319,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,
@@ -5358,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 }
     };
@@ -5405,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,