ai 3.1.0-canary.1 → 3.1.0-canary.3

package/core/dist/index.mjs

@@ -1,4 +1,183 @@
-// core/util/uint8-utils.ts
+// core/generate-object/generate-object.ts
+import zodToJsonSchema from "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';
+  constructor({
+    parameter,
+    value,
+    message
+  }) {
+    super(`Invalid argument for parameter ${parameter}: ${message}`);
+    this.name = "AI_InvalidArgumentError";
+    this.parameter = parameter;
+    this.value = value;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      stack: this.stack,
+      parameter: this.parameter,
+      value: this.value
+    };
+  }
+};
+
+// ai-model-specification/util/get-error-message.ts
+function getErrorMessage(error) {
+  if (error == null) {
+    return "unknown error";
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return JSON.stringify(error);
+}
+
+// ai-model-specification/errors/json-parse-error.ts
+var JSONParseError = class extends Error {
+  constructor({ text, cause }) {
+    super(
+      `JSON parsing failed: Text: ${text}.
+Error message: ${getErrorMessage(cause)}`
+    );
+    this.name = "JSONParseError";
+    this.cause = cause;
+    this.text = text;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      cause: this.cause,
+      stack: this.stack,
+      valueText: this.text
+    };
+  }
+};
+
+// 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/retry-error.ts
+var RetryError = class extends Error {
+  constructor({
+    message,
+    reason,
+    errors
+  }) {
+    super(message);
+    this.name = "RetryError";
+    this.reason = reason;
+    this.errors = errors;
+    this.lastError = errors[errors.length - 1];
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      reason: this.reason,
+      lastError: this.lastError,
+      errors: this.errors
+    };
+  }
+};
+
+// ai-model-specification/errors/type-validation-error.ts
+var TypeValidationError = class extends Error {
+  constructor({ value, cause }) {
+    super(
+      `Type validation failed: Value: ${JSON.stringify(value)}.
+Error message: ${getErrorMessage(cause)}`
+    );
+    this.name = "TypeValidationError";
+    this.cause = cause;
+    this.value = value;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      cause: this.cause,
+      stack: this.stack,
+      value: this.value
+    };
+  }
+};
+
+// ai-model-specification/util/parse-json.ts
+import SecureJSON from "secure-json-parse";
+
+// ai-model-specification/util/validate-types.ts
+function safeValidateTypes({
+  value,
+  schema
+}) {
+  try {
+    const validationResult = schema.safeParse(value);
+    if (validationResult.success) {
+      return {
+        success: true,
+        value: validationResult.data
+      };
+    }
+    return {
+      success: false,
+      error: new TypeValidationError({
+        value,
+        cause: validationResult.error
+      })
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof TypeValidationError ? error : new TypeValidationError({ value, cause: error })
+    };
+  }
+}
+
+// ai-model-specification/util/parse-json.ts
+function safeParseJSON({
+  text,
+  schema
+}) {
+  try {
+    const value = SecureJSON.parse(text);
+    if (schema == null) {
+      return {
+        success: true,
+        value
+      };
+    }
+    return safeValidateTypes({ value, schema });
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof JSONParseError ? error : new JSONParseError({ text, cause: error })
+    };
+  }
+}
+
+// ai-model-specification/util/uint8-utils.ts
 function convertBase64ToUint8Array(base64String) {
   const base64Url = base64String.replace(/-/g, "+").replace(/_/g, "/");
   const latin1string = globalThis.atob(base64Url);
@@ -12,6 +191,15 @@ function convertUint8ArrayToBase64(array) {
   return globalThis.btoa(latin1string);
 }
 
+// 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") {
@@ -81,7 +269,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
                       };
                     }
