ai 3.1.0-canary.2 → 3.1.0-canary.4

package/core/dist/index.js

@@ -33,7 +33,6 @@ __export(core_exports, {
   GenerateObjectResult: () => GenerateObjectResult,
   GenerateTextResult: () => GenerateTextResult,
   StreamObjectResult: () => StreamObjectResult,
-  StreamTextHttpResponse: () => StreamTextHttpResponse,
   StreamTextResult: () => StreamTextResult,
   convertDataContentToBase64String: () => convertDataContentToBase64String,
   convertDataContentToUint8Array: () => convertDataContentToUint8Array,
@@ -48,10 +47,52 @@ module.exports = __toCommonJS(core_exports);
 // core/generate-object/generate-object.ts
 var import_zod_to_json_schema = __toESM(require("zod-to-json-schema"));
 
-// ai-model-specification/errors/ai-invalid-argument-error.ts
-var AI_InvalidArgumentError = class extends Error {
-  // readonly learnMore =
-  //   'https://sdk.vercel.com/docs/ai/errors/ai_invalid_argument_error';
+// ai-model-specification/errors/api-call-error.ts
+var APICallError = class extends Error {
+  constructor({
+    message,
+    url,
+    requestBodyValues,
+    statusCode,
+    responseBody,
+    cause,
+    isRetryable = statusCode != null && (statusCode === 408 || // request timeout
+    statusCode === 409 || // conflict
+    statusCode === 429 || // too many requests
+    statusCode >= 500),
+    // server error
+    data
+  }) {
+    super(message);
+    this.name = "AI_APICallError";
+    this.url = url;
+    this.requestBodyValues = requestBodyValues;
+    this.statusCode = statusCode;
+    this.responseBody = responseBody;
+    this.cause = cause;
+    this.isRetryable = isRetryable;
+    this.data = data;
+  }
+  static isAPICallError(error) {
+    return error instanceof Error && error.name === "AI_APICallError" && typeof error.url === "string" && typeof error.requestBodyValues === "object" && (error.statusCode == null || typeof error.statusCode === "number") && (error.responseBody == null || typeof error.responseBody === "string") && (error.cause == null || typeof error.cause === "object") && typeof error.isRetryable === "boolean" && (error.data == null || typeof error.data === "object");
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      url: this.url,
+      requestBodyValues: this.requestBodyValues,
+      statusCode: this.statusCode,
+      responseBody: this.responseBody,
+      cause: this.cause,
+      isRetryable: this.isRetryable,
+      data: this.data
+    };
+  }
+};
+
+// ai-model-specification/errors/invalid-argument-error.ts
+var InvalidArgumentError = class extends Error {
   constructor({
     parameter,
     value,
@@ -62,6 +103,9 @@ var AI_InvalidArgumentError = class extends Error {
     this.parameter = parameter;
     this.value = value;
   }
+  static isInvalidArgumentError(error) {
+    return error instanceof Error && error.name === "AI_InvalidArgumentError" && typeof error.parameter === "string" && typeof error.value === "string";
+  }
   toJSON() {
     return {
       name: this.name,
@@ -87,6 +131,9 @@ function getErrorMessage(error) {
   return JSON.stringify(error);
 }
 
+// ai-model-specification/util/parse-json.ts
+var import_secure_json_parse = __toESM(require("secure-json-parse"));
+
 // ai-model-specification/errors/json-parse-error.ts
 var JSONParseError = class extends Error {
   constructor({ text, cause }) {
@@ -94,10 +141,13 @@ var JSONParseError = class extends Error {
       `JSON parsing failed: Text: ${text}.
 Error message: ${getErrorMessage(cause)}`
     );
-    this.name = "JSONParseError";
+    this.name = "AI_JSONParseError";
     this.cause = cause;
     this.text = text;
   }
+  static isJSONParseError(error) {
+    return error instanceof Error && error.name === "AI_JSONParseError" && typeof error.text === "string" && typeof error.cause === "string";
+  }
   toJSON() {
     return {
       name: this.name,
@@ -109,22 +159,6 @@ Error message: ${getErrorMessage(cause)}`
   }
 };
 
-// ai-model-specification/errors/no-object-generated-error.ts
-var NoTextGeneratedError = class extends Error {
-  constructor() {
-    super(`No text generated.`);
-    this.name = "NoTextGeneratedError";
-  }
-  toJSON() {
-    return {
-      name: this.name,
-      cause: this.cause,
-      message: this.message,
-      stack: this.stack
-    };
-  }
-};
-
 // ai-model-specification/errors/type-validation-error.ts
 var TypeValidationError = class extends Error {
   constructor({ value, cause }) {
@@ -132,10 +166,13 @@ var TypeValidationError = class extends Error {
       `Type validation failed: Value: ${JSON.stringify(value)}.
 Error message: ${getErrorMessage(cause)}`
     );
-    this.name = "TypeValidationError";
+    this.name = "AI_TypeValidationError";
     this.cause = cause;
     this.value = value;
   }
+  static isTypeValidationError(error) {
+    return error instanceof Error && error.name === "AI_TypeValidationError" && typeof error.value === "string" && typeof error.cause === "string";
+  }
   toJSON() {
     return {
       name: this.name,
@@ -147,9 +184,6 @@ Error message: ${getErrorMessage(cause)}`
   }
 };
 
-// ai-model-specification/util/parse-json.ts
-var import_secure_json_parse = __toESM(require("secure-json-parse"));
-
 // ai-model-specification/util/validate-types.ts
 function safeValidateTypes({
   value,
@@ -173,7 +207,7 @@ function safeValidateTypes({
   } catch (error) {
     return {
       success: false,
-      error: error instanceof TypeValidationError ? error : new TypeValidationError({ value, cause: error })
+      error: TypeValidationError.isTypeValidationError(error) ? error : new TypeValidationError({ value, cause: error })
     };
   }
 }
@@ -195,7 +229,7 @@ function safeParseJSON({
   } catch (error) {
     return {
       success: false,
-      error: error instanceof JSONParseError ? error : new JSONParseError({ text, cause: error })
+      error: JSONParseError.isJSONParseError(error) ? error : new JSONParseError({ text, cause: error })
     };
   }
 }
@@ -214,6 +248,112 @@ function convertUint8ArrayToBase64(array) {
   return globalThis.btoa(latin1string);
 }
 
+// ai-model-specification/errors/invalid-tool-arguments-error.ts
+var InvalidToolArgumentsError = class extends Error {
+  constructor({
+    toolArgs,
+    toolName,
+    cause,
+    message = `Invalid arguments for tool ${toolName}: ${getErrorMessage(
+      cause
+    )}`
+  }) {
+    super(message);
+    this.name = "AI_InvalidToolArgumentsError";
+    this.toolArgs = toolArgs;
+    this.toolName = toolName;
+    this.cause = cause;
+  }
+  static isInvalidToolArgumentsError(error) {
+    return error instanceof Error && error.name === "AI_InvalidToolArgumentsError" && typeof error.toolName === "string" && typeof error.toolArgs === "string";
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      cause: this.cause,
+      stack: this.stack,
+      toolName: this.toolName,
+      toolArgs: this.toolArgs
+    };
+  }
+};
+
+// ai-model-specification/errors/no-object-generated-error.ts
+var NoTextGeneratedError = class extends Error {
+  constructor() {
+    super(`No text generated.`);
+    this.name = "AI_NoTextGeneratedError";
+  }
+  static isNoTextGeneratedError(error) {
+    return error instanceof Error && error.name === "AI_NoTextGeneratedError";
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      cause: this.cause,
+      message: this.message,
+      stack: this.stack
+    };
+  }
+};
+
+// ai-model-specification/errors/no-such-tool-error.ts
+var NoSuchToolError = class extends Error {
+  constructor({ message, toolName }) {
+    super(message);
+    this.name = "AI_NoSuchToolError";
+    this.toolName = toolName;
+  }
+  static isNoSuchToolError(error) {
+    return error instanceof Error && error.name === "AI_NoSuchToolError" && typeof error.toolName === "string";
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      stack: this.stack,
+      toolName: this.toolName
+    };
+  }
+};
+
+// ai-model-specification/errors/retry-error.ts
+var RetryError = class extends Error {
+  constructor({
+    message,
+    reason,
+    errors
+  }) {
+    super(message);
+    this.name = "AI_RetryError";
+    this.reason = reason;
+    this.errors = errors;
+    this.lastError = errors[errors.length - 1];
+  }
+  static isRetryError(error) {
+    return error instanceof Error && error.name === "AI_RetryError" && typeof error.reason === "string" && Array.isArray(error.errors);
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      reason: this.reason,
+      lastError: this.lastError,
+      errors: this.errors
+    };
+  }
+};
+
+// core/generate-text/token-usage.ts
+function calculateTokenUsage(usage) {
+  return {
+    promptTokens: usage.promptTokens,
+    completionTokens: usage.completionTokens,
+    totalTokens: usage.promptTokens + usage.completionTokens
+  };
+}
+
 // core/prompt/data-content.ts
 function convertDataContentToBase64String(content) {
   if (typeof content === "string") {
@@ -283,7 +423,7 @@ function convertToLanguageModelPrompt({
                     case "image": {
                       return {
                         type: "image",
-                        image: convertDataContentToUint8Array(part.image),
+                        image: part.image instanceof URL ? part.image : convertDataContentToUint8Array(part.image),
                         mimeType: part.mimeType
                       };
                     }
@@ -325,98 +465,193 @@ function getInputFormat({
   return prompt != null ? "prompt" : "messages";
 }
 
-// core/prompt/validate-call-settings.ts
-function validateCallSettings(settings) {
-  if (settings.maxTokens != null) {
-    if (!Number.isInteger(settings.maxTokens)) {
-      throw new AI_InvalidArgumentError({
+// core/prompt/prepare-call-settings.ts
+function prepareCallSettings({
+  maxTokens,
+  temperature,
+  topP,
+  presencePenalty,
+  frequencyPenalty,
+  seed,
+  maxRetries
+}) {
+  if (maxTokens != null) {
+    if (!Number.isInteger(maxTokens)) {
+      throw new InvalidArgumentError({
         parameter: "maxTokens",
-        value: settings.maxTokens,
+        value: maxTokens,
         message: "maxTokens must be an integer"
       });
     }
-    if (settings.maxTokens < 1) {
-      throw new AI_InvalidArgumentError({
+    if (maxTokens < 1) {
+      throw new InvalidArgumentError({
         parameter: "maxTokens",
-        value: settings.maxTokens,
+        value: maxTokens,
         message: "maxTokens must be >= 1"
       });
     }
   }
-  if (settings.temperature != null) {
-    if (typeof settings.temperature !== "number") {
-      throw new AI_InvalidArgumentError({
+  if (temperature != null) {
+    if (typeof temperature !== "number") {
+      throw new InvalidArgumentError({
         parameter: "temperature",
-        value: settings.temperature,
+        value: temperature,
         message: "temperature must be a number"
       });
     }
-    if (settings.temperature < 0 || settings.temperature > 1) {
-      throw new AI_InvalidArgumentError({
+    if (temperature < 0 || temperature > 1) {
+      throw new InvalidArgumentError({
         parameter: "temperature",
-        value: settings.temperature,
+        value: temperature,
         message: "temperature must be between 0 and 1 (inclusive)"
       });
     }
   }
-  if (settings.topP != null) {
-    if (typeof settings.topP !== "number") {
-      throw new AI_InvalidArgumentError({
+  if (topP != null) {
+    if (typeof topP !== "number") {
+      throw new InvalidArgumentError({
         parameter: "topP",
-        value: settings.topP,
+        value: topP,
         message: "topP must be a number"
       });
     }
-    if (settings.topP < 0 || settings.topP > 1) {
-      throw new AI_InvalidArgumentError({
+    if (topP < 0 || topP > 1) {
+      throw new InvalidArgumentError({
         parameter: "topP",
-        value: settings.topP,
+        value: topP,
         message: "topP must be between 0 and 1 (inclusive)"
       });
     }
   }
-  if (settings.presencePenalty != null) {
-    if (typeof settings.presencePenalty !== "number") {
-      throw new AI_InvalidArgumentError({
+  if (presencePenalty != null) {
+    if (typeof presencePenalty !== "number") {
+      throw new InvalidArgumentError({
         parameter: "presencePenalty",
-        value: settings.presencePenalty,
+        value: presencePenalty,
         message: "presencePenalty must be a number"
       });
     }
-    if (settings.presencePenalty < -1 || settings.presencePenalty > 1) {
-      throw new AI_InvalidArgumentError({
+    if (presencePenalty < -1 || presencePenalty > 1) {
+      throw new InvalidArgumentError({
         parameter: "presencePenalty",
-        value: settings.presencePenalty,
+        value: presencePenalty,
         message: "presencePenalty must be between -1 and 1 (inclusive)"
       });
     }
   }
-  if (settings.frequencyPenalty != null) {
-    if (typeof settings.frequencyPenalty !== "number") {
-      throw new AI_InvalidArgumentError({
+  if (frequencyPenalty != null) {
+    if (typeof frequencyPenalty !== "number") {
+      throw new InvalidArgumentError({
         parameter: "frequencyPenalty",
-        value: settings.frequencyPenalty,
+        value: frequencyPenalty,
         message: "frequencyPenalty must be a number"
       });
     }
-    if (settings.frequencyPenalty < -1 || settings.frequencyPenalty > 1) {
-      throw new AI_InvalidArgumentError({
+    if (frequencyPenalty < -1 || frequencyPenalty > 1) {
+      throw new InvalidArgumentError({
         parameter: "frequencyPenalty",
-        value: settings.frequencyPenalty,
+        value: frequencyPenalty,
         message: "frequencyPenalty must be between -1 and 1 (inclusive)"
       });
     }
   }
-  if (settings.seed != null) {
-    if (!Number.isInteger(settings.seed)) {
-      throw new AI_InvalidArgumentError({
+  if (seed != null) {
+    if (!Number.isInteger(seed)) {
+      throw new InvalidArgumentError({
         parameter: "seed",
-        value: settings.seed,
+        value: seed,
         message: "seed must be an integer"
       });
     }
   }
-  return settings;
+  if (maxRetries != null) {
+    if (!Number.isInteger(maxRetries)) {
+      throw new InvalidArgumentError({
+        parameter: "maxRetries",
+        value: maxRetries,
+        message: "maxRetries must be an integer"
+      });
+    }
+    if (maxRetries < 0) {
+      throw new InvalidArgumentError({
+        parameter: "maxRetries",
+        value: maxRetries,
+        message: "maxRetries must be >= 0"
+      });
+    }
+  }
+  return {
+    maxTokens,
+    temperature: temperature != null ? temperature : 0,
+    topP,
+    presencePenalty: presencePenalty != null ? presencePenalty : 0,
+    frequencyPenalty: frequencyPenalty != null ? frequencyPenalty : 0,
+    seed,
+    maxRetries: maxRetries != null ? maxRetries : 2
+  };
+}
+
+// core/util/delay.ts
+async function delay(delayInMs) {
+  return new Promise((resolve) => setTimeout(resolve, delayInMs));
+}
+
+// core/util/retry-with-exponential-backoff.ts
+var retryWithExponentialBackoff = ({
+  maxRetries = 2,
+  initialDelayInMs = 2e3,
+  backoffFactor = 2
+} = {}) => async (f) => _retryWithExponentialBackoff(f, {
+  maxRetries,
+  delayInMs: initialDelayInMs,
+  backoffFactor
+});
+async function _retryWithExponentialBackoff(f, {
+  maxRetries,
+  delayInMs,
+  backoffFactor
+}, errors = []) {
+  try {
+    return await f();
+  } catch (error) {
+    if (maxRetries === 0) {
+      throw error;
+    }
+    const errorMessage = getErrorMessage(error);
+    const newErrors = [...errors, error];
+    const tryNumber = newErrors.length;
+    if (tryNumber > maxRetries) {
+      throw new RetryError({
+        message: `Failed after ${tryNumber} attemps. Last error: ${errorMessage}`,
+        reason: "maxRetriesExceeded",
+        errors: newErrors
+      });
+    }
+    if (error instanceof Error) {
+      if (error.name === "AbortError") {
+        throw error;
+      }
+      if (
+        // deal with bundling duplication by using names
+        APICallError.isAPICallError(error) && error.isRetryable === true && tryNumber <= maxRetries
+      ) {
+        await delay(delayInMs);
+        return _retryWithExponentialBackoff(
+          f,
+          { maxRetries, delayInMs: backoffFactor * delayInMs, backoffFactor },
+          newErrors
+        );
+      }
+    }
+    if (tryNumber === 1) {
+      throw error;
+    }
+    throw new RetryError({
+      message: `Failed after ${tryNumber} attemps with non-retryable error: '${errorMessage}'`,
+      reason: "errorNotRetryable",
+      errors: newErrors
+    });
+  }
 }
 
 // core/generate-object/inject-json-schema-into-system.ts
@@ -446,69 +681,89 @@ async function generateObject({
   system,
   prompt,
   messages,
+  maxRetries,
+  abortSignal,
   ...settings
 }) {
   var _a, _b;
+  const retry = retryWithExponentialBackoff({ maxRetries });
   const jsonSchema = (0, import_zod_to_json_schema.default)(schema);
   if (mode === "auto" || mode == null) {
     mode = model.defaultObjectGenerationMode;
   }
   let result;
+  let finishReason;
+  let usage;
   switch (mode) {
     case "json": {
-      const generateResult = await model.doGenerate({
-        mode: { type: "object-json" },
-        ...validateCallSettings(settings),
-        inputFormat: getInputFormat({ prompt, messages }),
-        prompt: convertToLanguageModelPrompt({
-          system: injectJsonSchemaIntoSystem({ system, schema: jsonSchema }),
-          prompt,
-          messages
+      const generateResult = await retry(
+        () => model.doGenerate({
+          mode: { type: "object-json" },
+          ...prepareCallSettings(settings),
+          inputFormat: getInputFormat({ prompt, messages }),
+          prompt: convertToLanguageModelPrompt({
+            system: injectJsonSchemaIntoSystem({ system, schema: jsonSchema }),
+            prompt,
+            messages
+          }),
+          abortSignal
         })
-      });
+      );
       if (generateResult.text === void 0) {
         throw new NoTextGeneratedError();
       }
       result = generateResult.text;
+      finishReason = generateResult.finishReason;
+      usage = generateResult.usage;
       break;
     }
     case "grammar": {
-      const generateResult = await model.doGenerate({
-        mode: { type: "object-grammar", schema: jsonSchema },
-        ...settings,
-        inputFormat: getInputFormat({ prompt, messages }),
-        prompt: convertToLanguageModelPrompt({
-          system: injectJsonSchemaIntoSystem({ system, schema: jsonSchema }),
-          prompt,
-          messages
+      const generateResult = await retry(
+        () => model.doGenerate({
+          mode: { type: "object-grammar", schema: jsonSchema },
+          ...settings,
+          inputFormat: getInputFormat({ prompt, messages }),
+          prompt: convertToLanguageModelPrompt({
+            system: injectJsonSchemaIntoSystem({ system, schema: jsonSchema }),
+            prompt,
+            messages
+          }),
+          abortSignal
         })
-      });
+      );
       if (generateResult.text === void 0) {
         throw new NoTextGeneratedError();
       }
       result = generateResult.text;
+      finishReason = generateResult.finishReason;
+      usage = generateResult.usage;
       break;
     }
     case "tool": {
-      const generateResult = await model.doGenerate({
-        mode: {
-          type: "object-tool",
-          tool: {
-            type: "function",
-            name: "json",
-            description: "Respond with a JSON object.",
-            parameters: jsonSchema
-          }
-        },
-        ...settings,
-        inputFormat: getInputFormat({ prompt, messages }),
-        prompt: convertToLanguageModelPrompt({ system, prompt, messages })
-      });
+      const generateResult = await retry(
+        () => model.doGenerate({
+          mode: {
+            type: "object-tool",
+            tool: {
+              type: "function",
+              name: "json",
+              description: "Respond with a JSON object.",
+              parameters: jsonSchema
+            }
+          },
+          ...settings,
+          inputFormat: getInputFormat({ prompt, messages }),
+          prompt: convertToLanguageModelPrompt({ system, prompt, messages }),
+          abortSignal
+        })
+      );
       const functionArgs = (_b = (_a = generateResult.toolCalls) == null ? void 0 : _a[0]) == null ? void 0 : _b.args;
       if (functionArgs === void 0) {
         throw new NoTextGeneratedError();
       }
       result = functionArgs;
+      finishReason = generateResult.finishReason;
+      usage = generateResult.usage;
       break;
     }
     case void 0: {
@@ -524,18 +779,39 @@ async function generateObject({
     throw parseResult.error;
   }
   return new GenerateObjectResult({
-    object: parseResult.value
+    object: parseResult.value,
+    finishReason,
+    usage: calculateTokenUsage(usage)
   });
 }
 var GenerateObjectResult = class {
   constructor(options) {
     this.object = options.object;
+    this.finishReason = options.finishReason;
+    this.usage = options.usage;
   }
 };
 
 // core/generate-object/stream-object.ts
 var import_zod_to_json_schema2 = __toESM(require("zod-to-json-schema"));
 
+// core/util/async-iterable-stream.ts
+function createAsyncIterableStream(source, transformer) {
+  const transformedStream = source.pipeThrough(
+    new TransformStream(transformer)
+  );
+  transformedStream[Symbol.asyncIterator] = () => {
+    const reader = transformedStream.getReader();
+    return {
+      async next() {
+        const { done, value } = await reader.read();
+        return done ? { done: true, value: void 0 } : { done: false, value };
+      }
+    };
+  };
+  return transformedStream;
+}
+
 // core/util/is-deep-equal-data.ts
 function isDeepEqualData(obj1, obj2) {
   if (obj1 === obj2)
@@ -916,43 +1192,46 @@ async function streamObject({
   system,
   prompt,
   messages,
+  maxRetries,
+  abortSignal,
   ...settings
 }) {
+  const retry = retryWithExponentialBackoff({ maxRetries });
   const jsonSchema = (0, import_zod_to_json_schema2.default)(schema);
-  let modelStream;
   if (mode === "auto" || mode == null) {
     mode = model.defaultObjectGenerationMode;
   }
+  let callOptions;
+  let transformer;
   switch (mode) {
     case "json": {
-      const { stream, warnings } = await model.doStream({
+      callOptions = {
         mode: { type: "object-json" },
-        ...validateCallSettings(settings),
+        ...prepareCallSettings(settings),
         inputFormat: getInputFormat({ prompt, messages }),
         prompt: convertToLanguageModelPrompt({
           system: injectJsonSchemaIntoSystem({ system, schema: jsonSchema }),
           prompt,
           messages
-        })
-      });
-      modelStream = stream.pipeThrough(
-        new TransformStream({
-          transform(chunk, controller) {
-            switch (chunk.type) {
-              case "text-delta":
-                controller.enqueue(chunk.textDelta);
-                break;
-              case "error":
-                controller.enqueue(chunk);
-                break;
-            }
+        }),
+        abortSignal
+      };
+      transformer = {
+        transform: (chunk, controller) => {
+          switch (chunk.type) {
+            case "text-delta":
+              controller.enqueue(chunk.textDelta);
+              break;
+            case "error":
+              controller.enqueue(chunk);
+              break;
           }
-        })
-      );
+        }
+      };
       break;
     }
     case "grammar": {
-      const { stream, warnings } = await model.doStream({
+      callOptions = {
         mode: { type: "object-grammar", schema: jsonSchema },
         ...settings,
         inputFormat: getInputFormat({ prompt, messages }),
@@ -960,26 +1239,25 @@ async function streamObject({
           system: injectJsonSchemaIntoSystem({ system, schema: jsonSchema }),
           prompt,
           messages
-        })
-      });
-      modelStream = stream.pipeThrough(
-        new TransformStream({
-          transform(chunk, controller) {
-            switch (chunk.type) {
-              case "text-delta":
-                controller.enqueue(chunk.textDelta);
-                break;
-              case "error":
-                controller.enqueue(chunk);
-                break;
-            }
+        }),
+        abortSignal
+      };
+      transformer = {
+        transform: (chunk, controller) => {
+          switch (chunk.type) {
+            case "text-delta":
+              controller.enqueue(chunk.textDelta);
+              break;
+            case "error":
+              controller.enqueue(chunk);
+              break;
           }
-        })
-      );
+        }
+      };
       break;
     }
     case "tool": {
-      const { stream, warnings } = await model.doStream({
+      callOptions = {
         mode: {
           type: "object-tool",
           tool: {
@@ -991,22 +1269,21 @@ async function streamObject({
         },
         ...settings,
         inputFormat: getInputFormat({ prompt, messages }),
-        prompt: convertToLanguageModelPrompt({ system, prompt, messages })
-      });
-      modelStream = stream.pipeThrough(
-        new TransformStream({
-          transform(chunk, controller) {
-            switch (chunk.type) {
-              case "tool-call-delta":
-                controller.enqueue(chunk.argsTextDelta);
-                break;
-              case "error":
-                controller.enqueue(chunk);
-                break;
-            }
+        prompt: convertToLanguageModelPrompt({ system, prompt, messages }),
+        abortSignal
+      };
+      transformer = {
+        transform(chunk, controller) {
+          switch (chunk.type) {
+            case "tool-call-delta":
+              controller.enqueue(chunk.argsTextDelta);
+              break;
+            case "error":
+              controller.enqueue(chunk);
+              break;
           }
-        })
-      );
+        }
+      };
       break;
     }
     case void 0: {
@@ -1017,37 +1294,35 @@ async function streamObject({
       throw new Error(`Unsupported mode: ${_exhaustiveCheck}`);
     }
   }
-  return new StreamObjectResult(modelStream);
+  const { stream, warnings } = await retry(() => model.doStream(callOptions));
+  return new StreamObjectResult(
+    stream.pipeThrough(new TransformStream(transformer))
+  );
 }
 var StreamObjectResult = class {
-  constructor(modelStream) {
+  constructor(stream) {
+    this.originalStream = stream;
+  }
+  get objectStream() {
     let accumulatedText = "";
     let latestObject = void 0;
-    this.objectStream = {
-      [Symbol.asyncIterator]() {
-        const reader = modelStream.getReader();
-        return {
-          next: async () => {
-            while (true) {
-              const { done, value } = await reader.read();
-              if (done) {
-                return { value: null, done: true };
-              }
-              if (typeof value === "string") {
-                accumulatedText += value;
-                const currentObject = parsePartialJson(
-                  accumulatedText
-                );
-                if (!isDeepEqualData(latestObject, currentObject)) {
-                  latestObject = currentObject;
-                  return { value: currentObject, done: false };
-                }
-              }
-            }
+    return createAsyncIterableStream(this.originalStream, {
+      transform(chunk, controller) {
+        if (typeof chunk === "string") {
+          accumulatedText += chunk;
+          const currentObject = parsePartialJson(
+            accumulatedText
+          );
+          if (!isDeepEqualData(latestObject, currentObject)) {
+            latestObject = currentObject;
+            controller.enqueue(currentObject);
           }
-        };
+        }
+        if (typeof chunk === "object" && chunk.type === "error") {
+          throw chunk.error;
+        }
       }
-    };
+    });
   }
 };
 
@@ -1061,26 +1336,33 @@ function parseToolCall({
 }) {
   const toolName = toolCall.toolName;
   if (tools == null) {
-    throw new Error(`Tool not found: ${toolName}`);
+    throw new NoSuchToolError({
+      message: `Tool ${toolCall.toolName} not found (no tools provided).`,
+      toolName: toolCall.toolName
+    });
   }
   const tool2 = tools[toolName];
   if (tool2 == null) {
-    throw new Error(`Tool not found: ${toolName}`);
+    throw new NoSuchToolError({
+      message: `Tool ${toolCall.toolName} not found.`,
+      toolName: toolCall.toolName
+    });
   }
   const parseResult = safeParseJSON({
     text: toolCall.args,
     schema: tool2.parameters
   });
   if (parseResult.success === false) {
-    throw new Error(
-      `Tool call ${toolName} has invalid arguments: ${parseResult.error}`
-    );
+    throw new InvalidToolArgumentsError({
+      toolName,
+      toolArgs: toolCall.args,
+      cause: parseResult.error
+    });
   }
-  const toolArgs = parseResult.value;
   return {
     toolCallId: toolCall.toolCallId,
     toolName,
-    args: toolArgs
+    args: parseResult.value
   };
 }
 
@@ -1091,27 +1373,33 @@ async function generateText({
   system,
   prompt,
   messages,
+  maxRetries,
+  abortSignal,
   ...settings
 }) {
   var _a, _b;
-  const modelResponse = await model.doGenerate({
-    mode: {
-      type: "regular",
-      tools: tools == null ? void 0 : Object.entries(tools).map(([name, tool2]) => ({
-        type: "function",
-        name,
-        description: tool2.description,
-        parameters: (0, import_zod_to_json_schema3.default)(tool2.parameters)
-      }))
-    },
-    ...validateCallSettings(settings),
-    inputFormat: getInputFormat({ prompt, messages }),
-    prompt: convertToLanguageModelPrompt({
-      system,
-      prompt,
-      messages
+  const retry = retryWithExponentialBackoff({ maxRetries });
+  const modelResponse = await retry(
+    () => model.doGenerate({
+      mode: {
+        type: "regular",
+        tools: tools == null ? void 0 : Object.entries(tools).map(([name, tool2]) => ({
+          type: "function",
+          name,
+          description: tool2.description,
+          parameters: (0, import_zod_to_json_schema3.default)(tool2.parameters)
+        }))
+      },
+      ...prepareCallSettings(settings),
+      inputFormat: getInputFormat({ prompt, messages }),
+      prompt: convertToLanguageModelPrompt({
+        system,
+        prompt,
+        messages
+      }),
+      abortSignal
     })
-  });
+  );
   const toolCalls = [];
   for (const modelToolCall of (_a = modelResponse.toolCalls) != null ? _a : []) {
     toolCalls.push(parseToolCall({ toolCall: modelToolCall, tools }));
@@ -1123,7 +1411,9 @@ async function generateText({
     // they can check the length of the string:
     text: (_b = modelResponse.text) != null ? _b : "",
     toolCalls,
-    toolResults
+    toolResults,
+    finishReason: modelResponse.finishReason,
+    usage: calculateTokenUsage(modelResponse.usage)
   });
 }
 async function executeTools({
@@ -1154,131 +1444,14 @@ var GenerateTextResult = class {
     this.text = options.text;
     this.toolCalls = options.toolCalls;
     this.toolResults = options.toolResults;
+    this.finishReason = options.finishReason;
+    this.usage = options.usage;
   }
 };
 
 // core/generate-text/stream-text.ts
 var import_zod_to_json_schema4 = __toESM(require("zod-to-json-schema"));
 
-// core/generate-text/run-tools-transformation.ts
-var import_nanoid = require("nanoid");
-function runToolsTransformation({
-  tools,
-  generatorStream
-}) {
-  let canClose = false;
-  const outstandingToolCalls = /* @__PURE__ */ new Set();
-  let toolResultsStreamController = null;
-  const toolResultsStream = new ReadableStream({
-    start(controller) {
-      toolResultsStreamController = controller;
-    }
-  });
-  const forwardStream = new TransformStream({
-    transform(chunk, controller) {
-      const chunkType = chunk.type;
-      switch (chunkType) {
-        case "text-delta":
-        case "error": {
-          controller.enqueue(chunk);
-          break;
-        }
-        case "tool-call": {
-          const toolName = chunk.toolName;
-          if (tools == null) {
-            toolResultsStreamController.enqueue({
-              type: "error",
-              error: `Tool ${chunk.toolName} not found (no tools provided)`
-            });
-            break;
-          }
-          const tool2 = tools[toolName];
-          if (tool2 == null) {
-            toolResultsStreamController.enqueue({
-              type: "error",
-              error: `Tool ${chunk.toolName} not found`
-            });
-            break;
-          }
-          const toolCall = parseToolCall({
-            toolCall: chunk,
-            tools
-          });
-          controller.enqueue({
-            type: "tool-call",
-            ...toolCall
-          });
-          if (tool2.execute != null) {
-            const toolExecutionId = (0, import_nanoid.nanoid)();
-            outstandingToolCalls.add(toolExecutionId);
-            tool2.execute(toolCall.args).then(
-              (result) => {
-                toolResultsStreamController.enqueue({
-                  type: "tool-result",
-                  ...toolCall,
-                  result
-                });
-                outstandingToolCalls.delete(toolExecutionId);
-                if (canClose && outstandingToolCalls.size === 0) {
-                  toolResultsStreamController.close();
-                }
-              },
-              (error) => {
-                toolResultsStreamController.enqueue({
-                  type: "error",
-                  error
-                });
-                outstandingToolCalls.delete(toolExecutionId);
-                if (canClose && outstandingToolCalls.size === 0) {
-                  toolResultsStreamController.close();
-                }
-              }
-            );
-          }
-          break;
-        }
-        case "finish-metadata":
-        case "tool-call-delta": {
-          break;
-        }
-        default: {
-          const _exhaustiveCheck = chunkType;
-          throw new Error(`Unhandled chunk type: ${_exhaustiveCheck}`);
-        }
-      }
-    },
-    flush() {
-      canClose = true;
-      if (outstandingToolCalls.size === 0) {
-        toolResultsStreamController.close();
-      }
-    }
-  });
-  return new ReadableStream({
-    async start(controller) {
-      generatorStream.pipeThrough(forwardStream).pipeTo(
-        new WritableStream({
-          write(chunk) {
-            controller.enqueue(chunk);
-          },
-          close() {
-          }
-        })
-      );
-      toolResultsStream.pipeTo(
-        new WritableStream({
-          write(chunk) {
-            controller.enqueue(chunk);
-          },
-          close() {
-            controller.close();
-          }
-        })
-      );
-    }
-  });
-}
-
 // shared/stream-parts.ts
 var textStreamPart = {
   code: "0",
@@ -1445,71 +1618,208 @@ function formatStreamPart(type, value) {
 `;
 }
 
-// shared/utils.ts
-var import_non_secure = require("nanoid/non-secure");
-var nanoid2 = (0, import_non_secure.customAlphabet)(
-  "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
-  7
-);
-var COMPLEX_HEADER = "X-Experimental-Stream-Data";
+// streams/ai-stream.ts
+var import_eventsource_parser = require("eventsource-parser");
+function createCallbacksTransformer(cb) {
+  const textEncoder = new TextEncoder();
+  let aggregatedResponse = "";
+  const callbacks = cb || {};
+  return new TransformStream({
+    async start() {
+      if (callbacks.onStart)
+        await callbacks.onStart();
+    },
+    async transform(message, controller) {
+      const content = typeof message === "string" ? message : message.content;
+      controller.enqueue(textEncoder.encode(content));
+      aggregatedResponse += content;
+      if (callbacks.onToken)
+        await callbacks.onToken(content);
+      if (callbacks.onText && typeof message === "string") {
+        await callbacks.onText(message);
+      }
+    },
+    async flush() {
+      const isOpenAICallbacks = isOfTypeOpenAIStreamCallbacks(callbacks);
+      if (callbacks.onCompletion) {
+        await callbacks.onCompletion(aggregatedResponse);
+      }
+      if (callbacks.onFinal && !isOpenAICallbacks) {
+        await callbacks.onFinal(aggregatedResponse);
+      }
+    }
+  });
+}
+function isOfTypeOpenAIStreamCallbacks(callbacks) {
+  return "experimental_onFunctionCall" in callbacks;
+}
+function readableFromAsyncIterable(iterable) {
+  let it = iterable[Symbol.asyncIterator]();
+  return new ReadableStream({
+    async pull(controller) {
+      const { done, value } = await it.next();
+      if (done)
+        controller.close();
+      else
+        controller.enqueue(value);
+    },
+    async cancel(reason) {
+      var _a;
+      await ((_a = it.return) == null ? void 0 : _a.call(it, reason));
+    }
+  });
+}
+
+// streams/stream-data.ts
+function createStreamDataTransformer(experimental_streamData) {
+  if (!experimental_streamData) {
+    return new TransformStream({
+      transform: async (chunk, controller) => {
+        controller.enqueue(chunk);
+      }
+    });
+  }
+  const encoder = new TextEncoder();
+  const decoder = new TextDecoder();
+  return new TransformStream({
+    transform: async (chunk, controller) => {
+      const message = decoder.decode(chunk);
+      controller.enqueue(encoder.encode(formatStreamPart("text", message)));
+    }
+  });
+}
 
-// core/generate-text/stream-text-http-response.ts
-var StreamTextHttpResponse = class extends Response {
-  constructor(messageStream) {
-    super(
-      messageStream.pipeThrough(
-        new TransformStream({
-          transform(chunk, controller) {
-            var _a;
-            switch (chunk.type) {
-              case "error": {
-                break;
-              }
-              case "text-delta": {
-                controller.enqueue(formatStreamPart("text", chunk.textDelta));
-                break;
-              }
-              case "tool-call": {
-                controller.enqueue(
-                  formatStreamPart("tool_calls", {
-                    tool_calls: [
-                      {
-                        type: "function",
-                        id: (_a = chunk.toolCallId) != null ? _a : "",
-                        // TODO client need to support null id
-                        function: {
-                          name: chunk.toolName,
-                          arguments: JSON.stringify(chunk.args)
-                        }
-                      }
-                    ]
-                  })
-                );
-                break;
-              }
-              case "tool-result": {
-                break;
-              }
-              default: {
-                const exhaustiveCheck = chunk;
-                throw new Error(
-                  `Unhandled stream part type: ${exhaustiveCheck}`
-                );
-              }
+// core/generate-text/run-tools-transformation.ts
+var import_nanoid = require("nanoid");
+function runToolsTransformation({
+  tools,
+  generatorStream
+}) {
+  let canClose = false;
+  const outstandingToolCalls = /* @__PURE__ */ new Set();
+  let toolResultsStreamController = null;
+  const toolResultsStream = new ReadableStream({
+    start(controller) {
+      toolResultsStreamController = controller;
+    }
+  });
+  const forwardStream = new TransformStream({
+    transform(chunk, controller) {
+      const chunkType = chunk.type;
+      switch (chunkType) {
+        case "text-delta":
+        case "error": {
+          controller.enqueue(chunk);
+          break;
+        }
+        case "tool-call": {
+          const toolName = chunk.toolName;
+          if (tools == null) {
+            toolResultsStreamController.enqueue({
+              type: "error",
+              error: new NoSuchToolError({
+                message: `Tool ${chunk.toolName} not found (no tools provided).`,
+                toolName: chunk.toolName
+              })
+            });
+            break;
+          }
+          const tool2 = tools[toolName];
+          if (tool2 == null) {
+            toolResultsStreamController.enqueue({
+              type: "error",
+              error: new NoSuchToolError({
+                message: `Tool ${chunk.toolName} not found.`,
+                toolName: chunk.toolName
+              })
+            });
+            break;
+          }
+          try {
+            const toolCall = parseToolCall({
+              toolCall: chunk,
+              tools
+            });
+            controller.enqueue({
+              type: "tool-call",
+              ...toolCall
+            });
+            if (tool2.execute != null) {
+              const toolExecutionId = (0, import_nanoid.nanoid)();
+              outstandingToolCalls.add(toolExecutionId);
+              tool2.execute(toolCall.args).then(
+                (result) => {
+                  toolResultsStreamController.enqueue({
+                    type: "tool-result",
+                    ...toolCall,
+                    result
+                  });
+                  outstandingToolCalls.delete(toolExecutionId);
+                  if (canClose && outstandingToolCalls.size === 0) {
+                    toolResultsStreamController.close();
+                  }
+                },
+                (error) => {
+                  toolResultsStreamController.enqueue({
+                    type: "error",
+                    error
+                  });
+                  outstandingToolCalls.delete(toolExecutionId);
+                  if (canClose && outstandingToolCalls.size === 0) {
+                    toolResultsStreamController.close();
+                  }
+                }
+              );
             }
+          } catch (error) {
+            toolResultsStreamController.enqueue({
+              type: "error",
+              error
+            });
           }
-        })
-      ),
-      {
-        status: 200,
-        headers: {
-          "Content-Type": "text/plain; charset=utf-8",
-          [COMPLEX_HEADER]: "true"
+          break;
+        }
+        case "finish-metadata":
+        case "tool-call-delta": {
+          break;
+        }
+        default: {
+          const _exhaustiveCheck = chunkType;
+          throw new Error(`Unhandled chunk type: ${_exhaustiveCheck}`);
         }
       }
-    );
-  }
-};
+    },
+    flush() {
+      canClose = true;
+      if (outstandingToolCalls.size === 0) {
+        toolResultsStreamController.close();
+      }
+    }
+  });
+  return new ReadableStream({
+    async start(controller) {
+      generatorStream.pipeThrough(forwardStream).pipeTo(
+        new WritableStream({
+          write(chunk) {
+            controller.enqueue(chunk);
+          },
+          close() {
+          }
+        })
+      );
+      toolResultsStream.pipeTo(
+        new WritableStream({
+          write(chunk) {
+            controller.enqueue(chunk);
+          },
+          close() {
+            controller.close();
+          }
+        })
+      );
+    }
+  });
+}
 
 // core/generate-text/stream-text.ts
 async function streamText({
@@ -1518,26 +1828,32 @@ async function streamText({
   system,
   prompt,
   messages,
+  maxRetries,
+  abortSignal,
   ...settings
 }) {
-  const { stream, warnings } = await model.doStream({
-    mode: {
-      type: "regular",
-      tools: tools == null ? void 0 : Object.entries(tools).map(([name, tool2]) => ({
-        type: "function",
-        name,
-        description: tool2.description,
-        parameters: (0, import_zod_to_json_schema4.default)(tool2.parameters)
-      }))
-    },
-    ...validateCallSettings(settings),
-    inputFormat: getInputFormat({ prompt, messages }),
-    prompt: convertToLanguageModelPrompt({
-      system,
-      prompt,
-      messages
+  const retry = retryWithExponentialBackoff({ maxRetries });
+  const { stream, warnings } = await retry(
+    () => model.doStream({
+      mode: {
+        type: "regular",
+        tools: tools == null ? void 0 : Object.entries(tools).map(([name, tool2]) => ({
+          type: "function",
+          name,
+          description: tool2.description,
+          parameters: (0, import_zod_to_json_schema4.default)(tool2.parameters)
+        }))
+      },
+      ...prepareCallSettings(settings),
+      inputFormat: getInputFormat({ prompt, messages }),
+      prompt: convertToLanguageModelPrompt({
+        system,
+        prompt,
+        messages
+      }),
+      abortSignal
     })
-  });
+  );
   const toolStream = runToolsTransformation({
     tools,
     generatorStream: stream
@@ -1546,55 +1862,38 @@ async function streamText({
 }
 var StreamTextResult = class {
   constructor(stream) {
-    this.rootStream = stream;
-    this.textStream = {
-      [Symbol.asyncIterator]() {
-        const reader = stream.getReader();
-        return {
-          next: async () => {
-            while (true) {
-              const { done, value } = await reader.read();
-              if (done) {
-                return { value: null, done: true };
-              }
-              if (value.type === "text-delta") {
-                if (value.textDelta.length > 0) {
-                  return { value: value.textDelta, done: false };
-                }
-              }
-              if (value.type === "error") {
-                console.error("Error:", value.error);
-              }
-            }
+    this.originalStream = stream;
+  }
+  get textStream() {
+    return createAsyncIterableStream(this.originalStream, {
+      transform(chunk, controller) {
+        if (chunk.type === "text-delta") {
+          if (chunk.textDelta.length > 0) {
+            controller.enqueue(chunk.textDelta);
           }
-        };
+        } else if (chunk.type === "error") {
+          throw chunk.error;
+        }
       }
-    };
-    this.fullStream = {
-      [Symbol.asyncIterator]() {
-        const reader = stream.getReader();
-        return {
-          next: async () => {
-            while (true) {
-              const { done, value } = await reader.read();
-              if (done) {
-                return { value: null, done: true };
-              }
-              if (value.type === "text-delta") {
-                if (value.textDelta.length > 0) {
-                  return { value, done: false };
-                }
-              } else {
-                return { value, done: false };
-              }
-            }
+    });
+  }
+  get fullStream() {
+    return createAsyncIterableStream(this.originalStream, {
+      transform(chunk, controller) {
+        if (chunk.type === "text-delta") {
+          if (chunk.textDelta.length > 0) {
+            controller.enqueue(chunk);
           }
-        };
+        } else {
+          controller.enqueue(chunk);
+        }
       }
-    };
+    });
   }
-  toResponse() {
-    return new StreamTextHttpResponse(this.rootStream);
+  toAIStream(callbacks) {
+    return readableFromAsyncIterable(this.textStream).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(
+      createStreamDataTransformer(callbacks == null ? void 0 : callbacks.experimental_streamData)
+    );
   }
 };
 
@@ -1607,7 +1906,6 @@ function tool(tool2) {
   GenerateObjectResult,
   GenerateTextResult,
   StreamObjectResult,
-  StreamTextHttpResponse,
   StreamTextResult,
   convertDataContentToBase64String,
   convertDataContentToUint8Array,