ai 5.0.0-beta.33 → 5.0.0-beta.34

package/dist/index.mjs

@@ -98,45 +98,51 @@ var RetryError = class extends AISDKError3 {
 _a3 = symbol3;
 
 // src/util/retry-with-exponential-backoff.ts
-function getRetryDelay(error, exponentialBackoffDelay) {
+function getRetryDelayInMs({
+  error,
+  exponentialBackoffDelay
+}) {
   const headers = error.responseHeaders;
   if (!headers)
     return exponentialBackoffDelay;
-  let timeoutMillis;
+  let ms;
   const retryAfterMs = headers["retry-after-ms"];
   if (retryAfterMs) {
     const timeoutMs = parseFloat(retryAfterMs);
     if (!Number.isNaN(timeoutMs)) {
-      timeoutMillis = timeoutMs;
+      ms = timeoutMs;
     }
   }
   const retryAfter = headers["retry-after"];
-  if (retryAfter && timeoutMillis === void 0) {
+  if (retryAfter && ms === void 0) {
     const timeoutSeconds = parseFloat(retryAfter);
     if (!Number.isNaN(timeoutSeconds)) {
-      timeoutMillis = timeoutSeconds * 1e3;
+      ms = timeoutSeconds * 1e3;
     } else {
-      timeoutMillis = Date.parse(retryAfter) - Date.now();
+      ms = Date.parse(retryAfter) - Date.now();
     }
   }
-  if (timeoutMillis !== void 0 && 0 <= timeoutMillis && timeoutMillis < 60 * 1e3) {
-    return timeoutMillis;
+  if (ms != null && !Number.isNaN(ms) && 0 <= ms && (ms < 60 * 1e3 || ms < exponentialBackoffDelay)) {
+    return ms;
   }
   return exponentialBackoffDelay;
 }
 var retryWithExponentialBackoffRespectingRetryHeaders = ({
   maxRetries = 2,
   initialDelayInMs = 2e3,
-  backoffFactor = 2
+  backoffFactor = 2,
+  abortSignal
 } = {}) => async (f) => _retryWithExponentialBackoff(f, {
   maxRetries,
   delayInMs: initialDelayInMs,
-  backoffFactor
+  backoffFactor,
+  abortSignal
 });
 async function _retryWithExponentialBackoff(f, {
   maxRetries,
   delayInMs,
-  backoffFactor
+  backoffFactor,
+  abortSignal
 }, errors = []) {
   try {
     return await f();
@@ -158,11 +164,21 @@ async function _retryWithExponentialBackoff(f, {
       });
     }
     if (error instanceof Error && APICallError.isInstance(error) && error.isRetryable === true && tryNumber <= maxRetries) {
-      const actualDelay = getRetryDelay(error, delayInMs);
-      await delay(actualDelay);
+      await delay(
+        getRetryDelayInMs({
+          error,
+          exponentialBackoffDelay: delayInMs
+        }),
+        { abortSignal }
+      );
       return _retryWithExponentialBackoff(
         f,
-        { maxRetries, delayInMs: backoffFactor * delayInMs, backoffFactor },
+        {
+          maxRetries,
+          delayInMs: backoffFactor * delayInMs,
+          backoffFactor,
+          abortSignal
+        },
         newErrors
       );
     }
@@ -179,7 +195,8 @@ async function _retryWithExponentialBackoff(f, {
 
 // src/util/prepare-retries.ts
 function prepareRetries({
-  maxRetries
+  maxRetries,
+  abortSignal
 }) {
   if (maxRetries != null) {
     if (!Number.isInteger(maxRetries)) {
@@ -201,7 +218,8 @@ function prepareRetries({
   return {
     maxRetries: maxRetriesResult,
     retry: retryWithExponentialBackoffRespectingRetryHeaders({
-      maxRetries: maxRetriesResult
+      maxRetries: maxRetriesResult,
+      abortSignal
     })
   };
 }
@@ -1957,7 +1975,10 @@ async function generateText({
 }) {
   const model = resolveLanguageModel(modelArg);
   const stopConditions = asArray(stopWhen);
-  const { maxRetries, retry } = prepareRetries({ maxRetries: maxRetriesArg });
+  const { maxRetries, retry } = prepareRetries({
+    maxRetries: maxRetriesArg,
+    abortSignal
+  });
   const callSettings = prepareCallSettings(settings);
   const baseTelemetryAttributes = getBaseTelemetryAttributes({
     model,
@@ -4448,7 +4469,8 @@ var DefaultStreamTextResult = class {
     }
     this.baseStream = stream.pipeThrough(createOutputTransformStream(output)).pipeThrough(eventProcessor);
     const { maxRetries, retry } = prepareRetries({
-      maxRetries: maxRetriesArg
+      maxRetries: maxRetriesArg,
+      abortSignal
     });
     const tracer = getTracer(telemetry);
     const callSettings = prepareCallSettings(settings);
@@ -5324,7 +5346,10 @@ async function embed({
       modelId: model.modelId
     });
   }
-  const { maxRetries, retry } = prepareRetries({ maxRetries: maxRetriesArg });
+  const { maxRetries, retry } = prepareRetries({
+    maxRetries: maxRetriesArg,
+    abortSignal
+  });
   const baseTelemetryAttributes = getBaseTelemetryAttributes({
     model,
     telemetry,
@@ -5454,7 +5479,10 @@ async function embedMany({
       modelId: model.modelId
     });
   }
-  const { maxRetries, retry } = prepareRetries({ maxRetries: maxRetriesArg });
+  const { maxRetries, retry } = prepareRetries({
+    maxRetries: maxRetriesArg,
+    abortSignal
+  });
   const baseTelemetryAttributes = getBaseTelemetryAttributes({
     model,
     telemetry,
@@ -5691,7 +5719,10 @@ async function generateImage({
       modelId: model.modelId
     });
   }
-  const { retry } = prepareRetries({ maxRetries: maxRetriesArg });
+  const { retry } = prepareRetries({
+    maxRetries: maxRetriesArg,
+    abortSignal
+  });
   const maxImagesPerCallWithDefault = (_a16 = maxImagesPerCall != null ? maxImagesPerCall : await invokeModelMaxImagesPerCall(model)) != null ? _a16 : 1;
   const callCount = Math.ceil(n / maxImagesPerCallWithDefault);
   const callImageCounts = Array.from({ length: callCount }, (_, i) => {
@@ -5780,12 +5811,7 @@ async function invokeModelMaxImagesPerCall(model) {
 
 // src/generate-object/generate-object.ts
 import {
-  JSONParseError as JSONParseError2,
-  TypeValidationError as TypeValidationError3
-} from "@ai-sdk/provider";
-import {
-  createIdGenerator as createIdGenerator3,
-  safeParseJSON as safeParseJSON3
+  createIdGenerator as createIdGenerator3
 } from "@ai-sdk/provider-utils";
 
 // src/generate-object/output-strategy.ts
@@ -6172,6 +6198,63 @@ function validateObjectGenerationInput({
   }
 }
 
+// src/generate-object/parse-and-validate-object-result.ts
+import { JSONParseError as JSONParseError2, TypeValidationError as TypeValidationError3 } from "@ai-sdk/provider";
+import { safeParseJSON as safeParseJSON3 } from "@ai-sdk/provider-utils";
+async function parseAndValidateObjectResult(result, outputStrategy, context) {
+  const parseResult = await safeParseJSON3({ text: result });
+  if (!parseResult.success) {
+    throw new NoObjectGeneratedError({
+      message: "No object generated: could not parse the response.",
+      cause: parseResult.error,
+      text: result,
+      response: context.response,
+      usage: context.usage,
+      finishReason: context.finishReason
+    });
+  }
+  const validationResult = await outputStrategy.validateFinalResult(
+    parseResult.value,
+    {
+      text: result,
+      response: context.response,
+      usage: context.usage
+    }
+  );
+  if (!validationResult.success) {
+    throw new NoObjectGeneratedError({
+      message: "No object generated: response did not match schema.",
+      cause: validationResult.error,
+      text: result,
+      response: context.response,
+      usage: context.usage,
+      finishReason: context.finishReason
+    });
+  }
+  return validationResult.value;
+}
+async function parseAndValidateObjectResultWithRepair(result, outputStrategy, repairText, context) {
+  try {
+    return await parseAndValidateObjectResult(result, outputStrategy, context);
+  } catch (error) {
+    if (repairText != null && NoObjectGeneratedError.isInstance(error) && (JSONParseError2.isInstance(error.cause) || TypeValidationError3.isInstance(error.cause))) {
+      const repairedText = await repairText({
+        text: result,
+        error: error.cause
+      });
+      if (repairedText === null) {
+        throw error;
+      }
+      return await parseAndValidateObjectResult(
+        repairedText,
+        outputStrategy,
+        context
+      );
+    }
+    throw error;
+  }
+}
+
 // src/generate-object/generate-object.ts
 var originalGenerateId3 = createIdGenerator3({ prefix: "aiobj", size: 24 });
 async function generateObject(options) {
@@ -6207,7 +6290,10 @@ async function generateObject(options) {
     schemaDescription,
     enumValues
   });
-  const { maxRetries, retry } = prepareRetries({ maxRetries: maxRetriesArg });
+  const { maxRetries, retry } = prepareRetries({
+    maxRetries: maxRetriesArg,
+    abortSignal
+  });
   const outputStrategy = getOutputStrategy({
     output,
     schema: inputSchema,
@@ -6353,55 +6439,16 @@ async function generateObject(options) {
         resultProviderMetadata = generateResult.providerMetadata;
         request = (_a16 = generateResult.request) != null ? _a16 : {};
         response = generateResult.responseData;
-        async function processResult(result2) {
-          const parseResult = await safeParseJSON3({ text: result2 });
-          if (!parseResult.success) {
-            throw new NoObjectGeneratedError({
-              message: "No object generated: could not parse the response.",
-              cause: parseResult.error,
-              text: result2,
-              response,
-              usage,
-              finishReason
-            });
-          }
-          const validationResult = await outputStrategy.validateFinalResult(
-            parseResult.value,
-            {
-              text: result2,
-              response,
-              usage
-            }
-          );
-          if (!validationResult.success) {
-            throw new NoObjectGeneratedError({
-              message: "No object generated: response did not match schema.",
-              cause: validationResult.error,
-              text: result2,
-              response,
-              usage,
-              finishReason
-            });
-          }
-          return validationResult.value;
-        }
-        let object2;
-        try {
-          object2 = await processResult(result);
-        } catch (error) {
-          if (repairText != null && NoObjectGeneratedError.isInstance(error) && (JSONParseError2.isInstance(error.cause) || TypeValidationError3.isInstance(error.cause))) {
-            const repairedText = await repairText({
-              text: result,
-              error: error.cause
-            });
-            if (repairedText === null) {
-              throw error;
-            }
-            object2 = await processResult(repairedText);
-          } else {
-            throw error;
+        const object2 = await parseAndValidateObjectResultWithRepair(
+          result,
+          outputStrategy,
+          repairText,
+          {
+            response,
+            usage,
+            finishReason
           }
-        }
+        );
         span.setAttributes(
           selectTelemetryAttributes({
             telemetry,
@@ -6602,6 +6649,7 @@ function streamObject(options) {
     maxRetries,
     abortSignal,
     headers,
+    experimental_repairText: repairText,
     experimental_telemetry: telemetry,
     providerOptions,
     onError = ({ error }) => {
@@ -6647,6 +6695,7 @@ function streamObject(options) {
     schemaName,
     schemaDescription,
     providerOptions,
+    repairText,
     onError,
     onFinish,
     generateId: generateId3,
@@ -6669,6 +6718,7 @@ var DefaultStreamObjectResult = class {
     schemaName,
     schemaDescription,
     providerOptions,
+    repairText,
     onError,
     onFinish,
     generateId: generateId3,
@@ -6684,7 +6734,8 @@ var DefaultStreamObjectResult = class {
     this._finishReason = new DelayedPromise();
     const model = resolveLanguageModel(modelArg);
     const { maxRetries, retry } = prepareRetries({
-      maxRetries: maxRetriesArg
+      maxRetries: maxRetriesArg,
+      abortSignal
     });
     const callSettings = prepareCallSettings(settings);
     const baseTelemetryAttributes = getBaseTelemetryAttributes({
@@ -6902,27 +6953,21 @@ var DefaultStreamObjectResult = class {
                     headers: response == null ? void 0 : response.headers
                   });
                   self._finishReason.resolve(finishReason != null ? finishReason : "unknown");
-                  const validationResult = await outputStrategy.validateFinalResult(
-                    latestObjectJson,
-                    {
-                      text: accumulatedText,
-                      response: fullResponse,
-                      usage
-                    }
-                  );
-                  if (validationResult.success) {
-                    object2 = validationResult.value;
+                  try {
+                    object2 = await parseAndValidateObjectResultWithRepair(
+                      accumulatedText,
+                      outputStrategy,
+                      repairText,
+                      {
+                        response: fullResponse,
+                        usage,
+                        finishReason
+                      }
+                    );
                     self._object.resolve(object2);
-                  } else {
-                    error = new NoObjectGeneratedError({
-                      message: "No object generated: response did not match schema.",
-                      cause: validationResult.error,
-                      text: accumulatedText,
-                      response: fullResponse,
-                      usage,
-                      finishReason
-                    });
-                    self._object.reject(error);
+                  } catch (e) {
+                    error = e;
+                    self._object.reject(e);
                   }
                   break;
                 }
@@ -7165,7 +7210,10 @@ async function generateSpeech({
       modelId: model.modelId
     });
   }
-  const { retry } = prepareRetries({ maxRetries: maxRetriesArg });
+  const { retry } = prepareRetries({
+    maxRetries: maxRetriesArg,
+    abortSignal
+  });
   const result = await retry(
     () => model.doGenerate({
       text: text2,
@@ -7213,7 +7261,7 @@ __export(output_exports, {
 });
 import {
   asSchema as asSchema4,
-  safeParseJSON as safeParseJSON4,
+  safeParseJSON as safeParseJSON5,
   safeValidateTypes as safeValidateTypes4
 } from "@ai-sdk/provider-utils";
 var text = () => ({
@@ -7255,7 +7303,7 @@ var object = ({
       }
     },
     async parseOutput({ text: text2 }, context) {
-      const parseResult = await safeParseJSON4({ text: text2 });
+      const parseResult = await safeParseJSON5({ text: text2 });
       if (!parseResult.success) {
         throw new NoObjectGeneratedError({
           message: "No object generated: could not parse the response.",
@@ -8477,7 +8525,10 @@ async function transcribe({
       modelId: model.modelId
     });
   }
-  const { retry } = prepareRetries({ maxRetries: maxRetriesArg });
+  const { retry } = prepareRetries({
+    maxRetries: maxRetriesArg,
+    abortSignal
+  });
   const audioData = audio instanceof URL ? (await download({ url: audio })).data : convertDataContentToUint8Array(audio);
   const result = await retry(
     () => {
@@ -8925,6 +8976,15 @@ var AbstractChat = class {
     this.resumeStream = async (options = {}) => {
       await this.makeRequest({ trigger: "resume-stream", ...options });
     };
+    /**
+     * Clear the error state and set the status to ready if the chat is in an error state.
+     */
+    this.clearError = () => {
+      if (this.status === "error") {
+        this.state.error = void 0;
+        this.setStatus({ status: "ready" });
+      }
+    };
     this.addToolResult = async ({
       tool: tool3,
       toolCallId,