ai 3.1.0-canary.3 → 3.1.0-canary.4

package/core/dist/index.mjs

@@ -1,10 +1,52 @@
 // 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';
+// 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,
@@ -15,6 +57,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,
@@ -40,6 +85,9 @@ function getErrorMessage(error) {
   return JSON.stringify(error);
 }
 
+// ai-model-specification/util/parse-json.ts
+import SecureJSON from "secure-json-parse";
+
 // ai-model-specification/errors/json-parse-error.ts
 var JSONParseError = class extends Error {
   constructor({ text, cause }) {
@@ -47,10 +95,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,
@@ -62,46 +113,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/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 }) {
@@ -109,10 +120,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,
@@ -124,9 +138,6 @@ Error message: ${getErrorMessage(cause)}`
   }
 };
 
-// ai-model-specification/util/parse-json.ts
-import SecureJSON from "secure-json-parse";
-
 // ai-model-specification/util/validate-types.ts
 function safeValidateTypes({
   value,
@@ -150,7 +161,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 })
     };
   }
 }
@@ -172,7 +183,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 })
     };
   }
 }
@@ -191,6 +202,103 @@ 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 {
@@ -311,98 +419,130 @@ 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
@@ -436,7 +576,7 @@ async function _retryWithExponentialBackoff(f, {
     const tryNumber = newErrors.length;
     if (tryNumber > maxRetries) {
       throw new RetryError({
-        message: `Failed after ${tryNumber} tries. Last error: ${errorMessage}`,
+        message: `Failed after ${tryNumber} attemps. Last error: ${errorMessage}`,
         reason: "maxRetriesExceeded",
         errors: newErrors
       });
@@ -447,7 +587,7 @@ async function _retryWithExponentialBackoff(f, {
       }
       if (
         // deal with bundling duplication by using names
-        error.name === "ApiCallError" && error.isRetryable === true && tryNumber <= maxRetries
+        APICallError.isAPICallError(error) && error.isRetryable === true && tryNumber <= maxRetries
       ) {
         await delay(delayInMs);
         return _retryWithExponentialBackoff(
@@ -457,8 +597,11 @@ async function _retryWithExponentialBackoff(f, {
         );
       }
     }
+    if (tryNumber === 1) {
+      throw error;
+    }
     throw new RetryError({
-      message: `Failed after ${tryNumber} tries with non-retryable error: '${errorMessage}'`,
+      message: `Failed after ${tryNumber} attemps with non-retryable error: '${errorMessage}'`,
       reason: "errorNotRetryable",
       errors: newErrors
     });
@@ -510,7 +653,7 @@ async function generateObject({
       const generateResult = await retry(
         () => model.doGenerate({
           mode: { type: "object-json" },
-          ...validateCallSettings(settings),
+          ...prepareCallSettings(settings),
           inputFormat: getInputFormat({ prompt, messages }),
           prompt: convertToLanguageModelPrompt({
             system: injectJsonSchemaIntoSystem({ system, schema: jsonSchema }),
@@ -606,6 +749,23 @@ var GenerateObjectResult = class {
 // core/generate-object/stream-object.ts
 import zodToJsonSchema2 from "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)
@@ -992,103 +1152,92 @@ async function streamObject({
 }) {
   const retry = retryWithExponentialBackoff({ maxRetries });
   const jsonSchema = zodToJsonSchema2(schema);
-  let modelStream;
   if (mode === "auto" || mode == null) {
     mode = model.defaultObjectGenerationMode;
   }
+  let callOptions;
+  let transformer;
   switch (mode) {
     case "json": {
-      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) {
-            switch (chunk.type) {
-              case "text-delta":
-                controller.enqueue(chunk.textDelta);
-                break;
-              case "error":
-                controller.enqueue(chunk);
-                break;
-            }
+      callOptions = {
+        mode: { type: "object-json" },
+        ...prepareCallSettings(settings),
+        inputFormat: getInputFormat({ prompt, messages }),
+        prompt: convertToLanguageModelPrompt({
+          system: injectJsonSchemaIntoSystem({ system, schema: jsonSchema }),
+          prompt,
+          messages
+        }),
+        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 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) {
-            switch (chunk.type) {
-              case "text-delta":
-                controller.enqueue(chunk.textDelta);
-                break;
-              case "error":
-                controller.enqueue(chunk);
-                break;
-            }
+      callOptions = {
+        mode: { type: "object-grammar", schema: jsonSchema },
+        ...settings,
+        inputFormat: getInputFormat({ prompt, messages }),
+        prompt: convertToLanguageModelPrompt({
+          system: injectJsonSchemaIntoSystem({ system, schema: jsonSchema }),
+          prompt,
+          messages
+        }),
+        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 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) {
-            switch (chunk.type) {
-              case "tool-call-delta":
-                controller.enqueue(chunk.argsTextDelta);
-                break;
-              case "error":
-                controller.enqueue(chunk);
-                break;
-            }
+      callOptions = {
+        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
+      };
+      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: {
@@ -1099,37 +1248,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;
+        }
       }
-    };
+    });
   }
 };
 
@@ -1143,26 +1290,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
   };
 }
 
@@ -1190,7 +1344,7 @@ async function generateText({
           parameters: zodToJsonSchema3(tool2.parameters)
         }))
       },
-      ...validateCallSettings(settings),
+      ...prepareCallSettings(settings),
       inputFormat: getInputFormat({ prompt, messages }),
       prompt: convertToLanguageModelPrompt({
         system,
@@ -1252,6 +1406,245 @@ var GenerateTextResult = class {
 // core/generate-text/stream-text.ts
 import zodToJsonSchema4 from "zod-to-json-schema";
 
+// 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)}
+`;
+}
+
+// streams/ai-stream.ts
+import {
+  createParser
+} from "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/run-tools-transformation.ts
 import { nanoid } from "nanoid";
 function runToolsTransformation({
@@ -1280,7 +1673,10 @@ function runToolsTransformation({
           if (tools == null) {
             toolResultsStreamController.enqueue({
               type: "error",
-              error: `Tool ${chunk.toolName} not found (no tools provided)`
+              error: new NoSuchToolError({
+                message: `Tool ${chunk.toolName} not found (no tools provided).`,
+                toolName: chunk.toolName
+              })
             });
             break;
           }
@@ -1288,44 +1684,54 @@ function runToolsTransformation({
           if (tool2 == null) {
             toolResultsStreamController.enqueue({
               type: "error",
-              error: `Tool ${chunk.toolName} not found`
+              error: new NoSuchToolError({
+                message: `Tool ${chunk.toolName} not found.`,
+                toolName: chunk.toolName
+              })
             });
             break;
           }
-          const toolCall = parseToolCall({
-            toolCall: chunk,
-            tools
-          });
-          controller.enqueue({
-            type: "tool-call",
-            ...toolCall
-          });
-          if (tool2.execute != null) {
-            const toolExecutionId = 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();
+          try {
+            const toolCall = parseToolCall({
+              toolCall: chunk,
+              tools
+            });
+            controller.enqueue({
+              type: "tool-call",
+              ...toolCall
+            });
+            if (tool2.execute != null) {
+              const toolExecutionId = 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
+            });
           }
           break;
         }
@@ -1394,7 +1800,7 @@ async function streamText({
           parameters: zodToJsonSchema4(tool2.parameters)
         }))
       },
-      ...validateCallSettings(settings),
+      ...prepareCallSettings(settings),
       inputFormat: getInputFormat({ prompt, messages }),
       prompt: convertToLanguageModelPrompt({
         system,
@@ -1412,52 +1818,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);
+        }
       }
-    };
+    });
+  }
+  toAIStream(callbacks) {
+    return readableFromAsyncIterable(this.textStream).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(
+      createStreamDataTransformer(callbacks == null ? void 0 : callbacks.experimental_streamData)
+    );
   }
 };