@@ -123,129 +311,160 @@ function getInputFormat({
   return prompt != null ? "prompt" : "messages";
 }
 
-// core/schema/parse-json.ts
-import SecureJSON from "secure-json-parse";
-
-// core/language-model/errors/get-error-message.ts
-function getErrorMessage(error) {
-  if (error == null) {
-    return "unknown error";
-  }
-  if (typeof error === "string") {
-    return error;
-  }
-  if (error instanceof Error) {
-    return error.message;
+// core/prompt/validate-call-settings.ts
+function validateCallSettings(settings) {
+  if (settings.maxTokens != null) {
+    if (!Number.isInteger(settings.maxTokens)) {
+      throw new AI_InvalidArgumentError({
+        parameter: "maxTokens",
+        value: settings.maxTokens,
+        message: "maxTokens must be an integer"
+      });
+    }
+    if (settings.maxTokens < 1) {
+      throw new AI_InvalidArgumentError({
+        parameter: "maxTokens",
+        value: settings.maxTokens,
+        message: "maxTokens must be >= 1"
+      });
+    }
   }
-  return JSON.stringify(error);
-}
-
-// core/language-model/errors/json-parse-error.ts
-var JSONParseError = class extends Error {
-  constructor({ text, cause }) {
-    super(
-      `JSON parsing failed: Text: ${text}.
-Error message: ${getErrorMessage(cause)}`
-    );
-    this.name = "JSONParseError";
-    this.cause = cause;
-    this.text = text;
+  if (settings.temperature != null) {
+    if (typeof settings.temperature !== "number") {
+      throw new AI_InvalidArgumentError({
+        parameter: "temperature",
+        value: settings.temperature,
+        message: "temperature must be a number"
+      });
+    }
+    if (settings.temperature < 0 || settings.temperature > 1) {
+      throw new AI_InvalidArgumentError({
+        parameter: "temperature",
+        value: settings.temperature,
+        message: "temperature must be between 0 and 1 (inclusive)"
+      });
+    }
   }
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      cause: this.cause,
-      stack: this.stack,
-      valueText: this.text
-    };
+  if (settings.topP != null) {
+    if (typeof settings.topP !== "number") {
+      throw new AI_InvalidArgumentError({
+        parameter: "topP",
+        value: settings.topP,
+        message: "topP must be a number"
+      });
+    }
+    if (settings.topP < 0 || settings.topP > 1) {
+      throw new AI_InvalidArgumentError({
+        parameter: "topP",
+        value: settings.topP,
+        message: "topP must be between 0 and 1 (inclusive)"
+      });
+    }
   }
-};
-
-// core/language-model/errors/type-validation-error.ts
-var TypeValidationError = class extends Error {
-  constructor({ value, cause }) {
-    super(
-      `Type validation failed: Value: ${JSON.stringify(value)}.
-Error message: ${getErrorMessage(cause)}`
-    );
-    this.name = "TypeValidationError";
-    this.cause = cause;
-    this.value = value;
+  if (settings.presencePenalty != null) {
+    if (typeof settings.presencePenalty !== "number") {
+      throw new AI_InvalidArgumentError({
+        parameter: "presencePenalty",
+        value: settings.presencePenalty,
+        message: "presencePenalty must be a number"
+      });
+    }
+    if (settings.presencePenalty < -1 || settings.presencePenalty > 1) {
+      throw new AI_InvalidArgumentError({
+        parameter: "presencePenalty",
+        value: settings.presencePenalty,
+        message: "presencePenalty must be between -1 and 1 (inclusive)"
+      });
+    }
   }
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      cause: this.cause,
-      stack: this.stack,
-      value: this.value
-    };
+  if (settings.frequencyPenalty != null) {
+    if (typeof settings.frequencyPenalty !== "number") {
+      throw new AI_InvalidArgumentError({
+        parameter: "frequencyPenalty",
+        value: settings.frequencyPenalty,
+        message: "frequencyPenalty must be a number"
+      });
+    }
+    if (settings.frequencyPenalty < -1 || settings.frequencyPenalty > 1) {
+      throw new AI_InvalidArgumentError({
+        parameter: "frequencyPenalty",
+        value: settings.frequencyPenalty,
+        message: "frequencyPenalty must be between -1 and 1 (inclusive)"
+      });
+    }
   }
-};
-
-// core/schema/validate-types.ts
-function safeValidateTypes({
-  value,
-  schema
-}) {
-  try {
-    const validationResult = schema.validate(value);
-    if (validationResult.success) {
-      return validationResult;
+  if (settings.seed != null) {
+    if (!Number.isInteger(settings.seed)) {
+      throw new AI_InvalidArgumentError({
+        parameter: "seed",
+        value: settings.seed,
+        message: "seed must be an integer"
+      });
     }
-    return {
-      success: false,
-      error: new TypeValidationError({
-        value,
-        cause: validationResult.error
-      })
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof TypeValidationError ? error : new TypeValidationError({ value, cause: error })
-    };
   }
+  return settings;
 }
 
-// core/schema/parse-json.ts
-function safeParseJSON({
-  text,
-  schema
-}) {
+// 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 {
-    const value = SecureJSON.parse(text);
-    if (schema == null) {
-      return {
-        success: true,
-        value
-      };
-    }
-    return safeValidateTypes({ value, schema });
+    return await f();
   } catch (error) {
-    return {
-      success: false,
-      error: error instanceof JSONParseError ? error : new JSONParseError({ text, cause: 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} tries. 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
+        error.name === "ApiCallError" && error.isRetryable === true && tryNumber <= maxRetries
+      ) {
+        await delay(delayInMs);
+        return _retryWithExponentialBackoff(
+          f,
+          { maxRetries, delayInMs: backoffFactor * delayInMs, backoffFactor },
+          newErrors
+        );
+      }
+    }
+    throw new RetryError({
+      message: `Failed after ${tryNumber} tries with non-retryable error: '${errorMessage}'`,
+      reason: "errorNotRetryable",
+      errors: newErrors
+    });
   }
 }
 
-// core/schema/zod-schema.ts
-import { zodToJsonSchema } from "zod-to-json-schema";
-var ZodSchema = class {
-  constructor(zodSchema) {
-    this.zodSchema = zodSchema;
-  }
-  validate(value) {
-    const result = this.zodSchema.safeParse(value);
-    return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
-  }
-  getJsonSchema() {
-    return zodToJsonSchema(this.zodSchema);
-  }
-};
-
 // core/generate-object/inject-json-schema-into-system.ts
 var DEFAULT_SCHEMA_PREFIX = "JSON schema:";
 var DEFAULT_SCHEMA_SUFFIX = "You MUST answer with a JSON object that matches the JSON schema above.";
@@ -265,94 +484,97 @@ function injectJsonSchemaIntoSystem({
   ].filter((line) => line != null).join("\n");
 }
 
-// core/language-model/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
-    };
-  }
-};
-
 // core/generate-object/generate-object.ts
 async function generateObject({
   model,
-  schema: zodSchema,
+  schema,
   mode,
   system,
   prompt,
   messages,
+  maxRetries,
+  abortSignal,
   ...settings
 }) {
   var _a, _b;
-  const schema = new ZodSchema(zodSchema);
-  const jsonSchema = schema.getJsonSchema();
-  let result;
+  const retry = retryWithExponentialBackoff({ maxRetries });
+  const jsonSchema = zodToJsonSchema(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" },
-        ...settings,
-        inputFormat: getInputFormat({ prompt, messages }),
-        prompt: convertToLanguageModelPrompt({
-          system: injectJsonSchemaIntoSystem({ system, schema: jsonSchema }),
-          prompt,
-          messages
+      const generateResult = await retry(
+        () => model.doGenerate({
+          mode: { type: "object-json" },
+          ...validateCallSettings(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: {
@@ -368,15 +590,22 @@ 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
+import zodToJsonSchema2 from "zod-to-json-schema";
+
 // core/util/is-deep-equal-data.ts
 function isDeepEqualData(obj1, obj2) {
   if (obj1 === obj2)
@@ -752,31 +981,36 @@ function parsePartialJson(jsonText) {
 // core/generate-object/stream-object.ts
 async function streamObject({
   model,
-  schema: zodSchema,
+  schema,
   mode,
   system,
   prompt,
   messages,
+  maxRetries,
+  abortSignal,
   ...settings
 }) {
-  const schema = new ZodSchema(zodSchema);
-  const jsonSchema = schema.getJsonSchema();
+  const retry = retryWithExponentialBackoff({ maxRetries });
+  const jsonSchema = zodToJsonSchema2(schema);
   let modelStream;
   if (mode === "auto" || mode == null) {
     mode = model.defaultObjectGenerationMode;
   }
   switch (mode) {
     case "json": {
-      const { stream, warnings } = await model.doStream({
-        mode: { type: "object-json" },
-        ...settings,
-        inputFormat: getInputFormat({ prompt, messages }),
-        prompt: convertToLanguageModelPrompt({
-          system: injectJsonSchemaIntoSystem({ system, schema: jsonSchema }),
-          prompt,
-          messages
+      const { stream, warnings } = await retry(
+        () => model.doStream({
+          mode: { type: "object-json" },
+          ...validateCallSettings(settings),
+          inputFormat: getInputFormat({ prompt, messages }),
+          prompt: convertToLanguageModelPrompt({
+            system: injectJsonSchemaIntoSystem({ system, schema: jsonSchema }),
+            prompt,
+            messages
+          }),
+          abortSignal
         })
-      });
+      );
       modelStream = stream.pipeThrough(
         new TransformStream({
           transform(chunk, controller) {
@@ -794,16 +1028,19 @@ async function streamObject({
       break;
     }
     case "grammar": {
-      const { stream, warnings } = await model.doStream({
-        mode: { type: "object-grammar", schema: jsonSchema },
-        ...settings,
-        inputFormat: getInputFormat({ prompt, messages }),
-        prompt: convertToLanguageModelPrompt({
-          system: injectJsonSchemaIntoSystem({ system, schema: jsonSchema }),
-          prompt,
-          messages
+      const { stream, warnings } = await retry(
+        () => model.doStream({
+          mode: { type: "object-grammar", schema: jsonSchema },
+          ...settings,
+          inputFormat: getInputFormat({ prompt, messages }),
+          prompt: convertToLanguageModelPrompt({
+            system: injectJsonSchemaIntoSystem({ system, schema: jsonSchema }),
+            prompt,
+            messages
+          }),
+          abortSignal
         })
-      });
+      );
       modelStream = stream.pipeThrough(
         new TransformStream({
           transform(chunk, controller) {
@@ -821,20 +1058,23 @@ async function streamObject({
       break;
     }
     case "tool": {
-      const { stream, warnings } = await model.doStream({
-        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 { stream, warnings } = await retry(
+        () => model.doStream({
+          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
+        })
+      );
       modelStream = stream.pipeThrough(
         new TransformStream({
           transform(chunk, controller) {
@@ -894,7 +1134,7 @@ var StreamObjectResult = class {
 };
 
 // core/generate-text/generate-text.ts
-import zodToJsonSchema2 from "zod-to-json-schema";
+import zodToJsonSchema3 from "zod-to-json-schema";
 
 // core/generate-text/tool-call.ts
 function parseToolCall({
@@ -911,7 +1151,7 @@ function parseToolCall({
   }
   const parseResult = safeParseJSON({
     text: toolCall.args,
-    schema: new ZodSchema(tool2.parameters)
+    schema: tool2.parameters
   });
   if (parseResult.success === false) {
     throw new Error(
@@ -933,27 +1173,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: zodToJsonSchema2(tool2.parameters)
-      }))
-    },
-    ...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: zodToJsonSchema3(tool2.parameters)
+        }))
+      },
+      ...validateCallSettings(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 }));
@@ -965,7 +1211,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({
@@ -996,11 +1244,13 @@ 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
-import zodToJsonSchema3 from "zod-to-json-schema";
+import zodToJsonSchema4 from "zod-to-json-schema";
 
 // core/generate-text/run-tools-transformation.ts
 import { nanoid } from "nanoid";
@@ -1079,6 +1329,7 @@ function runToolsTransformation({
           }
           break;
         }
+        case "finish-metadata":
         case "tool-call-delta": {
           break;
         }
@@ -1120,238 +1371,6 @@ function runToolsTransformation({
   });
 }
 
-// shared/stream-parts.ts
-var textStreamPart = {
-  code: "0",
-  name: "text",
-  parse: (value) => {
-    if (typeof value !== "string") {
-      throw new Error('"text" parts expect a string value.');
-    }
-    return { type: "text", value };
-  }
-};
-var functionCallStreamPart = {
-  code: "1",
-  name: "function_call",
-  parse: (value) => {
-    if (value == null || typeof value !== "object" || !("function_call" in value) || typeof value.function_call !== "object" || value.function_call == null || !("name" in value.function_call) || !("arguments" in value.function_call) || typeof value.function_call.name !== "string" || typeof value.function_call.arguments !== "string") {
-      throw new Error(
-        '"function_call" parts expect an object with a "function_call" property.'
-      );
-    }
-    return {
-      type: "function_call",
-      value
-    };
-  }
-};
-var dataStreamPart = {
-  code: "2",
-  name: "data",
-  parse: (value) => {
-    if (!Array.isArray(value)) {
-      throw new Error('"data" parts expect an array value.');
-    }
-    return { type: "data", value };
-  }
-};
-var errorStreamPart = {
-  code: "3",
-  name: "error",
-  parse: (value) => {
-    if (typeof value !== "string") {
-      throw new Error('"error" parts expect a string value.');
-    }
-    return { type: "error", value };
-  }
-};
-var assistantMessageStreamPart = {
-  code: "4",
-  name: "assistant_message",
-  parse: (value) => {
-    if (value == null || typeof value !== "object" || !("id" in value) || !("role" in value) || !("content" in value) || typeof value.id !== "string" || typeof value.role !== "string" || value.role !== "assistant" || !Array.isArray(value.content) || !value.content.every(
-      (item) => item != null && typeof item === "object" && "type" in item && item.type === "text" && "text" in item && item.text != null && typeof item.text === "object" && "value" in item.text && typeof item.text.value === "string"
-    )) {
-      throw new Error(
-        '"assistant_message" parts expect an object with an "id", "role", and "content" property.'
-      );
-    }
-    return {
-      type: "assistant_message",
-      value
-    };
-  }
-};
-var assistantControlDataStreamPart = {
-  code: "5",
-  name: "assistant_control_data",
-  parse: (value) => {
-    if (value == null || typeof value !== "object" || !("threadId" in value) || !("messageId" in value) || typeof value.threadId !== "string" || typeof value.messageId !== "string") {
-      throw new Error(
-        '"assistant_control_data" parts expect an object with a "threadId" and "messageId" property.'
-      );
-    }
-    return {
-      type: "assistant_control_data",
-      value: {
-        threadId: value.threadId,
-        messageId: value.messageId
-      }
-    };
-  }
-};
-var dataMessageStreamPart = {
-  code: "6",
-  name: "data_message",
-  parse: (value) => {
-    if (value == null || typeof value !== "object" || !("role" in value) || !("data" in value) || typeof value.role !== "string" || value.role !== "data") {
-      throw new Error(
-        '"data_message" parts expect an object with a "role" and "data" property.'
-      );
-    }
-    return {
-      type: "data_message",
-      value
-    };
-  }
-};
-var toolCallStreamPart = {
-  code: "7",
-  name: "tool_calls",
-  parse: (value) => {
-    if (value == null || typeof value !== "object" || !("tool_calls" in value) || typeof value.tool_calls !== "object" || value.tool_calls == null || !Array.isArray(value.tool_calls) || value.tool_calls.some((tc) => {
-      tc == null || typeof tc !== "object" || !("id" in tc) || typeof tc.id !== "string" || !("type" in tc) || typeof tc.type !== "string" || !("function" in tc) || tc.function == null || typeof tc.function !== "object" || !("arguments" in tc.function) || typeof tc.function.name !== "string" || typeof tc.function.arguments !== "string";
-    })) {
-      throw new Error(
-        '"tool_calls" parts expect an object with a ToolCallPayload.'
-      );
-    }
-    return {
-      type: "tool_calls",
-      value
-    };
-  }
-};
-var messageAnnotationsStreamPart = {
-  code: "8",
-  name: "message_annotations",
-  parse: (value) => {
-    if (!Array.isArray(value)) {
-      throw new Error('"message_annotations" parts expect an array value.');
-    }
-    return { type: "message_annotations", value };
-  }
-};
-var streamParts = [
-  textStreamPart,
-  functionCallStreamPart,
-  dataStreamPart,
-  errorStreamPart,
-  assistantMessageStreamPart,
-  assistantControlDataStreamPart,
-  dataMessageStreamPart,
-  toolCallStreamPart,
-  messageAnnotationsStreamPart
-];
-var streamPartsByCode = {
-  [textStreamPart.code]: textStreamPart,
-  [functionCallStreamPart.code]: functionCallStreamPart,
-  [dataStreamPart.code]: dataStreamPart,
-  [errorStreamPart.code]: errorStreamPart,
-  [assistantMessageStreamPart.code]: assistantMessageStreamPart,
-  [assistantControlDataStreamPart.code]: assistantControlDataStreamPart,
-  [dataMessageStreamPart.code]: dataMessageStreamPart,
-  [toolCallStreamPart.code]: toolCallStreamPart,
-  [messageAnnotationsStreamPart.code]: messageAnnotationsStreamPart
-};
-var StreamStringPrefixes = {
-  [textStreamPart.name]: textStreamPart.code,
-  [functionCallStreamPart.name]: functionCallStreamPart.code,
-  [dataStreamPart.name]: dataStreamPart.code,
-  [errorStreamPart.name]: errorStreamPart.code,
-  [assistantMessageStreamPart.name]: assistantMessageStreamPart.code,
-  [assistantControlDataStreamPart.name]: assistantControlDataStreamPart.code,
-  [dataMessageStreamPart.name]: dataMessageStreamPart.code,
-  [toolCallStreamPart.name]: toolCallStreamPart.code,
-  [messageAnnotationsStreamPart.name]: messageAnnotationsStreamPart.code
-};
-var validCodes = streamParts.map((part) => part.code);
-function formatStreamPart(type, value) {
-  const streamPart = streamParts.find((part) => part.name === type);
-  if (!streamPart) {
-    throw new Error(`Invalid stream part type: ${type}`);
-  }
-  return `${streamPart.code}:${JSON.stringify(value)}
-`;
-}
-
-// shared/utils.ts
-import { customAlphabet } from "nanoid/non-secure";
-var nanoid2 = customAlphabet(
-  "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
-  7
-);
-var COMPLEX_HEADER = "X-Experimental-Stream-Data";
-
-// 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}`
-                );
-              }
-            }
-          }
-        })
-      ),
-      {
-        status: 200,
-        headers: {
-          "Content-Type": "text/plain; charset=utf-8",
-          [COMPLEX_HEADER]: "true"
-        }
-      }
-    );
-  }
-};
-
 // core/generate-text/stream-text.ts
 async function streamText({
   model,
@@ -1359,26 +1378,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: zodToJsonSchema3(tool2.parameters)
-      }))
-    },
-    ...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: zodToJsonSchema4(tool2.parameters)
+        }))
+      },
+      ...validateCallSettings(settings),
+      inputFormat: getInputFormat({ prompt, messages }),
+      prompt: convertToLanguageModelPrompt({
+        system,
+        prompt,
+        messages
+      }),
+      abortSignal
     })
-  });
+  );
   const toolStream = runToolsTransformation({
     tools,
     generatorStream: stream
@@ -1403,6 +1428,9 @@ var StreamTextResult = class {
                   return { value: value.textDelta, done: false };
                 }
               }
+              if (value.type === "error") {
+                console.error("Error:", value.error);
+              }
             }
           }
         };
@@ -1431,47 +1459,17 @@ var StreamTextResult = class {
       }
     };
   }
-  toResponse() {
-    return new StreamTextHttpResponse(this.rootStream);
-  }
 };
 
 // core/tool/tool.ts
 function tool(tool2) {
   return tool2;
 }
-
-// core/language-model/errors/unsupported-functionality-error.ts
-var UnsupportedFunctionalityError = class extends Error {
-  constructor({
-    provider,
-    functionality
-  }) {
-    super(
-      `Functionality not supported by the provider. Provider: ${provider}.
-Functionality: ${functionality}`
-    );
-    this.name = "UnsupportedFunctionalityError";
-    this.provider = provider;
-    this.functionality = functionality;
-  }
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      stack: this.stack,
-      provider: this.provider,
-      functionality: this.functionality
-    };
-  }
-};
 export {
   GenerateObjectResult,
   GenerateTextResult,
   StreamObjectResult,
-  StreamTextHttpResponse,
   StreamTextResult,
-  UnsupportedFunctionalityError,
   convertDataContentToBase64String,
   convertDataContentToUint8Array,
   generateObject,