@mastra/core 1.2.0 → 1.2.1-alpha.0

package/dist/{chunk-IPXNR6RQ.js → chunk-V2MLGA7T.js}

@@ -1,7 +1,8 @@
-import { __commonJS, require_token_error, __toESM } from './chunk-V3LENMEW.js';
+import { __commonJS, require_token_error, __toESM } from './chunk-X5ORARLG.js';
 import * as z4 from 'zod/v4';
 import { z } from 'zod/v4';
 import { ZodFirstPartyTypeKind } from 'zod/v3';
+import { z as z$1 } from 'zod';
 
 var marker = "vercel.ai.error";
 var symbol = Symbol.for(marker);
@@ -17,13 +18,13 @@ var AISDKError = class _AISDKError extends (_b = Error, _a = symbol, _b) {
    * @param {unknown} [params.cause] - The underlying cause of the error.
    */
   constructor({
-    name: name142,
+    name: name1422,
     message,
     cause
   }) {
     super(message);
     this[_a] = true;
-    this.name = name142;
+    this.name = name1422;
     this.cause = cause;
   }
   /**
@@ -34,8 +35,8 @@ var AISDKError = class _AISDKError extends (_b = Error, _a = symbol, _b) {
   static isInstance(error) {
     return _AISDKError.hasMarker(error, marker);
   }
-  static hasMarker(error, marker152) {
-    const markerSymbol = Symbol.for(marker152);
+  static hasMarker(error, marker1522) {
+    const markerSymbol = Symbol.for(marker1522);
     return error != null && typeof error === "object" && markerSymbol in error && typeof error[markerSymbol] === "boolean" && error[markerSymbol] === true;
   }
 };
@@ -165,34 +166,79 @@ var symbol13 = Symbol.for(marker13);
 var _a13;
 var _b13;
 var TypeValidationError = class _TypeValidationError extends (_b13 = AISDKError, _a13 = symbol13, _b13) {
-  constructor({ value, cause }) {
+  constructor({
+    value,
+    cause,
+    context: context2
+  }) {
+    let contextPrefix = "Type validation failed";
+    if (context2 == null ? void 0 : context2.field) {
+      contextPrefix += ` for ${context2.field}`;
+    }
+    if ((context2 == null ? void 0 : context2.entityName) || (context2 == null ? void 0 : context2.entityId)) {
+      contextPrefix += " (";
+      const parts = [];
+      if (context2.entityName) {
+        parts.push(context2.entityName);
+      }
+      if (context2.entityId) {
+        parts.push(`id: "${context2.entityId}"`);
+      }
+      contextPrefix += parts.join(", ");
+      contextPrefix += ")";
+    }
     super({
       name: name12,
-      message: `Type validation failed: Value: ${JSON.stringify(value)}.
+      message: `${contextPrefix}: Value: ${JSON.stringify(value)}.
 Error message: ${getErrorMessage(cause)}`,
       cause
     });
     this[_a13] = true;
     this.value = value;
+    this.context = context2;
   }
   static isInstance(error) {
     return AISDKError.hasMarker(error, marker13);
   }
   /**
    * Wraps an error into a TypeValidationError.
-   * If the cause is already a TypeValidationError with the same value, it returns the cause.
+   * If the cause is already a TypeValidationError with the same value and context, it returns the cause.
    * Otherwise, it creates a new TypeValidationError.
    *
    * @param {Object} params - The parameters for wrapping the error.
    * @param {unknown} params.value - The value that failed validation.
    * @param {unknown} params.cause - The original error or cause of the validation failure.
+   * @param {TypeValidationContext} params.context - Optional context about what is being validated.
    * @returns {TypeValidationError} A TypeValidationError instance.
    */
   static wrap({
     value,
-    cause
+    cause,
+    context: context2
+  }) {
+    var _a1522, _b152, _c;
+    if (_TypeValidationError.isInstance(cause) && cause.value === value && ((_a1522 = cause.context) == null ? void 0 : _a1522.field) === (context2 == null ? void 0 : context2.field) && ((_b152 = cause.context) == null ? void 0 : _b152.entityName) === (context2 == null ? void 0 : context2.entityName) && ((_c = cause.context) == null ? void 0 : _c.entityId) === (context2 == null ? void 0 : context2.entityId)) {
+      return cause;
+    }
+    return new _TypeValidationError({ value, cause, context: context2 });
+  }
+};
+var name13 = "AI_UnsupportedFunctionalityError";
+var marker14 = `vercel.ai.error.${name13}`;
+var symbol14 = Symbol.for(marker14);
+var _a14;
+var _b14;
+var UnsupportedFunctionalityError = class extends (_b14 = AISDKError, _a14 = symbol14, _b14) {
+  constructor({
+    functionality,
+    message = `'${functionality}' functionality not supported.`
   }) {
-    return _TypeValidationError.isInstance(cause) && cause.value === value ? cause : new _TypeValidationError({ value, cause });
+    super({ name: name13, message });
+    this[_a14] = true;
+    this.functionality = functionality;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker14);
   }
 };
 var ParseError = class extends Error {
@@ -482,6 +528,25 @@ function isAbortError(error) {
   error.name === "TimeoutError");
 }
 var FETCH_FAILED_ERROR_MESSAGES = ["fetch failed", "failed to fetch"];
+var BUN_ERROR_CODES = [
+  "ConnectionRefused",
+  "ConnectionClosed",
+  "FailedToOpenSocket",
+  "ECONNRESET",
+  "ECONNREFUSED",
+  "ETIMEDOUT",
+  "EPIPE"
+];
+function isBunNetworkError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const code = error.code;
+  if (typeof code === "string" && BUN_ERROR_CODES.includes(code)) {
+    return true;
+  }
+  return false;
+}
 function handleFetchError({
   error,
   url,
@@ -503,6 +568,15 @@ function handleFetchError({
       });
     }
   }
+  if (isBunNetworkError(error)) {
+    return new APICallError({
+      message: `Cannot connect to API: ${error.message}`,
+      cause: error,
+      url,
+      requestBodyValues,
+      isRetryable: true
+    });
+  }
   return error;
 }
 function getRuntimeEnvironmentUserAgent(globalThisAny = globalThis) {
@@ -551,7 +625,7 @@ function withUserAgentSuffix(headers, ...userAgentSuffixParts) {
   );
   return Object.fromEntries(normalizedHeaders.entries());
 }
-var VERSION = "4.0.0";
+var VERSION = "4.0.13";
 var getOriginalFetch = () => globalThis.fetch;
 var getFromApi = async ({
   url,
@@ -696,30 +770,39 @@ function secureJsonParse(text2) {
   }
 }
 function addAdditionalPropertiesToJsonSchema(jsonSchema2) {
-  if (jsonSchema2.type === "object") {
+  if (jsonSchema2.type === "object" || Array.isArray(jsonSchema2.type) && jsonSchema2.type.includes("object")) {
     jsonSchema2.additionalProperties = false;
-    const properties = jsonSchema2.properties;
+    const { properties } = jsonSchema2;
     if (properties != null) {
-      for (const property in properties) {
-        properties[property] = addAdditionalPropertiesToJsonSchema(
-          properties[property]
-        );
+      for (const key of Object.keys(properties)) {
+        properties[key] = visit(properties[key]);
       }
     }
   }
-  if (jsonSchema2.type === "array" && jsonSchema2.items != null) {
-    if (Array.isArray(jsonSchema2.items)) {
-      jsonSchema2.items = jsonSchema2.items.map(
-        (item) => addAdditionalPropertiesToJsonSchema(item)
-      );
-    } else {
-      jsonSchema2.items = addAdditionalPropertiesToJsonSchema(
-        jsonSchema2.items
-      );
+  if (jsonSchema2.items != null) {
+    jsonSchema2.items = Array.isArray(jsonSchema2.items) ? jsonSchema2.items.map(visit) : visit(jsonSchema2.items);
+  }
+  if (jsonSchema2.anyOf != null) {
+    jsonSchema2.anyOf = jsonSchema2.anyOf.map(visit);
+  }
+  if (jsonSchema2.allOf != null) {
+    jsonSchema2.allOf = jsonSchema2.allOf.map(visit);
+  }
+  if (jsonSchema2.oneOf != null) {
+    jsonSchema2.oneOf = jsonSchema2.oneOf.map(visit);
+  }
+  const { definitions } = jsonSchema2;
+  if (definitions != null) {
+    for (const key of Object.keys(definitions)) {
+      definitions[key] = visit(definitions[key]);
     }
   }
   return jsonSchema2;
 }
+function visit(def) {
+  if (typeof def === "boolean") return def;
+  return addAdditionalPropertiesToJsonSchema(def);
+}
 var ignoreOverride = /* @__PURE__ */ Symbol(
   "Let zodToJsonSchema decide on which parser to use"
 );
@@ -1836,9 +1919,11 @@ function asSchema(schema) {
 }
 function standardSchema(standardSchema2) {
   return jsonSchema(
-    () => standardSchema2["~standard"].jsonSchema.input({
-      target: "draft-07"
-    }),
+    () => addAdditionalPropertiesToJsonSchema(
+      standardSchema2["~standard"].jsonSchema.input({
+        target: "draft-07"
+      })
+    ),
     {
       validate: async (value) => {
         const result = await standardSchema2["~standard"].validate(value);
@@ -1901,17 +1986,19 @@ function zodSchema(zodSchema2, options) {
 }
 async function validateTypes({
   value,
-  schema
+  schema,
+  context: context2
 }) {
-  const result = await safeValidateTypes({ value, schema });
+  const result = await safeValidateTypes({ value, schema, context: context2 });
   if (!result.success) {
-    throw TypeValidationError.wrap({ value, cause: result.error });
+    throw TypeValidationError.wrap({ value, cause: result.error, context: context2 });
   }
   return result.value;
 }
 async function safeValidateTypes({
   value,
-  schema
+  schema,
+  context: context2
 }) {
   const actualSchema = asSchema(schema);
   try {
@@ -1924,13 +2011,13 @@ async function safeValidateTypes({
     }
     return {
       success: false,
-      error: TypeValidationError.wrap({ value, cause: result.error }),
+      error: TypeValidationError.wrap({ value, cause: result.error, context: context2 }),
       rawValue: value
     };
   } catch (error) {
     return {
       success: false,
-      error: TypeValidationError.wrap({ value, cause: error }),
+      error: TypeValidationError.wrap({ value, cause: error, context: context2 }),
       rawValue: value
     };
   }
@@ -2078,6 +2165,38 @@ var postToApi = async ({
     throw handleFetchError({ error, url, requestBodyValues: body.values });
   }
 };
+function tool(tool2) {
+  return tool2;
+}
+function createProviderToolFactoryWithOutputSchema({
+  id,
+  inputSchema,
+  outputSchema: outputSchema2,
+  supportsDeferredResults
+}) {
+  return ({
+    execute,
+    needsApproval,
+    toModelOutput,
+    onInputStart,
+    onInputDelta,
+    onInputAvailable,
+    ...args
+  }) => tool({
+    type: "provider",
+    id,
+    args,
+    inputSchema,
+    outputSchema: outputSchema2,
+    execute,
+    needsApproval,
+    toModelOutput,
+    onInputStart,
+    onInputDelta,
+    onInputAvailable,
+    supportsDeferredResults
+  });
+}
 async function resolve(value) {
   if (typeof value === "function") {
     value = value();
@@ -2199,14 +2318,14 @@ async function* executeTool({
   }
 }
 var require_get_context = __commonJS({
-  "../../../node_modules/.pnpm/@vercel+oidc@3.0.5/node_modules/@vercel/oidc/dist/get-context.js"(exports$1, module) {
+  "../../../node_modules/.pnpm/@vercel+oidc@3.1.0/node_modules/@vercel/oidc/dist/get-context.js"(exports$1, module) {
     var __defProp2 = Object.defineProperty;
     var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
     var __getOwnPropNames = Object.getOwnPropertyNames;
     var __hasOwnProp = Object.prototype.hasOwnProperty;
     var __export2 = (target, all) => {
-      for (var name142 in all)
-        __defProp2(target, name142, { get: all[name142], enumerable: true });
+      for (var name21 in all)
+        __defProp2(target, name21, { get: all[name21], enumerable: true });
     };
     var __copyProps = (to, from, except, desc) => {
       if (from && typeof from === "object" || typeof from === "function") {
@@ -2231,14 +2350,14 @@ var require_get_context = __commonJS({
   }
 });
 var require_get_vercel_oidc_token = __commonJS({
-  "../../../node_modules/.pnpm/@vercel+oidc@3.0.5/node_modules/@vercel/oidc/dist/get-vercel-oidc-token.js"(exports$1, module) {
+  "../../../node_modules/.pnpm/@vercel+oidc@3.1.0/node_modules/@vercel/oidc/dist/get-vercel-oidc-token.js"(exports$1, module) {
     var __defProp2 = Object.defineProperty;
     var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
     var __getOwnPropNames = Object.getOwnPropertyNames;
     var __hasOwnProp = Object.prototype.hasOwnProperty;
     var __export2 = (target, all) => {
-      for (var name142 in all)
-        __defProp2(target, name142, { get: all[name142], enumerable: true });
+      for (var name21 in all)
+        __defProp2(target, name21, { get: all[name21], enumerable: true });
     };
     var __copyProps = (to, from, except, desc) => {
       if (from && typeof from === "object" || typeof from === "function") {
@@ -2267,19 +2386,23 @@ var require_get_vercel_oidc_token = __commonJS({
       }
       try {
         const [{ getTokenPayload, isExpired }, { refreshToken }] = await Promise.all([
-          await import('./token-util-NEHG7TUY-TZ426VZB.js'),
-          await import('./token-6GSAFR2W-TOUJCAPY.js')
+          await import('./token-util-RMHT2CPJ-S2YMG7N3.js'),
+          await import('./token-APYSY3BW-QJCV2XQG.js')
         ]);
         if (!token || isExpired(getTokenPayload(token))) {
           await refreshToken();
           token = getVercelOidcTokenSync2();
         }
       } catch (error) {
-        if (err?.message && error instanceof Error) {
-          error.message = `${err.message}
+        let message = err instanceof Error ? err.message : "";
+        if (error instanceof Error) {
+          message = `${message}
 ${error.message}`;
         }
-        throw new import_token_error.VercelOidcTokenError(`Failed to refresh OIDC token`, error);
+        if (message) {
+          throw new import_token_error.VercelOidcTokenError(message);
+        }
+        throw error;
       }
       return token;
     }
@@ -2295,14 +2418,14 @@ ${error.message}`;
   }
 });
 var require_dist = __commonJS({
-  "../../../node_modules/.pnpm/@vercel+oidc@3.0.5/node_modules/@vercel/oidc/dist/index.js"(exports$1, module) {
+  "../../../node_modules/.pnpm/@vercel+oidc@3.1.0/node_modules/@vercel/oidc/dist/index.js"(exports$1, module) {
     var __defProp2 = Object.defineProperty;
     var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
     var __getOwnPropNames = Object.getOwnPropertyNames;
     var __hasOwnProp = Object.prototype.hasOwnProperty;
     var __export2 = (target, all) => {
-      for (var name142 in all)
-        __defProp2(target, name142, { get: all[name142], enumerable: true });
+      for (var name21 in all)
+        __defProp2(target, name21, { get: all[name21], enumerable: true });
     };
     var __copyProps = (to, from, except, desc) => {
       if (from && typeof from === "object" || typeof from === "function") {
@@ -2334,12 +2457,14 @@ var GatewayError = class _GatewayError extends (_b16 = Error, _a16 = symbol16, _
   constructor({
     message,
     statusCode = 500,
-    cause
+    cause,
+    generationId
   }) {
-    super(message);
+    super(generationId ? `${message} [${generationId}]` : message);
     this[_a16] = true;
     this.statusCode = statusCode;
     this.cause = cause;
+    this.generationId = generationId;
   }
   /**
    * Checks if the given error is a Gateway Error.
@@ -2362,9 +2487,10 @@ var GatewayAuthenticationError = class _GatewayAuthenticationError extends (_b22
   constructor({
     message = "Authentication failed",
     statusCode = 401,
-    cause
+    cause,
+    generationId
   } = {}) {
-    super({ message, statusCode, cause });
+    super({ message, statusCode, cause, generationId });
     this[_a22] = true;
     this.name = name15;
     this.type = "authentication_error";
@@ -2380,7 +2506,8 @@ var GatewayAuthenticationError = class _GatewayAuthenticationError extends (_b22
     oidcTokenProvided,
     message = "Authentication failed",
     statusCode = 401,
-    cause
+    cause,
+    generationId
   }) {
     let contextualMessage;
     if (apiKeyProvided) {
@@ -2408,7 +2535,8 @@ Run 'npx vercel link' to link your project, then 'vc env pull' to fetch the toke
     return new _GatewayAuthenticationError({
       message: contextualMessage,
       statusCode,
-      cause
+      cause,
+      generationId
     });
   }
 };
@@ -2421,9 +2549,10 @@ var GatewayInvalidRequestError = class extends (_b32 = GatewayError, _a32 = symb
   constructor({
     message = "Invalid request",
     statusCode = 400,
-    cause
+    cause,
+    generationId
   } = {}) {
-    super({ message, statusCode, cause });
+    super({ message, statusCode, cause, generationId });
     this[_a32] = true;
     this.name = name22;
     this.type = "invalid_request_error";
@@ -2441,9 +2570,10 @@ var GatewayRateLimitError = class extends (_b42 = GatewayError, _a42 = symbol42,
   constructor({
     message = "Rate limit exceeded",
     statusCode = 429,
-    cause
+    cause,
+    generationId
   } = {}) {
-    super({ message, statusCode, cause });
+    super({ message, statusCode, cause, generationId });
     this[_a42] = true;
     this.name = name32;
     this.type = "rate_limit_exceeded";
@@ -2469,9 +2599,10 @@ var GatewayModelNotFoundError = class extends (_b52 = GatewayError, _a52 = symbo
     message = "Model not found",
     statusCode = 404,
     modelId,
-    cause
+    cause,
+    generationId
   } = {}) {
-    super({ message, statusCode, cause });
+    super({ message, statusCode, cause, generationId });
     this[_a52] = true;
     this.name = name42;
     this.type = "model_not_found";
@@ -2490,9 +2621,10 @@ var GatewayInternalServerError = class extends (_b62 = GatewayError, _a62 = symb
   constructor({
     message = "Internal server error",
     statusCode = 500,
-    cause
+    cause,
+    generationId
   } = {}) {
-    super({ message, statusCode, cause });
+    super({ message, statusCode, cause, generationId });
     this[_a62] = true;
     this.name = name52;
     this.type = "internal_server_error";
@@ -2512,9 +2644,10 @@ var GatewayResponseError = class extends (_b72 = GatewayError, _a72 = symbol72,
     statusCode = 502,
     response,
     validationError,
-    cause
+    cause,
+    generationId
   } = {}) {
-    super({ message, statusCode, cause });
+    super({ message, statusCode, cause, generationId });
     this[_a72] = true;
     this.name = name62;
     this.type = "response_error";
@@ -2532,34 +2665,49 @@ async function createGatewayErrorFromResponse({
   cause,
   authMethod
 }) {
+  var _a83;
   const parseResult = await safeValidateTypes({
     value: response,
     schema: gatewayErrorResponseSchema
   });
   if (!parseResult.success) {
+    const rawGenerationId = typeof response === "object" && response !== null && "generationId" in response ? response.generationId : void 0;
     return new GatewayResponseError({
       message: `Invalid error response format: ${defaultMessage}`,
       statusCode,
       response,
       validationError: parseResult.error,
-      cause
+      cause,
+      generationId: rawGenerationId
     });
   }
   const validatedResponse = parseResult.value;
   const errorType = validatedResponse.error.type;
   const message = validatedResponse.error.message;
+  const generationId = (_a83 = validatedResponse.generationId) != null ? _a83 : void 0;
   switch (errorType) {
     case "authentication_error":
       return GatewayAuthenticationError.createContextualError({
         apiKeyProvided: authMethod === "api-key",
         oidcTokenProvided: authMethod === "oidc",
         statusCode,
-        cause
+        cause,
+        generationId
       });
     case "invalid_request_error":
-      return new GatewayInvalidRequestError({ message, statusCode, cause });
+      return new GatewayInvalidRequestError({
+        message,
+        statusCode,
+        cause,
+        generationId
+      });
     case "rate_limit_exceeded":
-      return new GatewayRateLimitError({ message, statusCode, cause });
+      return new GatewayRateLimitError({
+        message,
+        statusCode,
+        cause,
+        generationId
+      });
     case "model_not_found": {
       const modelResult = await safeValidateTypes({
         value: validatedResponse.error.param,
@@ -2569,13 +2717,24 @@ async function createGatewayErrorFromResponse({
         message,
         statusCode,
         modelId: modelResult.success ? modelResult.value.modelId : void 0,
-        cause
+        cause,
+        generationId
       });
     }
     case "internal_server_error":
-      return new GatewayInternalServerError({ message, statusCode, cause });
+      return new GatewayInternalServerError({
+        message,
+        statusCode,
+        cause,
+        generationId
+      });
     default:
-      return new GatewayInternalServerError({ message, statusCode, cause });
+      return new GatewayInternalServerError({
+        message,
+        statusCode,
+        cause,
+        generationId
+      });
   }
 }
 var gatewayErrorResponseSchema = lazySchema(
@@ -2586,7 +2745,8 @@ var gatewayErrorResponseSchema = lazySchema(
         type: z.string().nullish(),
         param: z.unknown().nullish(),
         code: z.union([z.string(), z.number()]).nullish()
-      })
+      }),
+      generationId: z.string().nullish()
     })
   )
 );
@@ -2862,7 +3022,7 @@ var GatewayLanguageModel = class {
   }
   getModelConfigHeaders(modelId, streaming) {
     return {
-      "ai-language-model-specification-version": "2",
+      "ai-language-model-specification-version": "3",
       "ai-language-model-id": modelId,
       "ai-language-model-streaming": String(streaming)
     };
@@ -2930,7 +3090,7 @@ var GatewayEmbeddingModel = class {
   }
   getModelConfigHeaders() {
     return {
-      "ai-embedding-model-specification-version": "2",
+      "ai-embedding-model-specification-version": "3",
       "ai-model-id": this.modelId
     };
   }
@@ -2960,6 +3120,8 @@ var GatewayImageModel = class {
     size,
     aspectRatio,
     seed,
+    files,
+    mask,
     providerOptions,
     headers,
     abortSignal
@@ -2984,7 +3146,11 @@ var GatewayImageModel = class {
           ...size && { size },
           ...aspectRatio && { aspectRatio },
           ...seed && { seed },
-          ...providerOptions && { providerOptions }
+          ...providerOptions && { providerOptions },
+          ...files && {
+            files: files.map((file) => maybeEncodeImageFile(file))
+          },
+          ...mask && { mask: maybeEncodeImageFile(mask) }
         },
         successfulResponseHandler: createJsonResponseHandler(
           gatewayImageResponseSchema
@@ -3016,11 +3182,20 @@ var GatewayImageModel = class {
   }
   getModelConfigHeaders() {
     return {
-      "ai-image-model-specification-version": "2",
+      "ai-image-model-specification-version": "3",
       "ai-model-id": this.modelId
     };
   }
 };
+function maybeEncodeImageFile(file) {
+  if (file.type === "file" && file.data instanceof Uint8Array) {
+    return {
+      ...file,
+      data: convertUint8ArrayToBase64(file.data)
+    };
+  }
+  return file;
+}
 var providerMetadataEntrySchema = z.object({
   images: z.array(z.unknown()).optional()
 }).catchall(z.unknown());
@@ -3035,11 +3210,183 @@ var gatewayImageResponseSchema = z.object({
   ).optional(),
   providerMetadata: z.record(z.string(), providerMetadataEntrySchema).optional()
 });
+var parallelSearchInputSchema = lazySchema(
+  () => zodSchema(
+    z$1.object({
+      objective: z$1.string().describe(
+        "Natural-language description of the web research goal, including source or freshness guidance and broader context from the task. Maximum 5000 characters."
+      ),
+      search_queries: z$1.array(z$1.string()).optional().describe(
+        "Optional search queries to supplement the objective. Maximum 200 characters per query."
+      ),
+      mode: z$1.enum(["one-shot", "agentic"]).optional().describe(
+        'Mode preset: "one-shot" for comprehensive results with longer excerpts (default), "agentic" for concise, token-efficient results for multi-step workflows.'
+      ),
+      max_results: z$1.number().optional().describe(
+        "Maximum number of results to return (1-20). Defaults to 10 if not specified."
+      ),
+      source_policy: z$1.object({
+        include_domains: z$1.array(z$1.string()).optional().describe("List of domains to include in search results."),
+        exclude_domains: z$1.array(z$1.string()).optional().describe("List of domains to exclude from search results."),
+        after_date: z$1.string().optional().describe(
+          "Only include results published after this date (ISO 8601 format)."
+        )
+      }).optional().describe(
+        "Source policy for controlling which domains to include/exclude and freshness."
+      ),
+      excerpts: z$1.object({
+        max_chars_per_result: z$1.number().optional().describe("Maximum characters per result."),
+        max_chars_total: z$1.number().optional().describe("Maximum total characters across all results.")
+      }).optional().describe("Excerpt configuration for controlling result length."),
+      fetch_policy: z$1.object({
+        max_age_seconds: z$1.number().optional().describe(
+          "Maximum age in seconds for cached content. Set to 0 to always fetch fresh content."
+        )
+      }).optional().describe("Fetch policy for controlling content freshness.")
+    })
+  )
+);
+var parallelSearchOutputSchema = lazySchema(
+  () => zodSchema(
+    z$1.union([
+      // Success response
+      z$1.object({
+        searchId: z$1.string(),
+        results: z$1.array(
+          z$1.object({
+            url: z$1.string(),
+            title: z$1.string(),
+            excerpt: z$1.string(),
+            publishDate: z$1.string().nullable().optional(),
+            relevanceScore: z$1.number().optional()
+          })
+        )
+      }),
+      // Error response
+      z$1.object({
+        error: z$1.enum([
+          "api_error",
+          "rate_limit",
+          "timeout",
+          "invalid_input",
+          "configuration_error",
+          "unknown"
+        ]),
+        statusCode: z$1.number().optional(),
+        message: z$1.string()
+      })
+    ])
+  )
+);
+var parallelSearchToolFactory = createProviderToolFactoryWithOutputSchema({
+  id: "gateway.parallel_search",
+  inputSchema: parallelSearchInputSchema,
+  outputSchema: parallelSearchOutputSchema
+});
+var parallelSearch = (config = {}) => parallelSearchToolFactory(config);
+var perplexitySearchInputSchema = lazySchema(
+  () => zodSchema(
+    z$1.object({
+      query: z$1.union([z$1.string(), z$1.array(z$1.string())]).describe(
+        "Search query (string) or multiple queries (array of up to 5 strings). Multi-query searches return combined results from all queries."
+      ),
+      max_results: z$1.number().optional().describe(
+        "Maximum number of search results to return (1-20, default: 10)"
+      ),
+      max_tokens_per_page: z$1.number().optional().describe(
+        "Maximum number of tokens to extract per search result page (256-2048, default: 2048)"
+      ),
+      max_tokens: z$1.number().optional().describe(
+        "Maximum total tokens across all search results (default: 25000, max: 1000000)"
+      ),
+      country: z$1.string().optional().describe(
+        "Two-letter ISO 3166-1 alpha-2 country code for regional search results (e.g., 'US', 'GB', 'FR')"
+      ),
+      search_domain_filter: z$1.array(z$1.string()).optional().describe(
+        "List of domains to include or exclude from search results (max 20). To include: ['nature.com', 'science.org']. To exclude: ['-example.com', '-spam.net']"
+      ),
+      search_language_filter: z$1.array(z$1.string()).optional().describe(
+        "List of ISO 639-1 language codes to filter results (max 10, lowercase). Examples: ['en', 'fr', 'de']"
+      ),
+      search_after_date: z$1.string().optional().describe(
+        "Include only results published after this date. Format: 'MM/DD/YYYY' (e.g., '3/1/2025'). Cannot be used with search_recency_filter."
+      ),
+      search_before_date: z$1.string().optional().describe(
+        "Include only results published before this date. Format: 'MM/DD/YYYY' (e.g., '3/15/2025'). Cannot be used with search_recency_filter."
+      ),
+      last_updated_after_filter: z$1.string().optional().describe(
+        "Include only results last updated after this date. Format: 'MM/DD/YYYY' (e.g., '3/1/2025'). Cannot be used with search_recency_filter."
+      ),
+      last_updated_before_filter: z$1.string().optional().describe(
+        "Include only results last updated before this date. Format: 'MM/DD/YYYY' (e.g., '3/15/2025'). Cannot be used with search_recency_filter."
+      ),
+      search_recency_filter: z$1.enum(["day", "week", "month", "year"]).optional().describe(
+        "Filter results by relative time period. Cannot be used with search_after_date or search_before_date."
+      )
+    })
+  )
+);
+var perplexitySearchOutputSchema = lazySchema(
+  () => zodSchema(
+    z$1.union([
+      // Success response
+      z$1.object({
+        results: z$1.array(
+          z$1.object({
+            title: z$1.string(),
+            url: z$1.string(),
+            snippet: z$1.string(),
+            date: z$1.string().optional(),
+            lastUpdated: z$1.string().optional()
+          })
+        ),
+        id: z$1.string()
+      }),
+      // Error response
+      z$1.object({
+        error: z$1.enum([
+          "api_error",
+          "rate_limit",
+          "timeout",
+          "invalid_input",
+          "unknown"
+        ]),
+        statusCode: z$1.number().optional(),
+        message: z$1.string()
+      })
+    ])
+  )
+);
+var perplexitySearchToolFactory = createProviderToolFactoryWithOutputSchema({
+  id: "gateway.perplexity_search",
+  inputSchema: perplexitySearchInputSchema,
+  outputSchema: perplexitySearchOutputSchema
+});
+var perplexitySearch = (config = {}) => perplexitySearchToolFactory(config);
+var gatewayTools = {
+  /**
+   * Search the web using Parallel AI's Search API for LLM-optimized excerpts.
+   *
+   * Takes a natural language objective and returns relevant excerpts,
+   * replacing multiple keyword searches with a single call for broad
+   * or complex queries. Supports different search types for depth vs
+   * breadth tradeoffs.
+   */
+  parallelSearch,
+  /**
+   * Search the web using Perplexity's Search API for real-time information,
+   * news, research papers, and articles.
+   *
+   * Provides ranked search results with advanced filtering options including
+   * domain, language, date range, and recency filters.
+   */
+  perplexitySearch
+};
 async function getVercelRequestId() {
   var _a83;
   return (_a83 = (0, import_oidc.getContext)().headers) == null ? void 0 : _a83["x-vercel-id"];
 }
-var VERSION2 = "3.0.0";
+var VERSION2 = "3.0.32";
 var AI_GATEWAY_PROTOCOL_VERSION = "0.0.1";
 function createGatewayProvider(options = {}) {
   var _a83, _b82;
@@ -3049,8 +3396,8 @@ function createGatewayProvider(options = {}) {
   let lastFetchTime = 0;
   const baseURL = (_b82 = withoutTrailingSlash(options.baseURL)) != null ? _b82 : "https://ai-gateway.vercel.sh/v3/ai";
   const getHeaders = async () => {
-    const auth = await getGatewayAuthToken(options);
-    if (auth) {
+    try {
+      const auth = await getGatewayAuthToken(options);
       return withUserAgentSuffix(
         {
           Authorization: `Bearer ${auth.token}`,
@@ -3060,12 +3407,14 @@ function createGatewayProvider(options = {}) {
         },
         `ai-sdk/gateway/${VERSION2}`
       );
+    } catch (error) {
+      throw GatewayAuthenticationError.createContextualError({
+        apiKeyProvided: false,
+        oidcTokenProvided: false,
+        statusCode: 401,
+        cause: error
+      });
     }
-    throw GatewayAuthenticationError.createContextualError({
-      apiKeyProvided: false,
-      oidcTokenProvided: false,
-      statusCode: 401
-    });
   };
   const createO11yHeaders = () => {
     const deploymentId = loadOptionalSetting({
@@ -3164,6 +3513,7 @@ function createGatewayProvider(options = {}) {
   };
   provider.embeddingModel = createEmbeddingModel;
   provider.textEmbeddingModel = createEmbeddingModel;
+  provider.tools = gatewayTools;
   return provider;
 }
 var gateway = createGatewayProvider();
@@ -3178,15 +3528,11 @@ async function getGatewayAuthToken(options) {
       authMethod: "api-key"
     };
   }
-  try {
-    const oidcToken = await (0, import_oidc2.getVercelOidcToken)();
-    return {
-      token: oidcToken,
-      authMethod: "oidc"
-    };
-  } catch (e) {
-    return null;
-  }
+  const oidcToken = await (0, import_oidc2.getVercelOidcToken)();
+  return {
+    token: oidcToken,
+    authMethod: "oidc"
+  };
 }
 var _globalThis = typeof globalThis === "object" ? globalThis : global;
 var VERSION22 = "1.9.0";
@@ -3259,11 +3605,11 @@ var major = VERSION22.split(".")[0];
 var GLOBAL_OPENTELEMETRY_API_KEY = /* @__PURE__ */ Symbol.for("opentelemetry.js.api." + major);
 var _global = _globalThis;
 function registerGlobal(type, instance, diag, allowOverride) {
-  var _a142;
+  var _a21;
   if (allowOverride === void 0) {
     allowOverride = false;
   }
-  var api = _global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a142 = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a142 !== void 0 ? _a142 : {
+  var api = _global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a21 = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a21 !== void 0 ? _a21 : {
     version: VERSION22
   };
   if (!allowOverride && api[type]) {
@@ -3281,8 +3627,8 @@ function registerGlobal(type, instance, diag, allowOverride) {
   return true;
 }
 function getGlobal(type) {
-  var _a142, _b82;
-  var globalVersion = (_a142 = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a142 === void 0 ? void 0 : _a142.version;
+  var _a21, _b82;
+  var globalVersion = (_a21 = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a21 === void 0 ? void 0 : _a21.version;
   if (!globalVersion || !isCompatible(globalVersion)) {
     return;
   }
@@ -3451,13 +3797,13 @@ var DiagAPI = (
       }
       var self = this;
       var setLogger = function(logger, optionsOrLogLevel) {
-        var _a142, _b82, _c;
+        var _a21, _b82, _c;
         if (optionsOrLogLevel === void 0) {
           optionsOrLogLevel = { logLevel: DiagLogLevel.INFO };
         }
         if (logger === self) {
           var err = new Error("Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation");
-          self.error((_a142 = err.stack) !== null && _a142 !== void 0 ? _a142 : err.message);
+          self.error((_a21 = err.stack) !== null && _a21 !== void 0 ? _a21 : err.message);
           return false;
         }
         if (typeof optionsOrLogLevel === "number") {
@@ -3509,14 +3855,14 @@ var BaseContext = (
         return self._currentContext.get(key);
       };
       self.setValue = function(key, value) {
-        var context = new BaseContext2(self._currentContext);
-        context._currentContext.set(key, value);
-        return context;
+        var context2 = new BaseContext2(self._currentContext);
+        context2._currentContext.set(key, value);
+        return context2;
       };
       self.deleteValue = function(key) {
-        var context = new BaseContext2(self._currentContext);
-        context._currentContext.delete(key);
-        return context;
+        var context2 = new BaseContext2(self._currentContext);
+        context2._currentContext.delete(key);
+        return context2;
       };
     }
     return BaseContext2;
@@ -3621,16 +3967,16 @@ var ContextAPI = (
     ContextAPI2.prototype.active = function() {
       return this._getContextManager().active();
     };
-    ContextAPI2.prototype.with = function(context, fn, thisArg) {
-      var _a142;
+    ContextAPI2.prototype.with = function(context2, fn, thisArg) {
+      var _a21;
       var args = [];
       for (var _i = 3; _i < arguments.length; _i++) {
         args[_i - 3] = arguments[_i];
       }
-      return (_a142 = this._getContextManager()).with.apply(_a142, __spreadArray4([context, fn, thisArg], __read4(args), false));
+      return (_a21 = this._getContextManager()).with.apply(_a21, __spreadArray4([context2, fn, thisArg], __read4(args), false));
     };
-    ContextAPI2.prototype.bind = function(context, target) {
-      return this._getContextManager().bind(context, target);
+    ContextAPI2.prototype.bind = function(context2, target) {
+      return this._getContextManager().bind(context2, target);
     };
     ContextAPI2.prototype._getContextManager = function() {
       return getGlobal(API_NAME2) || NOOP_CONTEXT_MANAGER;
@@ -3698,24 +4044,24 @@ var NonRecordingSpan = (
   })()
 );
 var SPAN_KEY = createContextKey("OpenTelemetry Context Key SPAN");
-function getSpan(context) {
-  return context.getValue(SPAN_KEY) || void 0;
+function getSpan(context2) {
+  return context2.getValue(SPAN_KEY) || void 0;
 }
 function getActiveSpan() {
   return getSpan(ContextAPI.getInstance().active());
 }
-function setSpan(context, span) {
-  return context.setValue(SPAN_KEY, span);
+function setSpan(context2, span) {
+  return context2.setValue(SPAN_KEY, span);
 }
-function deleteSpan(context) {
-  return context.deleteValue(SPAN_KEY);
+function deleteSpan(context2) {
+  return context2.deleteValue(SPAN_KEY);
 }
-function setSpanContext(context, spanContext) {
-  return setSpan(context, new NonRecordingSpan(spanContext));
+function setSpanContext(context2, spanContext) {
+  return setSpan(context2, new NonRecordingSpan(spanContext));
 }
-function getSpanContext(context) {
-  var _a142;
-  return (_a142 = getSpan(context)) === null || _a142 === void 0 ? void 0 : _a142.spanContext();
+function getSpanContext(context2) {
+  var _a21;
+  return (_a21 = getSpan(context2)) === null || _a21 === void 0 ? void 0 : _a21.spanContext();
 }
 var VALID_TRACEID_REGEX = /^([0-9a-f]{32})$/i;
 var VALID_SPANID_REGEX = /^[0-9a-f]{16}$/i;
@@ -3737,22 +4083,22 @@ var NoopTracer = (
   (function() {
     function NoopTracer2() {
     }
-    NoopTracer2.prototype.startSpan = function(name142, options, context) {
-      if (context === void 0) {
-        context = contextApi.active();
+    NoopTracer2.prototype.startSpan = function(name21, options, context2) {
+      if (context2 === void 0) {
+        context2 = contextApi.active();
       }
       var root = Boolean(options === null || options === void 0 ? void 0 : options.root);
       if (root) {
         return new NonRecordingSpan();
       }
-      var parentFromContext = context && getSpanContext(context);
+      var parentFromContext = context2 && getSpanContext(context2);
       if (isSpanContext(parentFromContext) && isSpanContextValid(parentFromContext)) {
         return new NonRecordingSpan(parentFromContext);
       } else {
         return new NonRecordingSpan();
       }
     };
-    NoopTracer2.prototype.startActiveSpan = function(name142, arg2, arg3, arg4) {
+    NoopTracer2.prototype.startActiveSpan = function(name21, arg2, arg3, arg4) {
       var opts;
       var ctx;
       var fn;
@@ -3769,7 +4115,7 @@ var NoopTracer = (
         fn = arg4;
       }
       var parentContext = ctx !== null && ctx !== void 0 ? ctx : contextApi.active();
-      var span = this.startSpan(name142, opts, parentContext);
+      var span = this.startSpan(name21, opts, parentContext);
       var contextWithSpanSet = setSpan(parentContext, span);
       return contextApi.with(contextWithSpanSet, fn, void 0, span);
     };
@@ -3783,14 +4129,14 @@ var NOOP_TRACER = new NoopTracer();
 var ProxyTracer = (
   /** @class */
   (function() {
-    function ProxyTracer2(_provider, name142, version, options) {
+    function ProxyTracer2(_provider, name21, version, options) {
       this._provider = _provider;
-      this.name = name142;
+      this.name = name21;
       this.version = version;
       this.options = options;
     }
-    ProxyTracer2.prototype.startSpan = function(name142, options, context) {
-      return this._getTracer().startSpan(name142, options, context);
+    ProxyTracer2.prototype.startSpan = function(name21, options, context2) {
+      return this._getTracer().startSpan(name21, options, context2);
     };
     ProxyTracer2.prototype.startActiveSpan = function(_name, _options, _context, _fn) {
       var tracer = this._getTracer();
@@ -3827,20 +4173,20 @@ var ProxyTracerProvider = (
   (function() {
     function ProxyTracerProvider2() {
     }
-    ProxyTracerProvider2.prototype.getTracer = function(name142, version, options) {
-      var _a142;
-      return (_a142 = this.getDelegateTracer(name142, version, options)) !== null && _a142 !== void 0 ? _a142 : new ProxyTracer(this, name142, version, options);
+    ProxyTracerProvider2.prototype.getTracer = function(name21, version, options) {
+      var _a21;
+      return (_a21 = this.getDelegateTracer(name21, version, options)) !== null && _a21 !== void 0 ? _a21 : new ProxyTracer(this, name21, version, options);
     };
     ProxyTracerProvider2.prototype.getDelegate = function() {
-      var _a142;
-      return (_a142 = this._delegate) !== null && _a142 !== void 0 ? _a142 : NOOP_TRACER_PROVIDER;
+      var _a21;
+      return (_a21 = this._delegate) !== null && _a21 !== void 0 ? _a21 : NOOP_TRACER_PROVIDER;
     };
     ProxyTracerProvider2.prototype.setDelegate = function(delegate) {
       this._delegate = delegate;
     };
-    ProxyTracerProvider2.prototype.getDelegateTracer = function(name142, version, options) {
-      var _a142;
-      return (_a142 = this._delegate) === null || _a142 === void 0 ? void 0 : _a142.getTracer(name142, version, options);
+    ProxyTracerProvider2.prototype.getDelegateTracer = function(name21, version, options) {
+      var _a21;
+      return (_a21 = this._delegate) === null || _a21 === void 0 ? void 0 : _a21.getTracer(name21, version, options);
     };
     return ProxyTracerProvider2;
   })()
@@ -3851,6 +4197,7 @@ var SpanStatusCode;
   SpanStatusCode2[SpanStatusCode2["OK"] = 1] = "OK";
   SpanStatusCode2[SpanStatusCode2["ERROR"] = 2] = "ERROR";
 })(SpanStatusCode || (SpanStatusCode = {}));
+var context = ContextAPI.getInstance();
 var API_NAME3 = "trace";
 var TraceAPI = (
   /** @class */
@@ -3882,8 +4229,8 @@ var TraceAPI = (
     TraceAPI2.prototype.getTracerProvider = function() {
       return getGlobal(API_NAME3) || this._proxyTracerProvider;
     };
-    TraceAPI2.prototype.getTracer = function(name142, version) {
-      return this.getTracerProvider().getTracer(name142, version);
+    TraceAPI2.prototype.getTracer = function(name21, version) {
+      return this.getTracerProvider().getTracer(name21, version);
     };
     TraceAPI2.prototype.disable = function() {
       unregisterGlobal(API_NAME3, DiagAPI.instance());
@@ -3895,8 +4242,8 @@ var TraceAPI = (
 var trace = TraceAPI.getInstance();
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
-  for (var name142 in all)
-    __defProp(target, name142, { get: all[name142], enumerable: true });
+  for (var name21 in all)
+    __defProp(target, name21, { get: all[name21], enumerable: true });
 };
 var name72 = "AI_InvalidArgumentError";
 var marker82 = `vercel.ai.error.${name72}`;
@@ -3921,10 +4268,28 @@ var InvalidArgumentError2 = class extends AISDKError {
   }
 };
 _a82 = symbol82;
-var name322 = "AI_InvalidToolInputError";
+var name322 = "AI_InvalidToolApprovalError";
 var marker322 = `vercel.ai.error.${name322}`;
 var symbol322 = Symbol.for(marker322);
 var _a322;
+var InvalidToolApprovalError = class extends AISDKError {
+  constructor({ approvalId }) {
+    super({
+      name: name322,
+      message: `Tool approval response references unknown approvalId: "${approvalId}". No matching tool-approval-request found in message history.`
+    });
+    this[_a322] = true;
+    this.approvalId = approvalId;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker322);
+  }
+};
+_a322 = symbol322;
+var name422 = "AI_InvalidToolInputError";
+var marker422 = `vercel.ai.error.${name422}`;
+var symbol422 = Symbol.for(marker422);
+var _a422;
 var InvalidToolInputError = class extends AISDKError {
   constructor({
     toolInput,
@@ -3932,20 +4297,62 @@ var InvalidToolInputError = class extends AISDKError {
     cause,
     message = `Invalid input for tool ${toolName}: ${getErrorMessage(cause)}`
   }) {
-    super({ name: name322, message, cause });
-    this[_a322] = true;
+    super({ name: name422, message, cause });
+    this[_a422] = true;
     this.toolInput = toolInput;
     this.toolName = toolName;
   }
   static isInstance(error) {
-    return AISDKError.hasMarker(error, marker322);
+    return AISDKError.hasMarker(error, marker422);
   }
 };
-_a322 = symbol322;
-var name522 = "AI_NoObjectGeneratedError";
+_a422 = symbol422;
+var name522 = "AI_ToolCallNotFoundForApprovalError";
 var marker522 = `vercel.ai.error.${name522}`;
 var symbol522 = Symbol.for(marker522);
 var _a522;
+var ToolCallNotFoundForApprovalError = class extends AISDKError {
+  constructor({
+    toolCallId,
+    approvalId
+  }) {
+    super({
+      name: name522,
+      message: `Tool call "${toolCallId}" not found for approval request "${approvalId}".`
+    });
+    this[_a522] = true;
+    this.toolCallId = toolCallId;
+    this.approvalId = approvalId;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker522);
+  }
+};
+_a522 = symbol522;
+var name622 = "AI_MissingToolResultsError";
+var marker622 = `vercel.ai.error.${name622}`;
+var symbol622 = Symbol.for(marker622);
+var _a622;
+var MissingToolResultsError = class extends AISDKError {
+  constructor({ toolCallIds }) {
+    super({
+      name: name622,
+      message: `Tool result${toolCallIds.length > 1 ? "s are" : " is"} missing for tool call${toolCallIds.length > 1 ? "s" : ""} ${toolCallIds.join(
+        ", "
+      )}.`
+    });
+    this[_a622] = true;
+    this.toolCallIds = toolCallIds;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker622);
+  }
+};
+_a622 = symbol622;
+var name82 = "AI_NoObjectGeneratedError";
+var marker822 = `vercel.ai.error.${name82}`;
+var symbol822 = Symbol.for(marker822);
+var _a822;
 var NoObjectGeneratedError = class extends AISDKError {
   constructor({
     message = "No object generated.",
@@ -3955,75 +4362,75 @@ var NoObjectGeneratedError = class extends AISDKError {
     usage,
     finishReason
   }) {
-    super({ name: name522, message, cause });
-    this[_a522] = true;
+    super({ name: name82, message, cause });
+    this[_a822] = true;
     this.text = text2;
     this.response = response;
     this.usage = usage;
     this.finishReason = finishReason;
   }
   static isInstance(error) {
-    return AISDKError.hasMarker(error, marker522);
+    return AISDKError.hasMarker(error, marker822);
   }
 };
-_a522 = symbol522;
-var name622 = "AI_NoOutputGeneratedError";
-var marker622 = `vercel.ai.error.${name622}`;
-var symbol622 = Symbol.for(marker622);
-var _a622;
+_a822 = symbol822;
+var name92 = "AI_NoOutputGeneratedError";
+var marker92 = `vercel.ai.error.${name92}`;
+var symbol92 = Symbol.for(marker92);
+var _a92;
 var NoOutputGeneratedError = class extends AISDKError {
   // used in isInstance
   constructor({
     message = "No output generated.",
     cause
   } = {}) {
-    super({ name: name622, message, cause });
-    this[_a622] = true;
+    super({ name: name92, message, cause });
+    this[_a92] = true;
   }
   static isInstance(error) {
-    return AISDKError.hasMarker(error, marker622);
+    return AISDKError.hasMarker(error, marker92);
   }
 };
-_a622 = symbol622;
-var name722 = "AI_NoSuchToolError";
-var marker722 = `vercel.ai.error.${name722}`;
-var symbol722 = Symbol.for(marker722);
-var _a722;
+_a92 = symbol92;
+var name132 = "AI_NoSuchToolError";
+var marker132 = `vercel.ai.error.${name132}`;
+var symbol132 = Symbol.for(marker132);
+var _a132;
 var NoSuchToolError = class extends AISDKError {
   constructor({
     toolName,
     availableTools = void 0,
     message = `Model tried to call unavailable tool '${toolName}'. ${availableTools === void 0 ? "No tools are available." : `Available tools: ${availableTools.join(", ")}.`}`
   }) {
-    super({ name: name722, message });
-    this[_a722] = true;
+    super({ name: name132, message });
+    this[_a132] = true;
     this.toolName = toolName;
     this.availableTools = availableTools;
   }
   static isInstance(error) {
-    return AISDKError.hasMarker(error, marker722);
+    return AISDKError.hasMarker(error, marker132);
   }
 };
-_a722 = symbol722;
-var name82 = "AI_ToolCallRepairError";
-var marker822 = `vercel.ai.error.${name82}`;
-var symbol822 = Symbol.for(marker822);
-var _a822;
+_a132 = symbol132;
+var name142 = "AI_ToolCallRepairError";
+var marker142 = `vercel.ai.error.${name142}`;
+var symbol142 = Symbol.for(marker142);
+var _a142;
 var ToolCallRepairError = class extends AISDKError {
   constructor({
     cause,
     originalError,
     message = `Error repairing tool call: ${getErrorMessage(cause)}`
   }) {
-    super({ name: name82, message, cause });
-    this[_a822] = true;
+    super({ name: name142, message, cause });
+    this[_a142] = true;
     this.originalError = originalError;
   }
   static isInstance(error) {
-    return AISDKError.hasMarker(error, marker822);
+    return AISDKError.hasMarker(error, marker142);
   }
 };
-_a822 = symbol822;
+_a142 = symbol142;
 var UnsupportedModelVersionError = class extends AISDKError {
   constructor(options) {
     super({
@@ -4035,45 +4442,65 @@ var UnsupportedModelVersionError = class extends AISDKError {
     this.modelId = options.modelId;
   }
 };
-var name102 = "AI_InvalidMessageRoleError";
-var marker102 = `vercel.ai.error.${name102}`;
-var symbol102 = Symbol.for(marker102);
-var _a102;
+var name152 = "AI_UIMessageStreamError";
+var marker152 = `vercel.ai.error.${name152}`;
+var symbol152 = Symbol.for(marker152);
+var _a152;
+var UIMessageStreamError = class extends AISDKError {
+  constructor({
+    chunkType,
+    chunkId,
+    message
+  }) {
+    super({ name: name152, message });
+    this[_a152] = true;
+    this.chunkType = chunkType;
+    this.chunkId = chunkId;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker152);
+  }
+};
+_a152 = symbol152;
+var name17 = "AI_InvalidMessageRoleError";
+var marker17 = `vercel.ai.error.${name17}`;
+var symbol17 = Symbol.for(marker17);
+var _a17;
 var InvalidMessageRoleError = class extends AISDKError {
   constructor({
     role,
     message = `Invalid message role: '${role}'. Must be one of: "system", "user", "assistant", "tool".`
   }) {
-    super({ name: name102, message });
-    this[_a102] = true;
+    super({ name: name17, message });
+    this[_a17] = true;
     this.role = role;
   }
   static isInstance(error) {
-    return AISDKError.hasMarker(error, marker102);
+    return AISDKError.hasMarker(error, marker17);
   }
 };
-_a102 = symbol102;
-var name122 = "AI_RetryError";
-var marker122 = `vercel.ai.error.${name122}`;
-var symbol122 = Symbol.for(marker122);
-var _a122;
+_a17 = symbol17;
+var name19 = "AI_RetryError";
+var marker19 = `vercel.ai.error.${name19}`;
+var symbol19 = Symbol.for(marker19);
+var _a19;
 var RetryError = class extends AISDKError {
   constructor({
     message,
     reason,
     errors
   }) {
-    super({ name: name122, message });
-    this[_a122] = true;
+    super({ name: name19, message });
+    this[_a19] = true;
     this.reason = reason;
     this.errors = errors;
     this.lastError = errors[errors.length - 1];
   }
   static isInstance(error) {
-    return AISDKError.hasMarker(error, marker122);
+    return AISDKError.hasMarker(error, marker19);
   }
 };
-_a122 = symbol122;
+_a19 = symbol19;
 function formatWarning({
   warning,
   provider,
@@ -4269,8 +4696,29 @@ function resolveEmbeddingModel(model) {
   return getGlobalProvider().embeddingModel(model);
 }
 function getGlobalProvider() {
-  var _a142;
-  return (_a142 = globalThis.AI_SDK_DEFAULT_PROVIDER) != null ? _a142 : gateway;
+  var _a21;
+  return (_a21 = globalThis.AI_SDK_DEFAULT_PROVIDER) != null ? _a21 : gateway;
+}
+function getTotalTimeoutMs(timeout) {
+  if (timeout == null) {
+    return void 0;
+  }
+  if (typeof timeout === "number") {
+    return timeout;
+  }
+  return timeout.totalMs;
+}
+function getStepTimeoutMs(timeout) {
+  if (timeout == null || typeof timeout === "number") {
+    return void 0;
+  }
+  return timeout.stepMs;
+}
+function getChunkTimeoutMs(timeout) {
+  if (timeout == null || typeof timeout === "number") {
+    return void 0;
+  }
+  return timeout.chunkMs;
 }
 var imageMediaTypeSignatures = [
   {
@@ -4383,9 +4831,9 @@ function detectMediaType({
   }
   return void 0;
 }
-var VERSION3 = "6.0.1";
+var VERSION3 = "6.0.69";
 var download = async ({ url }) => {
-  var _a142;
+  var _a21;
   const urlText = url.toString();
   try {
     const response = await fetch(urlText, {
@@ -4404,7 +4852,7 @@ var download = async ({ url }) => {
     }
     return {
       data: new Uint8Array(await response.arrayBuffer()),
-      mediaType: (_a142 = response.headers.get("content-type")) != null ? _a142 : void 0
+      mediaType: (_a21 = response.headers.get("content-type")) != null ? _a21 : void 0
     };
   } catch (error) {
     if (DownloadError.isInstance(error)) {
@@ -4439,8 +4887,8 @@ var dataContentSchema = z.union([
   z.custom(
     // Buffer might not be available in some environments such as CloudFlare:
     (value) => {
-      var _a142, _b82;
-      return (_b82 = (_a142 = globalThis.Buffer) == null ? void 0 : _a142.isBuffer(value)) != null ? _b82 : false;
+      var _a21, _b82;
+      return (_b82 = (_a21 = globalThis.Buffer) == null ? void 0 : _a21.isBuffer(value)) != null ? _b82 : false;
     },
     { message: "Must be a Buffer" }
   )
@@ -4494,6 +4942,32 @@ async function convertToLanguageModelPrompt({
     download2,
     supportedUrls
   );
+  const approvalIdToToolCallId = /* @__PURE__ */ new Map();
+  for (const message of prompt.messages) {
+    if (message.role === "assistant" && Array.isArray(message.content)) {
+      for (const part of message.content) {
+        if (part.type === "tool-approval-request" && "approvalId" in part && "toolCallId" in part) {
+          approvalIdToToolCallId.set(
+            part.approvalId,
+            part.toolCallId
+          );
+        }
+      }
+    }
+  }
+  const approvedToolCallIds = /* @__PURE__ */ new Set();
+  for (const message of prompt.messages) {
+    if (message.role === "tool") {
+      for (const part of message.content) {
+        if (part.type === "tool-approval-response") {
+          const toolCallId = approvalIdToToolCallId.get(part.approvalId);
+          if (toolCallId) {
+            approvedToolCallIds.add(toolCallId);
+          }
+        }
+      }
+    }
+  }
   const messages = [
     ...prompt.system != null ? typeof prompt.system === "string" ? [{ role: "system", content: prompt.system }] : asArray(prompt.system).map((message) => ({
       role: "system",
@@ -4517,23 +4991,67 @@ async function convertToLanguageModelPrompt({
       combinedMessages.push(message);
     }
   }
-  return combinedMessages;
-}
-function convertToLanguageModelMessage({
-  message,
-  downloadedAssets
-}) {
-  const role = message.role;
-  switch (role) {
-    case "system": {
-      return {
-        role: "system",
-        content: message.content,
-        providerOptions: message.providerOptions
-      };
-    }
-    case "user": {
-      if (typeof message.content === "string") {
+  const toolCallIds = /* @__PURE__ */ new Set();
+  for (const message of combinedMessages) {
+    switch (message.role) {
+      case "assistant": {
+        for (const content of message.content) {
+          if (content.type === "tool-call" && !content.providerExecuted) {
+            toolCallIds.add(content.toolCallId);
+          }
+        }
+        break;
+      }
+      case "tool": {
+        for (const content of message.content) {
+          if (content.type === "tool-result") {
+            toolCallIds.delete(content.toolCallId);
+          }
+        }
+        break;
+      }
+      case "user":
+      case "system":
+        for (const id of approvedToolCallIds) {
+          toolCallIds.delete(id);
+        }
+        if (toolCallIds.size > 0) {
+          throw new MissingToolResultsError({
+            toolCallIds: Array.from(toolCallIds)
+          });
+        }
+        break;
+    }
+  }
+  for (const id of approvedToolCallIds) {
+    toolCallIds.delete(id);
+  }
+  if (toolCallIds.size > 0) {
+    throw new MissingToolResultsError({ toolCallIds: Array.from(toolCallIds) });
+  }
+  return combinedMessages.filter(
+    // Filter out empty tool messages (e.g. if they only contained
+    // tool-approval-response parts that were removed).
+    // This prevents sending invalid empty messages to the provider.
+    // Note: provider-executed tool-approval-response parts are preserved.
+    (message) => message.role !== "tool" || message.content.length > 0
+  );
+}
+function convertToLanguageModelMessage({
+  message,
+  downloadedAssets
+}) {
+  const role = message.role;
+  switch (role) {
+    case "system": {
+      return {
+        role: "system",
+        content: message.content,
+        providerOptions: message.providerOptions
+      };
+    }
+    case "user": {
+      if (typeof message.content === "string") {
         return {
           role: "user",
           content: [{ type: "text", text: message.content }],
@@ -4617,13 +5135,30 @@ function convertToLanguageModelMessage({
     case "tool": {
       return {
         role: "tool",
-        content: message.content.filter((part) => part.type !== "tool-approval-response").map((part) => ({
-          type: "tool-result",
-          toolCallId: part.toolCallId,
-          toolName: part.toolName,
-          output: mapToolResultOutput(part.output),
-          providerOptions: part.providerOptions
-        })),
+        content: message.content.filter(
+          // Only include tool-approval-response for provider-executed tools
+          (part) => part.type !== "tool-approval-response" || part.providerExecuted
+        ).map((part) => {
+          switch (part.type) {
+            case "tool-result": {
+              return {
+                type: "tool-result",
+                toolCallId: part.toolCallId,
+                toolName: part.toolName,
+                output: mapToolResultOutput(part.output),
+                providerOptions: part.providerOptions
+              };
+            }
+            case "tool-approval-response": {
+              return {
+                type: "tool-approval-response",
+                approvalId: part.approvalId,
+                approved: part.approved,
+                reason: part.reason
+              };
+            }
+          }
+        }),
         providerOptions: message.providerOptions
       };
     }
@@ -4639,8 +5174,8 @@ async function downloadAssets(messages, download2, supportedUrls) {
   ).flat().filter(
     (part) => part.type === "image" || part.type === "file"
   ).map((part) => {
-    var _a142;
-    const mediaType = (_a142 = part.mediaType) != null ? _a142 : part.type === "image" ? "image/*" : void 0;
+    var _a21;
+    const mediaType = (_a21 = part.mediaType) != null ? _a21 : part.type === "image" ? "image/*" : void 0;
     let data = part.type === "image" ? part.image : part.data;
     if (typeof data === "string") {
       try {
@@ -4670,7 +5205,7 @@ async function downloadAssets(messages, download2, supportedUrls) {
   );
 }
 function convertPartToLanguageModelPart(part, downloadedAssets) {
-  var _a142;
+  var _a21;
   if (part.type === "text") {
     return {
       type: "text",
@@ -4703,7 +5238,7 @@ function convertPartToLanguageModelPart(part, downloadedAssets) {
   switch (type) {
     case "image": {
       if (data instanceof Uint8Array || typeof data === "string") {
-        mediaType = (_a142 = detectMediaType({ data, signatures: imageMediaTypeSignatures })) != null ? _a142 : mediaType;
+        mediaType = (_a21 = detectMediaType({ data, signatures: imageMediaTypeSignatures })) != null ? _a21 : mediaType;
       }
       return {
         type: "file",
@@ -4879,10 +5414,10 @@ async function prepareToolsAndToolChoice({
     };
   }
   const filteredTools = activeTools != null ? Object.entries(tools).filter(
-    ([name142]) => activeTools.includes(name142)
+    ([name21]) => activeTools.includes(name21)
   ) : Object.entries(tools);
   const languageModelTools = [];
-  for (const [name142, tool2] of filteredTools) {
+  for (const [name21, tool2] of filteredTools) {
     const toolType = tool2.type;
     switch (toolType) {
       case void 0:
@@ -4890,7 +5425,7 @@ async function prepareToolsAndToolChoice({
       case "function":
         languageModelTools.push({
           type: "function",
-          name: name142,
+          name: name21,
           description: tool2.description,
           inputSchema: await asSchema(tool2.inputSchema).jsonSchema,
           ...tool2.inputExamples != null ? { inputExamples: tool2.inputExamples } : {},
@@ -4901,7 +5436,7 @@ async function prepareToolsAndToolChoice({
       case "provider":
         languageModelTools.push({
           type: "provider",
-          name: name142,
+          name: name21,
           id: tool2.id,
           args: tool2.args
         });
@@ -5206,17 +5741,26 @@ function getBaseTelemetryAttributes({
   telemetry,
   headers
 }) {
-  var _a142;
+  var _a21;
   return {
     "ai.model.provider": model.provider,
     "ai.model.id": model.modelId,
     // settings:
     ...Object.entries(settings).reduce((attributes, [key, value]) => {
-      attributes[`ai.settings.${key}`] = value;
+      if (key === "timeout") {
+        const totalTimeoutMs = getTotalTimeoutMs(
+          value
+        );
+        if (totalTimeoutMs != null) {
+          attributes[`ai.settings.${key}`] = totalTimeoutMs;
+        }
+      } else {
+        attributes[`ai.settings.${key}`] = value;
+      }
       return attributes;
     }, {}),
     // add metadata as attributes:
-    ...Object.entries((_a142 = telemetry == null ? void 0 : telemetry.metadata) != null ? _a142 : {}).reduce(
+    ...Object.entries((_a21 = telemetry == null ? void 0 : telemetry.metadata) != null ? _a21 : {}).reduce(
       (attributes, [key, value]) => {
         attributes[`ai.telemetry.metadata.${key}`] = value;
         return attributes;
@@ -5236,7 +5780,7 @@ var noopTracer = {
   startSpan() {
     return noopSpan;
   },
-  startActiveSpan(name142, arg1, arg2, arg3) {
+  startActiveSpan(name21, arg1, arg2, arg3) {
     if (typeof arg1 === "function") {
       return arg1(noopSpan);
     }
@@ -5301,18 +5845,19 @@ function getTracer({
   return trace.getTracer("ai");
 }
 async function recordSpan({
-  name: name142,
+  name: name21,
   tracer,
   attributes,
   fn,
   endWhenDone = true
 }) {
   return tracer.startActiveSpan(
-    name142,
+    name21,
     { attributes: await attributes },
     async (span) => {
+      const ctx = context.active();
       try {
-        const result = await fn(span);
+        const result = await context.with(ctx, () => fn(span));
         if (endWhenDone) {
           span.end();
         }
@@ -5432,12 +5977,12 @@ function createNullLanguageModelUsage() {
   };
 }
 function addLanguageModelUsage(usage1, usage2) {
-  var _a142, _b82, _c, _d, _e, _f, _g, _h, _i, _j;
+  var _a21, _b82, _c, _d, _e, _f, _g, _h, _i, _j;
   return {
     inputTokens: addTokenCounts(usage1.inputTokens, usage2.inputTokens),
     inputTokenDetails: {
       noCacheTokens: addTokenCounts(
-        (_a142 = usage1.inputTokenDetails) == null ? void 0 : _a142.noCacheTokens,
+        (_a21 = usage1.inputTokenDetails) == null ? void 0 : _a21.noCacheTokens,
         (_b82 = usage2.inputTokenDetails) == null ? void 0 : _b82.noCacheTokens
       ),
       cacheReadTokens: addTokenCounts(
@@ -5673,13 +6218,25 @@ function collectToolApprovals({
   );
   for (const approvalResponse of approvalResponses) {
     const approvalRequest = toolApprovalRequestsByApprovalId[approvalResponse.approvalId];
+    if (approvalRequest == null) {
+      throw new InvalidToolApprovalError({
+        approvalId: approvalResponse.approvalId
+      });
+    }
     if (toolResults[approvalRequest.toolCallId] != null) {
       continue;
     }
+    const toolCall = toolCallsByToolCallId[approvalRequest.toolCallId];
+    if (toolCall == null) {
+      throw new ToolCallNotFoundForApprovalError({
+        toolCallId: approvalRequest.toolCallId,
+        approvalId: approvalRequest.approvalId
+      });
+    }
     const approval = {
       approvalRequest,
       approvalResponse,
-      toolCall: toolCallsByToolCallId[approvalRequest.toolCallId]
+      toolCall
     };
     if (approvalResponse.approved) {
       approvedToolApprovals.push(approval);
@@ -6180,37 +6737,42 @@ async function parsePartialJson(jsonText) {
   return { value: void 0, state: "failed-parse" };
 }
 var text = () => ({
+  name: "text",
   responseFormat: Promise.resolve({ type: "text" }),
   async parseCompleteOutput({ text: text2 }) {
     return text2;
   },
   async parsePartialOutput({ text: text2 }) {
     return { partial: text2 };
+  },
+  createElementStreamTransform() {
+    return void 0;
   }
 });
 var object = ({
   schema: inputSchema,
-  name: name142,
+  name: name21,
   description
 }) => {
   const schema = asSchema(inputSchema);
   return {
+    name: "object",
     responseFormat: resolve(schema.jsonSchema).then((jsonSchema2) => ({
       type: "json",
       schema: jsonSchema2,
-      ...name142 != null && { name: name142 },
+      ...name21 != null && { name: name21 },
       ...description != null && { description }
     })),
-    async parseCompleteOutput({ text: text2 }, context) {
+    async parseCompleteOutput({ text: text2 }, context2) {
       const parseResult = await safeParseJSON({ text: text2 });
       if (!parseResult.success) {
         throw new NoObjectGeneratedError({
           message: "No object generated: could not parse the response.",
           cause: parseResult.error,
           text: text2,
-          response: context.response,
-          usage: context.usage,
-          finishReason: context.finishReason
+          response: context2.response,
+          usage: context2.usage,
+          finishReason: context2.finishReason
         });
       }
       const validationResult = await safeValidateTypes({
@@ -6222,9 +6784,9 @@ var object = ({
           message: "No object generated: response did not match schema.",
           cause: validationResult.error,
           text: text2,
-          response: context.response,
-          usage: context.usage,
-          finishReason: context.finishReason
+          response: context2.response,
+          usage: context2.usage,
+          finishReason: context2.finishReason
         });
       }
       return validationResult.value;
@@ -6244,16 +6806,20 @@ var object = ({
           };
         }
       }
+    },
+    createElementStreamTransform() {
+      return void 0;
     }
   };
 };
 var array = ({
   element: inputElementSchema,
-  name: name142,
+  name: name21,
   description
 }) => {
   const elementSchema = asSchema(inputElementSchema);
   return {
+    name: "array",
     // JSON schema that describes an array of elements:
     responseFormat: resolve(elementSchema.jsonSchema).then((jsonSchema2) => {
       const { $schema, ...itemSchema } = jsonSchema2;
@@ -6268,20 +6834,20 @@ var array = ({
           required: ["elements"],
           additionalProperties: false
         },
-        ...name142 != null && { name: name142 },
+        ...name21 != null && { name: name21 },
         ...description != null && { description }
       };
     }),
-    async parseCompleteOutput({ text: text2 }, context) {
+    async parseCompleteOutput({ text: text2 }, context2) {
       const parseResult = await safeParseJSON({ text: text2 });
       if (!parseResult.success) {
         throw new NoObjectGeneratedError({
           message: "No object generated: could not parse the response.",
           cause: parseResult.error,
           text: text2,
-          response: context.response,
-          usage: context.usage,
-          finishReason: context.finishReason
+          response: context2.response,
+          usage: context2.usage,
+          finishReason: context2.finishReason
         });
       }
       const outerValue = parseResult.value;
@@ -6293,9 +6859,9 @@ var array = ({
             cause: "response must be an object with an elements array"
           }),
           text: text2,
-          response: context.response,
-          usage: context.usage,
-          finishReason: context.finishReason
+          response: context2.response,
+          usage: context2.usage,
+          finishReason: context2.finishReason
         });
       }
       for (const element of outerValue.elements) {
@@ -6308,9 +6874,9 @@ var array = ({
             message: "No object generated: response did not match schema.",
             cause: validationResult.error,
             text: text2,
-            response: context.response,
-            usage: context.usage,
-            finishReason: context.finishReason
+            response: context2.response,
+            usage: context2.usage,
+            finishReason: context2.finishReason
           });
         }
       }
@@ -6343,15 +6909,28 @@ var array = ({
           return { partial: parsedElements };
         }
       }
+    },
+    createElementStreamTransform() {
+      let publishedElements = 0;
+      return new TransformStream({
+        transform({ partialOutput }, controller) {
+          if (partialOutput != null) {
+            for (; publishedElements < partialOutput.length; publishedElements++) {
+              controller.enqueue(partialOutput[publishedElements]);
+            }
+          }
+        }
+      });
     }
   };
 };
 var choice = ({
   options: choiceOptions,
-  name: name142,
+  name: name21,
   description
 }) => {
   return {
+    name: "choice",
     // JSON schema that describes an enumeration:
     responseFormat: Promise.resolve({
       type: "json",
@@ -6364,19 +6943,19 @@ var choice = ({
         required: ["result"],
         additionalProperties: false
       },
-      ...name142 != null && { name: name142 },
+      ...name21 != null && { name: name21 },
       ...description != null && { description }
     }),
-    async parseCompleteOutput({ text: text2 }, context) {
+    async parseCompleteOutput({ text: text2 }, context2) {
       const parseResult = await safeParseJSON({ text: text2 });
       if (!parseResult.success) {
         throw new NoObjectGeneratedError({
           message: "No object generated: could not parse the response.",
           cause: parseResult.error,
           text: text2,
-          response: context.response,
-          usage: context.usage,
-          finishReason: context.finishReason
+          response: context2.response,
+          usage: context2.usage,
+          finishReason: context2.finishReason
         });
       }
       const outerValue = parseResult.value;
@@ -6388,9 +6967,9 @@ var choice = ({
             cause: "response must be an object that contains a choice value."
           }),
           text: text2,
-          response: context.response,
-          usage: context.usage,
-          finishReason: context.finishReason
+          response: context2.response,
+          usage: context2.usage,
+          finishReason: context2.finishReason
         });
       }
       return outerValue.result;
@@ -6418,29 +6997,33 @@ var choice = ({
           }
         }
       }
+    },
+    createElementStreamTransform() {
+      return void 0;
     }
   };
 };
 var json = ({
-  name: name142,
+  name: name21,
   description
 } = {}) => {
   return {
+    name: "json",
     responseFormat: Promise.resolve({
       type: "json",
-      ...name142 != null && { name: name142 },
+      ...name21 != null && { name: name21 },
       ...description != null && { description }
     }),
-    async parseCompleteOutput({ text: text2 }, context) {
+    async parseCompleteOutput({ text: text2 }, context2) {
       const parseResult = await safeParseJSON({ text: text2 });
       if (!parseResult.success) {
         throw new NoObjectGeneratedError({
           message: "No object generated: could not parse the response.",
           cause: parseResult.error,
           text: text2,
-          response: context.response,
-          usage: context.usage,
-          finishReason: context.finishReason
+          response: context2.response,
+          usage: context2.usage,
+          finishReason: context2.finishReason
         });
       }
       return parseResult.value;
@@ -6457,6 +7040,9 @@ var json = ({
           return result.value === void 0 ? void 0 : { partial: result.value };
         }
       }
+    },
+    createElementStreamTransform() {
+      return void 0;
     }
   };
 };
@@ -6467,7 +7053,7 @@ async function parseToolCall({
   system,
   messages
 }) {
-  var _a142;
+  var _a21;
   try {
     if (tools == null) {
       if (toolCall.providerExecuted && toolCall.dynamic) {
@@ -6516,7 +7102,7 @@ async function parseToolCall({
       dynamic: true,
       invalid: true,
       error,
-      title: (_a142 = tools == null ? void 0 : tools[toolCall.toolName]) == null ? void 0 : _a142.title,
+      title: (_a21 = tools == null ? void 0 : tools[toolCall.toolName]) == null ? void 0 : _a21.title,
       providerExecuted: toolCall.providerExecuted,
       providerMetadata: toolCall.providerMetadata
     };
@@ -6662,7 +7248,13 @@ async function toResponseMessages({
   const responseMessages = [];
   const content = [];
   for (const part of inputContent) {
-    if (part.type === "source" || (part.type === "tool-result" || part.type === "tool-error") && !part.providerExecuted || part.type === "text" && part.text.length === 0) {
+    if (part.type === "source") {
+      continue;
+    }
+    if ((part.type === "tool-result" || part.type === "tool-error") && !part.providerExecuted) {
+      continue;
+    }
+    if (part.type === "text" && part.text.length === 0) {
       continue;
     }
     switch (part.type) {
@@ -6775,6 +7367,32 @@ async function toResponseMessages({
   }
   return responseMessages;
 }
+function mergeAbortSignals(...signals) {
+  const validSignals = signals.filter(
+    (signal) => signal != null
+  );
+  if (validSignals.length === 0) {
+    return void 0;
+  }
+  if (validSignals.length === 1) {
+    return validSignals[0];
+  }
+  const controller = new AbortController();
+  for (const signal of validSignals) {
+    if (signal.aborted) {
+      controller.abort(signal.reason);
+      return controller.signal;
+    }
+    signal.addEventListener(
+      "abort",
+      () => {
+        controller.abort(signal.reason);
+      },
+      { once: true }
+    );
+  }
+  return controller.signal;
+}
 var originalGenerateId = createIdGenerator({
   prefix: "aitxt",
   size: 24
@@ -6788,6 +7406,7 @@ async function generateText({
   messages,
   maxRetries: maxRetriesArg,
   abortSignal,
+  timeout,
   headers,
   stopWhen = stepCountIs(1),
   experimental_output,
@@ -6801,19 +7420,25 @@ async function generateText({
   experimental_repairToolCall: repairToolCall,
   experimental_download: download2,
   experimental_context,
-  _internal: {
-    generateId: generateId2 = originalGenerateId,
-    currentDate = () => /* @__PURE__ */ new Date()
-  } = {},
+  experimental_include: include,
+  _internal: { generateId: generateId2 = originalGenerateId } = {},
   onStepFinish,
   onFinish,
   ...settings
 }) {
   const model = resolveLanguageModel(modelArg);
   const stopConditions = asArray(stopWhen);
+  const totalTimeoutMs = getTotalTimeoutMs(timeout);
+  const stepTimeoutMs = getStepTimeoutMs(timeout);
+  const stepAbortController = stepTimeoutMs != null ? new AbortController() : void 0;
+  const mergedAbortSignal = mergeAbortSignals(
+    abortSignal,
+    totalTimeoutMs != null ? AbortSignal.timeout(totalTimeoutMs) : void 0,
+    stepAbortController == null ? void 0 : stepAbortController.signal
+  );
   const { maxRetries, retry } = prepareRetries({
     maxRetries: maxRetriesArg,
-    abortSignal
+    abortSignal: mergedAbortSignal
   });
   const callSettings = prepareCallSettings(settings);
   const headersWithUserAgent = withUserAgentSuffix(
@@ -6854,20 +7479,23 @@ async function generateText({
       }),
       tracer,
       fn: async (span) => {
-        var _a142, _b82, _c, _d, _e, _f, _g, _h;
+        var _a21, _b82, _c, _d, _e, _f, _g, _h, _i, _j, _k;
         const initialMessages = initialPrompt.messages;
         const responseMessages = [];
         const { approvedToolApprovals, deniedToolApprovals } = collectToolApprovals({ messages: initialMessages });
-        if (deniedToolApprovals.length > 0 || approvedToolApprovals.length > 0) {
+        const localApprovedToolApprovals = approvedToolApprovals.filter(
+          (toolApproval) => !toolApproval.toolCall.providerExecuted
+        );
+        if (deniedToolApprovals.length > 0 || localApprovedToolApprovals.length > 0) {
           const toolOutputs = await executeTools({
-            toolCalls: approvedToolApprovals.map(
+            toolCalls: localApprovedToolApprovals.map(
               (toolApproval) => toolApproval.toolCall
             ),
             tools,
             tracer,
             telemetry,
             messages: initialMessages,
-            abortSignal,
+            abortSignal: mergedAbortSignal,
             experimental_context
           });
           const toolContent = [];
@@ -6893,7 +7521,15 @@ async function generateText({
               toolName: toolApproval.toolCall.toolName,
               output: {
                 type: "execution-denied",
-                reason: toolApproval.approvalResponse.reason
+                reason: toolApproval.approvalResponse.reason,
+                // For provider-executed tools, include approvalId so provider can correlate
+                ...toolApproval.toolCall.providerExecuted && {
+                  providerOptions: {
+                    openai: {
+                      approvalId: toolApproval.approvalResponse.approvalId
+                    }
+                  }
+                }
               }
             });
           }
@@ -6902,6 +7538,24 @@ async function generateText({
             content: toolContent
           });
         }
+        const providerExecutedToolApprovals = [
+          ...approvedToolApprovals,
+          ...deniedToolApprovals
+        ].filter((toolApproval) => toolApproval.toolCall.providerExecuted);
+        if (providerExecutedToolApprovals.length > 0) {
+          responseMessages.push({
+            role: "tool",
+            content: providerExecutedToolApprovals.map(
+              (toolApproval) => ({
+                type: "tool-approval-response",
+                approvalId: toolApproval.approvalResponse.approvalId,
+                approved: toolApproval.approvalResponse.approved,
+                reason: toolApproval.approvalResponse.reason,
+                providerExecuted: true
+              })
+            )
+          });
+        }
         const callSettings2 = prepareCallSettings(settings);
         let currentModelResponse;
         let clientToolCalls = [];
@@ -6909,263 +7563,274 @@ async function generateText({
         const steps = [];
         const pendingDeferredToolCalls = /* @__PURE__ */ new Map();
         do {
-          const stepInputMessages = [...initialMessages, ...responseMessages];
-          const prepareStepResult = await (prepareStep == null ? void 0 : prepareStep({
-            model,
-            steps,
-            stepNumber: steps.length,
-            messages: stepInputMessages,
-            experimental_context
-          }));
-          const stepModel = resolveLanguageModel(
-            (_a142 = prepareStepResult == null ? void 0 : prepareStepResult.model) != null ? _a142 : model
-          );
-          const promptMessages = await convertToLanguageModelPrompt({
-            prompt: {
-              system: (_b82 = prepareStepResult == null ? void 0 : prepareStepResult.system) != null ? _b82 : initialPrompt.system,
-              messages: (_c = prepareStepResult == null ? void 0 : prepareStepResult.messages) != null ? _c : stepInputMessages
-            },
-            supportedUrls: await stepModel.supportedUrls,
-            download: download2
-          });
-          experimental_context = (_d = prepareStepResult == null ? void 0 : prepareStepResult.experimental_context) != null ? _d : experimental_context;
-          const { toolChoice: stepToolChoice, tools: stepTools } = await prepareToolsAndToolChoice({
-            tools,
-            toolChoice: (_e = prepareStepResult == null ? void 0 : prepareStepResult.toolChoice) != null ? _e : toolChoice,
-            activeTools: (_f = prepareStepResult == null ? void 0 : prepareStepResult.activeTools) != null ? _f : activeTools
-          });
-          currentModelResponse = await retry(
-            () => {
-              var _a152;
-              return recordSpan({
-                name: "ai.generateText.doGenerate",
-                attributes: selectTelemetryAttributes({
-                  telemetry,
-                  attributes: {
-                    ...assembleOperationName({
-                      operationId: "ai.generateText.doGenerate",
-                      telemetry
-                    }),
-                    ...baseTelemetryAttributes,
-                    // model:
-                    "ai.model.provider": stepModel.provider,
-                    "ai.model.id": stepModel.modelId,
-                    // prompt:
-                    "ai.prompt.messages": {
-                      input: () => stringifyForTelemetry(promptMessages)
-                    },
-                    "ai.prompt.tools": {
-                      // convert the language model level tools:
-                      input: () => stepTools == null ? void 0 : stepTools.map((tool2) => JSON.stringify(tool2))
-                    },
-                    "ai.prompt.toolChoice": {
-                      input: () => stepToolChoice != null ? JSON.stringify(stepToolChoice) : void 0
-                    },
-                    // standardized gen-ai llm span attributes:
-                    "gen_ai.system": stepModel.provider,
-                    "gen_ai.request.model": stepModel.modelId,
-                    "gen_ai.request.frequency_penalty": settings.frequencyPenalty,
-                    "gen_ai.request.max_tokens": settings.maxOutputTokens,
-                    "gen_ai.request.presence_penalty": settings.presencePenalty,
-                    "gen_ai.request.stop_sequences": settings.stopSequences,
-                    "gen_ai.request.temperature": (_a152 = settings.temperature) != null ? _a152 : void 0,
-                    "gen_ai.request.top_k": settings.topK,
-                    "gen_ai.request.top_p": settings.topP
+          const stepTimeoutId = stepTimeoutMs != null ? setTimeout(() => stepAbortController.abort(), stepTimeoutMs) : void 0;
+          try {
+            const stepInputMessages = [...initialMessages, ...responseMessages];
+            const prepareStepResult = await (prepareStep == null ? void 0 : prepareStep({
+              model,
+              steps,
+              stepNumber: steps.length,
+              messages: stepInputMessages,
+              experimental_context
+            }));
+            const stepModel = resolveLanguageModel(
+              (_a21 = prepareStepResult == null ? void 0 : prepareStepResult.model) != null ? _a21 : model
+            );
+            const promptMessages = await convertToLanguageModelPrompt({
+              prompt: {
+                system: (_b82 = prepareStepResult == null ? void 0 : prepareStepResult.system) != null ? _b82 : initialPrompt.system,
+                messages: (_c = prepareStepResult == null ? void 0 : prepareStepResult.messages) != null ? _c : stepInputMessages
+              },
+              supportedUrls: await stepModel.supportedUrls,
+              download: download2
+            });
+            experimental_context = (_d = prepareStepResult == null ? void 0 : prepareStepResult.experimental_context) != null ? _d : experimental_context;
+            const { toolChoice: stepToolChoice, tools: stepTools } = await prepareToolsAndToolChoice({
+              tools,
+              toolChoice: (_e = prepareStepResult == null ? void 0 : prepareStepResult.toolChoice) != null ? _e : toolChoice,
+              activeTools: (_f = prepareStepResult == null ? void 0 : prepareStepResult.activeTools) != null ? _f : activeTools
+            });
+            currentModelResponse = await retry(
+              () => {
+                var _a2222;
+                return recordSpan({
+                  name: "ai.generateText.doGenerate",
+                  attributes: selectTelemetryAttributes({
+                    telemetry,
+                    attributes: {
+                      ...assembleOperationName({
+                        operationId: "ai.generateText.doGenerate",
+                        telemetry
+                      }),
+                      ...baseTelemetryAttributes,
+                      // model:
+                      "ai.model.provider": stepModel.provider,
+                      "ai.model.id": stepModel.modelId,
+                      // prompt:
+                      "ai.prompt.messages": {
+                        input: () => stringifyForTelemetry(promptMessages)
+                      },
+                      "ai.prompt.tools": {
+                        // convert the language model level tools:
+                        input: () => stepTools == null ? void 0 : stepTools.map((tool2) => JSON.stringify(tool2))
+                      },
+                      "ai.prompt.toolChoice": {
+                        input: () => stepToolChoice != null ? JSON.stringify(stepToolChoice) : void 0
+                      },
+                      // standardized gen-ai llm span attributes:
+                      "gen_ai.system": stepModel.provider,
+                      "gen_ai.request.model": stepModel.modelId,
+                      "gen_ai.request.frequency_penalty": settings.frequencyPenalty,
+                      "gen_ai.request.max_tokens": settings.maxOutputTokens,
+                      "gen_ai.request.presence_penalty": settings.presencePenalty,
+                      "gen_ai.request.stop_sequences": settings.stopSequences,
+                      "gen_ai.request.temperature": (_a2222 = settings.temperature) != null ? _a2222 : void 0,
+                      "gen_ai.request.top_k": settings.topK,
+                      "gen_ai.request.top_p": settings.topP
+                    }
+                  }),
+                  tracer,
+                  fn: async (span2) => {
+                    var _a23, _b222, _c2, _d2, _e2, _f2, _g2, _h2;
+                    const stepProviderOptions = mergeObjects(
+                      providerOptions,
+                      prepareStepResult == null ? void 0 : prepareStepResult.providerOptions
+                    );
+                    const result = await stepModel.doGenerate({
+                      ...callSettings2,
+                      tools: stepTools,
+                      toolChoice: stepToolChoice,
+                      responseFormat: await (output == null ? void 0 : output.responseFormat),
+                      prompt: promptMessages,
+                      providerOptions: stepProviderOptions,
+                      abortSignal: mergedAbortSignal,
+                      headers: headersWithUserAgent
+                    });
+                    const responseData = {
+                      id: (_b222 = (_a23 = result.response) == null ? void 0 : _a23.id) != null ? _b222 : generateId2(),
+                      timestamp: (_d2 = (_c2 = result.response) == null ? void 0 : _c2.timestamp) != null ? _d2 : /* @__PURE__ */ new Date(),
+                      modelId: (_f2 = (_e2 = result.response) == null ? void 0 : _e2.modelId) != null ? _f2 : stepModel.modelId,
+                      headers: (_g2 = result.response) == null ? void 0 : _g2.headers,
+                      body: (_h2 = result.response) == null ? void 0 : _h2.body
+                    };
+                    span2.setAttributes(
+                      await selectTelemetryAttributes({
+                        telemetry,
+                        attributes: {
+                          "ai.response.finishReason": result.finishReason.unified,
+                          "ai.response.text": {
+                            output: () => extractTextContent(result.content)
+                          },
+                          "ai.response.toolCalls": {
+                            output: () => {
+                              const toolCalls = asToolCalls(result.content);
+                              return toolCalls == null ? void 0 : JSON.stringify(toolCalls);
+                            }
+                          },
+                          "ai.response.id": responseData.id,
+                          "ai.response.model": responseData.modelId,
+                          "ai.response.timestamp": responseData.timestamp.toISOString(),
+                          "ai.response.providerMetadata": JSON.stringify(
+                            result.providerMetadata
+                          ),
+                          // TODO rename telemetry attributes to inputTokens and outputTokens
+                          "ai.usage.promptTokens": result.usage.inputTokens.total,
+                          "ai.usage.completionTokens": result.usage.outputTokens.total,
+                          // standardized gen-ai llm span attributes:
+                          "gen_ai.response.finish_reasons": [
+                            result.finishReason.unified
+                          ],
+                          "gen_ai.response.id": responseData.id,
+                          "gen_ai.response.model": responseData.modelId,
+                          "gen_ai.usage.input_tokens": result.usage.inputTokens.total,
+                          "gen_ai.usage.output_tokens": result.usage.outputTokens.total
+                        }
+                      })
+                    );
+                    return { ...result, response: responseData };
                   }
-                }),
-                tracer,
-                fn: async (span2) => {
-                  var _a162, _b222, _c2, _d2, _e2, _f2, _g2, _h2;
-                  const stepProviderOptions = mergeObjects(
-                    providerOptions,
-                    prepareStepResult == null ? void 0 : prepareStepResult.providerOptions
-                  );
-                  const result = await stepModel.doGenerate({
-                    ...callSettings2,
-                    tools: stepTools,
-                    toolChoice: stepToolChoice,
-                    responseFormat: await (output == null ? void 0 : output.responseFormat),
-                    prompt: promptMessages,
-                    providerOptions: stepProviderOptions,
-                    abortSignal,
-                    headers: headersWithUserAgent
-                  });
-                  const responseData = {
-                    id: (_b222 = (_a162 = result.response) == null ? void 0 : _a162.id) != null ? _b222 : generateId2(),
-                    timestamp: (_d2 = (_c2 = result.response) == null ? void 0 : _c2.timestamp) != null ? _d2 : currentDate(),
-                    modelId: (_f2 = (_e2 = result.response) == null ? void 0 : _e2.modelId) != null ? _f2 : stepModel.modelId,
-                    headers: (_g2 = result.response) == null ? void 0 : _g2.headers,
-                    body: (_h2 = result.response) == null ? void 0 : _h2.body
-                  };
-                  span2.setAttributes(
-                    await selectTelemetryAttributes({
-                      telemetry,
-                      attributes: {
-                        "ai.response.finishReason": result.finishReason.unified,
-                        "ai.response.text": {
-                          output: () => extractTextContent(result.content)
-                        },
-                        "ai.response.toolCalls": {
-                          output: () => {
-                            const toolCalls = asToolCalls(result.content);
-                            return toolCalls == null ? void 0 : JSON.stringify(toolCalls);
-                          }
-                        },
-                        "ai.response.id": responseData.id,
-                        "ai.response.model": responseData.modelId,
-                        "ai.response.timestamp": responseData.timestamp.toISOString(),
-                        "ai.response.providerMetadata": JSON.stringify(
-                          result.providerMetadata
-                        ),
-                        // TODO rename telemetry attributes to inputTokens and outputTokens
-                        "ai.usage.promptTokens": result.usage.inputTokens.total,
-                        "ai.usage.completionTokens": result.usage.outputTokens.total,
-                        // standardized gen-ai llm span attributes:
-                        "gen_ai.response.finish_reasons": [
-                          result.finishReason.unified
-                        ],
-                        "gen_ai.response.id": responseData.id,
-                        "gen_ai.response.model": responseData.modelId,
-                        "gen_ai.usage.input_tokens": result.usage.inputTokens.total,
-                        "gen_ai.usage.output_tokens": result.usage.outputTokens.total
-                      }
-                    })
-                  );
-                  return { ...result, response: responseData };
-                }
-              });
-            }
-          );
-          const stepToolCalls = await Promise.all(
-            currentModelResponse.content.filter(
-              (part) => part.type === "tool-call"
-            ).map(
-              (toolCall) => parseToolCall({
+                });
+              }
+            );
+            const stepToolCalls = await Promise.all(
+              currentModelResponse.content.filter(
+                (part) => part.type === "tool-call"
+              ).map(
+                (toolCall) => parseToolCall({
+                  toolCall,
+                  tools,
+                  repairToolCall,
+                  system,
+                  messages: stepInputMessages
+                })
+              )
+            );
+            const toolApprovalRequests = {};
+            for (const toolCall of stepToolCalls) {
+              if (toolCall.invalid) {
+                continue;
+              }
+              const tool2 = tools == null ? void 0 : tools[toolCall.toolName];
+              if (tool2 == null) {
+                continue;
+              }
+              if ((tool2 == null ? void 0 : tool2.onInputAvailable) != null) {
+                await tool2.onInputAvailable({
+                  input: toolCall.input,
+                  toolCallId: toolCall.toolCallId,
+                  messages: stepInputMessages,
+                  abortSignal: mergedAbortSignal,
+                  experimental_context
+                });
+              }
+              if (await isApprovalNeeded({
+                tool: tool2,
                 toolCall,
-                tools,
-                repairToolCall,
-                system,
-                messages: stepInputMessages
-              })
-            )
-          );
-          const toolApprovalRequests = {};
-          for (const toolCall of stepToolCalls) {
-            if (toolCall.invalid) {
-              continue;
-            }
-            const tool2 = tools == null ? void 0 : tools[toolCall.toolName];
-            if (tool2 == null) {
-              continue;
-            }
-            if ((tool2 == null ? void 0 : tool2.onInputAvailable) != null) {
-              await tool2.onInputAvailable({
-                input: toolCall.input,
-                toolCallId: toolCall.toolCallId,
                 messages: stepInputMessages,
-                abortSignal,
                 experimental_context
-              });
+              })) {
+                toolApprovalRequests[toolCall.toolCallId] = {
+                  type: "tool-approval-request",
+                  approvalId: generateId2(),
+                  toolCall
+                };
+              }
             }
-            if (await isApprovalNeeded({
-              tool: tool2,
-              toolCall,
-              messages: stepInputMessages,
-              experimental_context
-            })) {
-              toolApprovalRequests[toolCall.toolCallId] = {
-                type: "tool-approval-request",
-                approvalId: generateId2(),
-                toolCall
-              };
+            const invalidToolCalls = stepToolCalls.filter(
+              (toolCall) => toolCall.invalid && toolCall.dynamic
+            );
+            clientToolOutputs = [];
+            for (const toolCall of invalidToolCalls) {
+              clientToolOutputs.push({
+                type: "tool-error",
+                toolCallId: toolCall.toolCallId,
+                toolName: toolCall.toolName,
+                input: toolCall.input,
+                error: getErrorMessage2(toolCall.error),
+                dynamic: true
+              });
             }
-          }
-          const invalidToolCalls = stepToolCalls.filter(
-            (toolCall) => toolCall.invalid && toolCall.dynamic
-          );
-          clientToolOutputs = [];
-          for (const toolCall of invalidToolCalls) {
-            clientToolOutputs.push({
-              type: "tool-error",
-              toolCallId: toolCall.toolCallId,
-              toolName: toolCall.toolName,
-              input: toolCall.input,
-              error: getErrorMessage2(toolCall.error),
-              dynamic: true
-            });
-          }
-          clientToolCalls = stepToolCalls.filter(
-            (toolCall) => !toolCall.providerExecuted
-          );
-          if (tools != null) {
-            clientToolOutputs.push(
-              ...await executeTools({
-                toolCalls: clientToolCalls.filter(
-                  (toolCall) => !toolCall.invalid && toolApprovalRequests[toolCall.toolCallId] == null
-                ),
-                tools,
-                tracer,
-                telemetry,
-                messages: stepInputMessages,
-                abortSignal,
-                experimental_context
-              })
+            clientToolCalls = stepToolCalls.filter(
+              (toolCall) => !toolCall.providerExecuted
             );
-          }
-          for (const toolCall of stepToolCalls) {
-            if (!toolCall.providerExecuted)
-              continue;
-            const tool2 = tools == null ? void 0 : tools[toolCall.toolName];
-            if ((tool2 == null ? void 0 : tool2.type) === "provider" && tool2.supportsDeferredResults) {
-              const hasResultInResponse = currentModelResponse.content.some(
-                (part) => part.type === "tool-result" && part.toolCallId === toolCall.toolCallId
+            if (tools != null) {
+              clientToolOutputs.push(
+                ...await executeTools({
+                  toolCalls: clientToolCalls.filter(
+                    (toolCall) => !toolCall.invalid && toolApprovalRequests[toolCall.toolCallId] == null
+                  ),
+                  tools,
+                  tracer,
+                  telemetry,
+                  messages: stepInputMessages,
+                  abortSignal: mergedAbortSignal,
+                  experimental_context
+                })
               );
-              if (!hasResultInResponse) {
-                pendingDeferredToolCalls.set(toolCall.toolCallId, {
-                  toolName: toolCall.toolName
-                });
+            }
+            for (const toolCall of stepToolCalls) {
+              if (!toolCall.providerExecuted)
+                continue;
+              const tool2 = tools == null ? void 0 : tools[toolCall.toolName];
+              if ((tool2 == null ? void 0 : tool2.type) === "provider" && tool2.supportsDeferredResults) {
+                const hasResultInResponse = currentModelResponse.content.some(
+                  (part) => part.type === "tool-result" && part.toolCallId === toolCall.toolCallId
+                );
+                if (!hasResultInResponse) {
+                  pendingDeferredToolCalls.set(toolCall.toolCallId, {
+                    toolName: toolCall.toolName
+                  });
+                }
               }
             }
-          }
-          for (const part of currentModelResponse.content) {
-            if (part.type === "tool-result") {
-              pendingDeferredToolCalls.delete(part.toolCallId);
+            for (const part of currentModelResponse.content) {
+              if (part.type === "tool-result") {
+                pendingDeferredToolCalls.delete(part.toolCallId);
+              }
             }
-          }
-          const stepContent = asContent({
-            content: currentModelResponse.content,
-            toolCalls: stepToolCalls,
-            toolOutputs: clientToolOutputs,
-            toolApprovalRequests: Object.values(toolApprovalRequests),
-            tools
-          });
-          responseMessages.push(
-            ...await toResponseMessages({
-              content: stepContent,
+            const stepContent = asContent({
+              content: currentModelResponse.content,
+              toolCalls: stepToolCalls,
+              toolOutputs: clientToolOutputs,
+              toolApprovalRequests: Object.values(toolApprovalRequests),
               tools
-            })
-          );
-          const currentStepResult = new DefaultStepResult({
-            content: stepContent,
-            finishReason: currentModelResponse.finishReason.unified,
-            rawFinishReason: currentModelResponse.finishReason.raw,
-            usage: asLanguageModelUsage(currentModelResponse.usage),
-            warnings: currentModelResponse.warnings,
-            providerMetadata: currentModelResponse.providerMetadata,
-            request: (_g = currentModelResponse.request) != null ? _g : {},
-            response: {
+            });
+            responseMessages.push(
+              ...await toResponseMessages({
+                content: stepContent,
+                tools
+              })
+            );
+            const stepRequest = ((_g = include == null ? void 0 : include.requestBody) != null ? _g : true) ? (_h = currentModelResponse.request) != null ? _h : {} : { ...currentModelResponse.request, body: void 0 };
+            const stepResponse = {
               ...currentModelResponse.response,
               // deep clone msgs to avoid mutating past messages in multi-step:
-              messages: structuredClone(responseMessages)
-            }
-          });
-          logWarnings({
-            warnings: (_h = currentModelResponse.warnings) != null ? _h : [],
-            provider: stepModel.provider,
-            model: stepModel.modelId
-          });
-          steps.push(currentStepResult);
-          await (onStepFinish == null ? void 0 : onStepFinish(currentStepResult));
+              messages: structuredClone(responseMessages),
+              // Conditionally include response body:
+              body: ((_i = include == null ? void 0 : include.responseBody) != null ? _i : true) ? (_j = currentModelResponse.response) == null ? void 0 : _j.body : void 0
+            };
+            const currentStepResult = new DefaultStepResult({
+              content: stepContent,
+              finishReason: currentModelResponse.finishReason.unified,
+              rawFinishReason: currentModelResponse.finishReason.raw,
+              usage: asLanguageModelUsage(currentModelResponse.usage),
+              warnings: currentModelResponse.warnings,
+              providerMetadata: currentModelResponse.providerMetadata,
+              request: stepRequest,
+              response: stepResponse
+            });
+            logWarnings({
+              warnings: (_k = currentModelResponse.warnings) != null ? _k : [],
+              provider: stepModel.provider,
+              model: stepModel.modelId
+            });
+            steps.push(currentStepResult);
+            await (onStepFinish == null ? void 0 : onStepFinish(currentStepResult));
+          } finally {
+            if (stepTimeoutId != null) {
+              clearTimeout(stepTimeoutId);
+            }
+          }
         } while (
           // Continue if:
           // 1. There are client tool calls that have all been executed, OR
@@ -7456,6 +8121,23 @@ function asContent({
         }
         break;
       }
+      case "tool-approval-request": {
+        const toolCall = toolCalls.find(
+          (toolCall2) => toolCall2.toolCallId === part.toolCallId
+        );
+        if (toolCall == null) {
+          throw new ToolCallNotFoundForApprovalError({
+            toolCallId: part.toolCallId,
+            approvalId: part.approvalId
+          });
+        }
+        contentParts.push({
+          type: "tool-approval-request",
+          approvalId: part.approvalId,
+          toolCall
+        });
+        break;
+      }
     }
   }
   return [...contentParts, ...toolOutputs, ...toolApprovalRequests];
@@ -7632,21 +8314,23 @@ function processUIMessageStream({
     new TransformStream({
       async transform(chunk, controller) {
         await runUpdateMessageJob(async ({ state, write }) => {
-          var _a142, _b82, _c, _d;
+          var _a21, _b82, _c, _d;
           function getToolInvocation(toolCallId) {
             const toolInvocations = state.message.parts.filter(isToolUIPart);
             const toolInvocation = toolInvocations.find(
               (invocation) => invocation.toolCallId === toolCallId
             );
             if (toolInvocation == null) {
-              throw new Error(
-                `no tool invocation found for tool call ${toolCallId}`
-              );
+              throw new UIMessageStreamError({
+                chunkType: "tool-invocation",
+                chunkId: toolCallId,
+                message: `No tool invocation found for tool call ID "${toolCallId}".`
+              });
             }
             return toolInvocation;
           }
           function updateToolPart(options) {
-            var _a152;
+            var _a2222;
             const part = state.message.parts.find(
               (part2) => isStaticToolUIPart(part2) && part2.toolCallId === options.toolCallId
             );
@@ -7662,8 +8346,8 @@ function processUIMessageStream({
               if (options.title !== void 0) {
                 anyPart.title = options.title;
               }
-              anyPart.providerExecuted = (_a152 = anyOptions.providerExecuted) != null ? _a152 : part.providerExecuted;
-              if (anyOptions.providerMetadata != null && part.state === "input-available") {
+              anyPart.providerExecuted = (_a2222 = anyOptions.providerExecuted) != null ? _a2222 : part.providerExecuted;
+              if (anyOptions.providerMetadata != null) {
                 part.callProviderMetadata = anyOptions.providerMetadata;
               }
             } else {
@@ -7683,7 +8367,7 @@ function processUIMessageStream({
             }
           }
           function updateDynamicToolPart(options) {
-            var _a152, _b222;
+            var _a2222, _b222;
             const part = state.message.parts.find(
               (part2) => part2.type === "dynamic-tool" && part2.toolCallId === options.toolCallId
             );
@@ -7695,13 +8379,13 @@ function processUIMessageStream({
               anyPart.input = anyOptions.input;
               anyPart.output = anyOptions.output;
               anyPart.errorText = anyOptions.errorText;
-              anyPart.rawInput = (_a152 = anyOptions.rawInput) != null ? _a152 : anyPart.rawInput;
+              anyPart.rawInput = (_a2222 = anyOptions.rawInput) != null ? _a2222 : anyPart.rawInput;
               anyPart.preliminary = anyOptions.preliminary;
               if (options.title !== void 0) {
                 anyPart.title = options.title;
               }
               anyPart.providerExecuted = (_b222 = anyOptions.providerExecuted) != null ? _b222 : part.providerExecuted;
-              if (anyOptions.providerMetadata != null && part.state === "input-available") {
+              if (anyOptions.providerMetadata != null) {
                 part.callProviderMetadata = anyOptions.providerMetadata;
               }
             } else {
@@ -7726,7 +8410,11 @@ function processUIMessageStream({
               if (messageMetadataSchema != null) {
                 await validateTypes({
                   value: mergedMetadata,
-                  schema: messageMetadataSchema
+                  schema: messageMetadataSchema,
+                  context: {
+                    field: "message.metadata",
+                    entityId: state.message.id
+                  }
                 });
               }
               state.message.metadata = mergedMetadata;
@@ -7747,13 +8435,27 @@ function processUIMessageStream({
             }
             case "text-delta": {
               const textPart = state.activeTextParts[chunk.id];
+              if (textPart == null) {
+                throw new UIMessageStreamError({
+                  chunkType: "text-delta",
+                  chunkId: chunk.id,
+                  message: `Received text-delta for missing text part with ID "${chunk.id}". Ensure a "text-start" chunk is sent before any "text-delta" chunks.`
+                });
+              }
               textPart.text += chunk.delta;
-              textPart.providerMetadata = (_a142 = chunk.providerMetadata) != null ? _a142 : textPart.providerMetadata;
+              textPart.providerMetadata = (_a21 = chunk.providerMetadata) != null ? _a21 : textPart.providerMetadata;
               write();
               break;
             }
             case "text-end": {
               const textPart = state.activeTextParts[chunk.id];
+              if (textPart == null) {
+                throw new UIMessageStreamError({
+                  chunkType: "text-end",
+                  chunkId: chunk.id,
+                  message: `Received text-end for missing text part with ID "${chunk.id}". Ensure a "text-start" chunk is sent before any "text-end" chunks.`
+                });
+              }
               textPart.state = "done";
               textPart.providerMetadata = (_b82 = chunk.providerMetadata) != null ? _b82 : textPart.providerMetadata;
               delete state.activeTextParts[chunk.id];
@@ -7774,6 +8476,13 @@ function processUIMessageStream({
             }
             case "reasoning-delta": {
               const reasoningPart = state.activeReasoningParts[chunk.id];
+              if (reasoningPart == null) {
+                throw new UIMessageStreamError({
+                  chunkType: "reasoning-delta",
+                  chunkId: chunk.id,
+                  message: `Received reasoning-delta for missing reasoning part with ID "${chunk.id}". Ensure a "reasoning-start" chunk is sent before any "reasoning-delta" chunks.`
+                });
+              }
               reasoningPart.text += chunk.delta;
               reasoningPart.providerMetadata = (_c = chunk.providerMetadata) != null ? _c : reasoningPart.providerMetadata;
               write();
@@ -7781,6 +8490,13 @@ function processUIMessageStream({
             }
             case "reasoning-end": {
               const reasoningPart = state.activeReasoningParts[chunk.id];
+              if (reasoningPart == null) {
+                throw new UIMessageStreamError({
+                  chunkType: "reasoning-end",
+                  chunkId: chunk.id,
+                  message: `Received reasoning-end for missing reasoning part with ID "${chunk.id}". Ensure a "reasoning-start" chunk is sent before any "reasoning-end" chunks.`
+                });
+              }
               reasoningPart.providerMetadata = (_d = chunk.providerMetadata) != null ? _d : reasoningPart.providerMetadata;
               reasoningPart.state = "done";
               delete state.activeReasoningParts[chunk.id];
@@ -7835,7 +8551,8 @@ function processUIMessageStream({
                   state: "input-streaming",
                   input: void 0,
                   providerExecuted: chunk.providerExecuted,
-                  title: chunk.title
+                  title: chunk.title,
+                  providerMetadata: chunk.providerMetadata
                 });
               } else {
                 updateToolPart({
@@ -7844,7 +8561,8 @@ function processUIMessageStream({
                   state: "input-streaming",
                   input: void 0,
                   providerExecuted: chunk.providerExecuted,
-                  title: chunk.title
+                  title: chunk.title,
+                  providerMetadata: chunk.providerMetadata
                 });
               }
               write();
@@ -7852,6 +8570,13 @@ function processUIMessageStream({
             }
             case "tool-input-delta": {
               const partialToolCall = state.partialToolCalls[chunk.toolCallId];
+              if (partialToolCall == null) {
+                throw new UIMessageStreamError({
+                  chunkType: "tool-input-delta",
+                  chunkId: chunk.toolCallId,
+                  message: `Received tool-input-delta for missing tool call with ID "${chunk.toolCallId}". Ensure a "tool-input-start" chunk is sent before any "tool-input-delta" chunks.`
+                });
+              }
               partialToolCall.text += chunk.inputTextDelta;
               const { value: partialArgs } = await parsePartialJson(
                 partialToolCall.text
@@ -8043,9 +8768,18 @@ function processUIMessageStream({
             default: {
               if (isDataUIMessageChunk(chunk)) {
                 if ((dataPartSchemas == null ? void 0 : dataPartSchemas[chunk.type]) != null) {
+                  const partIdx = state.message.parts.findIndex(
+                    (p) => "id" in p && "data" in p && p.id === chunk.id && p.type === chunk.type
+                  );
+                  const actualPartIdx = partIdx >= 0 ? partIdx : state.message.parts.length;
                   await validateTypes({
                     value: chunk.data,
-                    schema: dataPartSchemas[chunk.type]
+                    schema: dataPartSchemas[chunk.type],
+                    context: {
+                      field: `message.parts[${actualPartIdx}].data`,
+                      entityName: chunk.type,
+                      entityId: chunk.id
+                    }
                   });
                 }
                 const dataChunk = chunk;
@@ -8181,11 +8915,13 @@ function createAsyncIterableStream(source) {
     const reader = this.getReader();
     let finished = false;
     async function cleanup(cancelStream) {
-      var _a142;
+      var _a21;
+      if (finished)
+        return;
       finished = true;
       try {
         {
-          await ((_a142 = reader.cancel) == null ? void 0 : _a142.call(reader));
+          await ((_a21 = reader.cancel) == null ? void 0 : _a21.call(reader));
         }
       } finally {
         try {
@@ -8211,7 +8947,7 @@ function createAsyncIterableStream(source) {
         return { done: false, value };
       },
       /**
-       * Called on early exit (e.g., break from for-await).
+       * May be called on early exit (e.g., break from for-await) or after completion.
        * Ensures the stream is cancelled and resources are released.
        * @returns A promise resolving to a completed IteratorResult.
        */
@@ -8343,8 +9079,8 @@ function createStitchableStream() {
   };
 }
 function now() {
-  var _a142, _b82;
-  return (_b82 = (_a142 = globalThis == null ? void 0 : globalThis.performance) == null ? void 0 : _a142.now()) != null ? _b82 : Date.now();
+  var _a21, _b82;
+  return (_b82 = (_a21 = globalThis == null ? void 0 : globalThis.performance) == null ? void 0 : _a21.now()) != null ? _b82 : Date.now();
 }
 function runToolsTransformation({
   tools,
@@ -8366,6 +9102,7 @@ function runToolsTransformation({
   });
   const outstandingToolResults = /* @__PURE__ */ new Set();
   const toolInputs = /* @__PURE__ */ new Map();
+  const toolCallsByToolCallId = /* @__PURE__ */ new Map();
   let canClose = false;
   let finishChunk = void 0;
   function attemptClose() {
@@ -8417,6 +9154,25 @@ function runToolsTransformation({
           };
           break;
         }
+        case "tool-approval-request": {
+          const toolCall = toolCallsByToolCallId.get(chunk.toolCallId);
+          if (toolCall == null) {
+            toolResultsStreamController.enqueue({
+              type: "error",
+              error: new ToolCallNotFoundForApprovalError({
+                toolCallId: chunk.toolCallId,
+                approvalId: chunk.approvalId
+              })
+            });
+            break;
+          }
+          controller.enqueue({
+            type: "tool-approval-request",
+            approvalId: chunk.approvalId,
+            toolCall
+          });
+          break;
+        }
         case "tool-call": {
           try {
             const toolCall = await parseToolCall({
@@ -8426,6 +9182,7 @@ function runToolsTransformation({
               system,
               messages
             });
+            toolCallsByToolCallId.set(toolCall.toolCallId, toolCall);
             controller.enqueue(toolCall);
             if (toolCall.invalid) {
               toolResultsStreamController.enqueue({
@@ -8482,6 +9239,12 @@ function runToolsTransformation({
                 }
               }).then((result) => {
                 toolResultsStreamController.enqueue(result);
+              }).catch((error) => {
+                toolResultsStreamController.enqueue({
+                  type: "error",
+                  error
+                });
+              }).finally(() => {
                 outstandingToolResults.delete(toolExecutionId);
                 attemptClose();
               });
@@ -8516,9 +9279,6 @@ function runToolsTransformation({
           }
           break;
         }
-        case "tool-approval-request": {
-          break;
-        }
         default: {
           const _exhaustiveCheck = chunkType;
           throw new Error(`Unhandled chunk type: ${_exhaustiveCheck}`);
@@ -8569,6 +9329,7 @@ function streamText({
   messages,
   maxRetries,
   abortSignal,
+  timeout,
   headers,
   stopWhen = stepCountIs(1),
   experimental_output,
@@ -8590,20 +9351,31 @@ function streamText({
   onAbort,
   onStepFinish,
   experimental_context,
-  _internal: {
-    now: now2 = now,
-    generateId: generateId2 = originalGenerateId2,
-    currentDate = () => /* @__PURE__ */ new Date()
-  } = {},
+  experimental_include: include,
+  _internal: { now: now2 = now, generateId: generateId2 = originalGenerateId2 } = {},
   ...settings
 }) {
+  const totalTimeoutMs = getTotalTimeoutMs(timeout);
+  const stepTimeoutMs = getStepTimeoutMs(timeout);
+  const chunkTimeoutMs = getChunkTimeoutMs(timeout);
+  const stepAbortController = stepTimeoutMs != null ? new AbortController() : void 0;
+  const chunkAbortController = chunkTimeoutMs != null ? new AbortController() : void 0;
   return new DefaultStreamTextResult({
     model: resolveLanguageModel(model),
     telemetry,
     headers,
     settings,
     maxRetries,
-    abortSignal,
+    abortSignal: mergeAbortSignals(
+      abortSignal,
+      totalTimeoutMs != null ? AbortSignal.timeout(totalTimeoutMs) : void 0,
+      stepAbortController == null ? void 0 : stepAbortController.signal,
+      chunkAbortController == null ? void 0 : chunkAbortController.signal
+    ),
+    stepTimeoutMs,
+    stepAbortController,
+    chunkTimeoutMs,
+    chunkAbortController,
     system,
     prompt,
     messages,
@@ -8623,10 +9395,10 @@ function streamText({
     onAbort,
     onStepFinish,
     now: now2,
-    currentDate,
     generateId: generateId2,
     experimental_context,
-    download: download2
+    download: download2,
+    include
   });
 }
 function createOutputTransformStream(output) {
@@ -8652,7 +9424,7 @@ function createOutputTransformStream(output) {
   }
   return new TransformStream({
     async transform(chunk, controller) {
-      var _a142;
+      var _a21;
       if (chunk.type === "finish-step" && textChunk.length > 0) {
         publishTextChunk({ controller });
       }
@@ -8679,7 +9451,7 @@ function createOutputTransformStream(output) {
       }
       text2 += chunk.text;
       textChunk += chunk.text;
-      textProviderMetadata = (_a142 = chunk.providerMetadata) != null ? _a142 : textProviderMetadata;
+      textProviderMetadata = (_a21 = chunk.providerMetadata) != null ? _a21 : textProviderMetadata;
       const result = await output.parsePartialOutput({ text: text2 });
       if (result !== void 0) {
         const currentJson = JSON.stringify(result.partial);
@@ -8699,6 +9471,10 @@ var DefaultStreamTextResult = class {
     settings,
     maxRetries: maxRetriesArg,
     abortSignal,
+    stepTimeoutMs,
+    stepAbortController,
+    chunkTimeoutMs,
+    chunkAbortController,
     system,
     prompt,
     messages,
@@ -8713,7 +9489,6 @@ var DefaultStreamTextResult = class {
     prepareStep,
     includeRawChunks,
     now: now2,
-    currentDate,
     generateId: generateId2,
     onChunk,
     onError,
@@ -8721,7 +9496,8 @@ var DefaultStreamTextResult = class {
     onAbort,
     onStepFinish,
     experimental_context,
-    download: download2
+    download: download2,
+    include
   }) {
     this._totalUsage = new DelayedPromise();
     this._finishReason = new DelayedPromise();
@@ -8745,7 +9521,7 @@ var DefaultStreamTextResult = class {
     let activeReasoningContent = {};
     const eventProcessor = new TransformStream({
       async transform(chunk, controller) {
-        var _a142, _b82, _c, _d;
+        var _a21, _b82, _c, _d;
         controller.enqueue(chunk);
         const { part } = chunk;
         if (part.type === "text-delta" || part.type === "reasoning-delta" || part.type === "source" || part.type === "tool-call" || part.type === "tool-result" || part.type === "tool-input-start" || part.type === "tool-input-delta" || part.type === "raw") {
@@ -8775,7 +9551,7 @@ var DefaultStreamTextResult = class {
             return;
           }
           activeText.text += part.text;
-          activeText.providerMetadata = (_a142 = part.providerMetadata) != null ? _a142 : activeText.providerMetadata;
+          activeText.providerMetadata = (_a21 = part.providerMetadata) != null ? _a21 : activeText.providerMetadata;
         }
         if (part.type === "text-end") {
           const activeText = activeTextContent[part.id];
@@ -8892,7 +9668,7 @@ var DefaultStreamTextResult = class {
       async flush(controller) {
         try {
           if (recordedSteps.length === 0) {
-            const error = new NoOutputGeneratedError({
+            const error = (abortSignal == null ? void 0 : abortSignal.aborted) ? abortSignal.reason : new NoOutputGeneratedError({
               message: "No output generated. Check the stream for errors."
             });
             self._finishReason.reject(error);
@@ -8940,8 +9716,8 @@ var DefaultStreamTextResult = class {
                 "ai.response.text": { output: () => finalStep.text },
                 "ai.response.toolCalls": {
                   output: () => {
-                    var _a142;
-                    return ((_a142 = finalStep.toolCalls) == null ? void 0 : _a142.length) ? JSON.stringify(finalStep.toolCalls) : void 0;
+                    var _a21;
+                    return ((_a21 = finalStep.toolCalls) == null ? void 0 : _a21.length) ? JSON.stringify(finalStep.toolCalls) : void 0;
                   }
                 },
                 "ai.response.providerMetadata": JSON.stringify(
@@ -8973,7 +9749,13 @@ var DefaultStreamTextResult = class {
       async pull(controller) {
         function abort() {
           onAbort == null ? void 0 : onAbort({ steps: recordedSteps });
-          controller.enqueue({ type: "abort" });
+          controller.enqueue({
+            type: "abort",
+            // The `reason` is usually of type DOMException, but it can also be of any type,
+            // so we use getErrorMessage for serialization because it is already designed to accept values of the unknown type.
+            // See: https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/reason
+            ...(abortSignal == null ? void 0 : abortSignal.reason) !== void 0 ? { reason: getErrorMessage(abortSignal.reason) } : {}
+          });
           controller.close();
         }
         try {
@@ -9049,6 +9831,19 @@ var DefaultStreamTextResult = class {
         const initialResponseMessages = [];
         const { approvedToolApprovals, deniedToolApprovals } = collectToolApprovals({ messages: initialMessages });
         if (deniedToolApprovals.length > 0 || approvedToolApprovals.length > 0) {
+          const providerExecutedToolApprovals = [
+            ...approvedToolApprovals,
+            ...deniedToolApprovals
+          ].filter((toolApproval) => toolApproval.toolCall.providerExecuted);
+          const localApprovedToolApprovals = approvedToolApprovals.filter(
+            (toolApproval) => !toolApproval.toolCall.providerExecuted
+          );
+          const localDeniedToolApprovals = deniedToolApprovals.filter(
+            (toolApproval) => !toolApproval.toolCall.providerExecuted
+          );
+          const deniedProviderExecutedToolApprovals = deniedToolApprovals.filter(
+            (toolApproval) => toolApproval.toolCall.providerExecuted
+          );
           let toolExecutionStepStreamController;
           const toolExecutionStepStream = new ReadableStream({
             start(controller) {
@@ -9057,7 +9852,10 @@ var DefaultStreamTextResult = class {
           });
           self.addStream(toolExecutionStepStream);
           try {
-            for (const toolApproval of deniedToolApprovals) {
+            for (const toolApproval of [
+              ...localDeniedToolApprovals,
+              ...deniedProviderExecutedToolApprovals
+            ]) {
               toolExecutionStepStreamController == null ? void 0 : toolExecutionStepStreamController.enqueue({
                 type: "tool-output-denied",
                 toolCallId: toolApproval.toolCall.toolCallId,
@@ -9066,7 +9864,7 @@ var DefaultStreamTextResult = class {
             }
             const toolOutputs = [];
             await Promise.all(
-              approvedToolApprovals.map(async (toolApproval) => {
+              localApprovedToolApprovals.map(async (toolApproval) => {
                 const result = await executeToolCall({
                   toolCall: toolApproval.toolCall,
                   tools,
@@ -9085,36 +9883,52 @@ var DefaultStreamTextResult = class {
                 }
               })
             );
-            const content = [];
-            for (const output2 of toolOutputs) {
-              content.push({
-                type: "tool-result",
-                toolCallId: output2.toolCallId,
-                toolName: output2.toolName,
-                output: await createToolModelOutput({
-                  toolCallId: output2.toolCallId,
-                  input: output2.input,
-                  tool: tools == null ? void 0 : tools[output2.toolName],
-                  output: output2.type === "tool-result" ? output2.output : output2.error,
-                  errorMode: output2.type === "tool-error" ? "json" : "none"
-                })
+            if (providerExecutedToolApprovals.length > 0) {
+              initialResponseMessages.push({
+                role: "tool",
+                content: providerExecutedToolApprovals.map(
+                  (toolApproval) => ({
+                    type: "tool-approval-response",
+                    approvalId: toolApproval.approvalResponse.approvalId,
+                    approved: toolApproval.approvalResponse.approved,
+                    reason: toolApproval.approvalResponse.reason,
+                    providerExecuted: true
+                  })
+                )
               });
             }
-            for (const toolApproval of deniedToolApprovals) {
-              content.push({
-                type: "tool-result",
-                toolCallId: toolApproval.toolCall.toolCallId,
-                toolName: toolApproval.toolCall.toolName,
-                output: {
-                  type: "execution-denied",
-                  reason: toolApproval.approvalResponse.reason
-                }
+            if (toolOutputs.length > 0 || localDeniedToolApprovals.length > 0) {
+              const localToolContent = [];
+              for (const output2 of toolOutputs) {
+                localToolContent.push({
+                  type: "tool-result",
+                  toolCallId: output2.toolCallId,
+                  toolName: output2.toolName,
+                  output: await createToolModelOutput({
+                    toolCallId: output2.toolCallId,
+                    input: output2.input,
+                    tool: tools == null ? void 0 : tools[output2.toolName],
+                    output: output2.type === "tool-result" ? output2.output : output2.error,
+                    errorMode: output2.type === "tool-error" ? "json" : "none"
+                  })
+                });
+              }
+              for (const toolApproval of localDeniedToolApprovals) {
+                localToolContent.push({
+                  type: "tool-result",
+                  toolCallId: toolApproval.toolCall.toolCallId,
+                  toolName: toolApproval.toolCall.toolName,
+                  output: {
+                    type: "execution-denied",
+                    reason: toolApproval.approvalResponse.reason
+                  }
+                });
+              }
+              initialResponseMessages.push({
+                role: "tool",
+                content: localToolContent
               });
             }
-            initialResponseMessages.push({
-              role: "tool",
-              content
-            });
           } finally {
             toolExecutionStepStreamController == null ? void 0 : toolExecutionStepStreamController.close();
           }
@@ -9125,407 +9939,446 @@ var DefaultStreamTextResult = class {
           responseMessages,
           usage
         }) {
-          var _a142, _b82, _c, _d, _e, _f;
+          var _a21, _b82, _c, _d, _e, _f, _g;
           const includeRawChunks2 = self.includeRawChunks;
-          stepFinish = new DelayedPromise();
-          const stepInputMessages = [...initialMessages, ...responseMessages];
-          const prepareStepResult = await (prepareStep == null ? void 0 : prepareStep({
-            model,
-            steps: recordedSteps,
-            stepNumber: recordedSteps.length,
-            messages: stepInputMessages,
-            experimental_context
-          }));
-          const stepModel = resolveLanguageModel(
-            (_a142 = prepareStepResult == null ? void 0 : prepareStepResult.model) != null ? _a142 : model
-          );
-          const promptMessages = await convertToLanguageModelPrompt({
-            prompt: {
-              system: (_b82 = prepareStepResult == null ? void 0 : prepareStepResult.system) != null ? _b82 : initialPrompt.system,
-              messages: (_c = prepareStepResult == null ? void 0 : prepareStepResult.messages) != null ? _c : stepInputMessages
-            },
-            supportedUrls: await stepModel.supportedUrls,
-            download: download2
-          });
-          const { toolChoice: stepToolChoice, tools: stepTools } = await prepareToolsAndToolChoice({
-            tools,
-            toolChoice: (_d = prepareStepResult == null ? void 0 : prepareStepResult.toolChoice) != null ? _d : toolChoice,
-            activeTools: (_e = prepareStepResult == null ? void 0 : prepareStepResult.activeTools) != null ? _e : activeTools
-          });
-          experimental_context = (_f = prepareStepResult == null ? void 0 : prepareStepResult.experimental_context) != null ? _f : experimental_context;
-          const stepProviderOptions = mergeObjects(
-            providerOptions,
-            prepareStepResult == null ? void 0 : prepareStepResult.providerOptions
-          );
-          const {
-            result: { stream: stream2, response, request },
-            doStreamSpan,
-            startTimestampMs
-          } = await retry(
-            () => recordSpan({
-              name: "ai.streamText.doStream",
-              attributes: selectTelemetryAttributes({
-                telemetry,
-                attributes: {
-                  ...assembleOperationName({
-                    operationId: "ai.streamText.doStream",
-                    telemetry
-                  }),
-                  ...baseTelemetryAttributes,
-                  // model:
-                  "ai.model.provider": stepModel.provider,
-                  "ai.model.id": stepModel.modelId,
-                  // prompt:
-                  "ai.prompt.messages": {
-                    input: () => stringifyForTelemetry(promptMessages)
-                  },
-                  "ai.prompt.tools": {
-                    // convert the language model level tools:
-                    input: () => stepTools == null ? void 0 : stepTools.map((tool2) => JSON.stringify(tool2))
-                  },
-                  "ai.prompt.toolChoice": {
-                    input: () => stepToolChoice != null ? JSON.stringify(stepToolChoice) : void 0
-                  },
-                  // standardized gen-ai llm span attributes:
-                  "gen_ai.system": stepModel.provider,
-                  "gen_ai.request.model": stepModel.modelId,
-                  "gen_ai.request.frequency_penalty": callSettings.frequencyPenalty,
-                  "gen_ai.request.max_tokens": callSettings.maxOutputTokens,
-                  "gen_ai.request.presence_penalty": callSettings.presencePenalty,
-                  "gen_ai.request.stop_sequences": callSettings.stopSequences,
-                  "gen_ai.request.temperature": callSettings.temperature,
-                  "gen_ai.request.top_k": callSettings.topK,
-                  "gen_ai.request.top_p": callSettings.topP
-                }
-              }),
-              tracer,
-              endWhenDone: false,
-              fn: async (doStreamSpan2) => ({
-                startTimestampMs: now2(),
-                // get before the call
-                doStreamSpan: doStreamSpan2,
-                result: await stepModel.doStream({
-                  ...callSettings,
-                  tools: stepTools,
-                  toolChoice: stepToolChoice,
-                  responseFormat: await (output == null ? void 0 : output.responseFormat),
-                  prompt: promptMessages,
-                  providerOptions: stepProviderOptions,
-                  abortSignal,
-                  headers,
-                  includeRawChunks: includeRawChunks2
+          const stepTimeoutId = stepTimeoutMs != null ? setTimeout(() => stepAbortController.abort(), stepTimeoutMs) : void 0;
+          let chunkTimeoutId = void 0;
+          function resetChunkTimeout() {
+            if (chunkTimeoutMs != null) {
+              if (chunkTimeoutId != null) {
+                clearTimeout(chunkTimeoutId);
+              }
+              chunkTimeoutId = setTimeout(
+                () => chunkAbortController.abort(),
+                chunkTimeoutMs
+              );
+            }
+          }
+          function clearChunkTimeout() {
+            if (chunkTimeoutId != null) {
+              clearTimeout(chunkTimeoutId);
+              chunkTimeoutId = void 0;
+            }
+          }
+          function clearStepTimeout() {
+            if (stepTimeoutId != null) {
+              clearTimeout(stepTimeoutId);
+            }
+          }
+          try {
+            stepFinish = new DelayedPromise();
+            const stepInputMessages = [...initialMessages, ...responseMessages];
+            const prepareStepResult = await (prepareStep == null ? void 0 : prepareStep({
+              model,
+              steps: recordedSteps,
+              stepNumber: recordedSteps.length,
+              messages: stepInputMessages,
+              experimental_context
+            }));
+            const stepModel = resolveLanguageModel(
+              (_a21 = prepareStepResult == null ? void 0 : prepareStepResult.model) != null ? _a21 : model
+            );
+            const promptMessages = await convertToLanguageModelPrompt({
+              prompt: {
+                system: (_b82 = prepareStepResult == null ? void 0 : prepareStepResult.system) != null ? _b82 : initialPrompt.system,
+                messages: (_c = prepareStepResult == null ? void 0 : prepareStepResult.messages) != null ? _c : stepInputMessages
+              },
+              supportedUrls: await stepModel.supportedUrls,
+              download: download2
+            });
+            const { toolChoice: stepToolChoice, tools: stepTools } = await prepareToolsAndToolChoice({
+              tools,
+              toolChoice: (_d = prepareStepResult == null ? void 0 : prepareStepResult.toolChoice) != null ? _d : toolChoice,
+              activeTools: (_e = prepareStepResult == null ? void 0 : prepareStepResult.activeTools) != null ? _e : activeTools
+            });
+            experimental_context = (_f = prepareStepResult == null ? void 0 : prepareStepResult.experimental_context) != null ? _f : experimental_context;
+            const stepProviderOptions = mergeObjects(
+              providerOptions,
+              prepareStepResult == null ? void 0 : prepareStepResult.providerOptions
+            );
+            const {
+              result: { stream: stream2, response, request },
+              doStreamSpan,
+              startTimestampMs
+            } = await retry(
+              () => recordSpan({
+                name: "ai.streamText.doStream",
+                attributes: selectTelemetryAttributes({
+                  telemetry,
+                  attributes: {
+                    ...assembleOperationName({
+                      operationId: "ai.streamText.doStream",
+                      telemetry
+                    }),
+                    ...baseTelemetryAttributes,
+                    // model:
+                    "ai.model.provider": stepModel.provider,
+                    "ai.model.id": stepModel.modelId,
+                    // prompt:
+                    "ai.prompt.messages": {
+                      input: () => stringifyForTelemetry(promptMessages)
+                    },
+                    "ai.prompt.tools": {
+                      // convert the language model level tools:
+                      input: () => stepTools == null ? void 0 : stepTools.map((tool2) => JSON.stringify(tool2))
+                    },
+                    "ai.prompt.toolChoice": {
+                      input: () => stepToolChoice != null ? JSON.stringify(stepToolChoice) : void 0
+                    },
+                    // standardized gen-ai llm span attributes:
+                    "gen_ai.system": stepModel.provider,
+                    "gen_ai.request.model": stepModel.modelId,
+                    "gen_ai.request.frequency_penalty": callSettings.frequencyPenalty,
+                    "gen_ai.request.max_tokens": callSettings.maxOutputTokens,
+                    "gen_ai.request.presence_penalty": callSettings.presencePenalty,
+                    "gen_ai.request.stop_sequences": callSettings.stopSequences,
+                    "gen_ai.request.temperature": callSettings.temperature,
+                    "gen_ai.request.top_k": callSettings.topK,
+                    "gen_ai.request.top_p": callSettings.topP
+                  }
+                }),
+                tracer,
+                endWhenDone: false,
+                fn: async (doStreamSpan2) => ({
+                  startTimestampMs: now2(),
+                  // get before the call
+                  doStreamSpan: doStreamSpan2,
+                  result: await stepModel.doStream({
+                    ...callSettings,
+                    tools: stepTools,
+                    toolChoice: stepToolChoice,
+                    responseFormat: await (output == null ? void 0 : output.responseFormat),
+                    prompt: promptMessages,
+                    providerOptions: stepProviderOptions,
+                    abortSignal,
+                    headers,
+                    includeRawChunks: includeRawChunks2
+                  })
                 })
               })
-            })
-          );
-          const streamWithToolResults = runToolsTransformation({
-            tools,
-            generatorStream: stream2,
-            tracer,
-            telemetry,
-            system,
-            messages: stepInputMessages,
-            repairToolCall,
-            abortSignal,
-            experimental_context,
-            generateId: generateId2
-          });
-          const stepRequest = request != null ? request : {};
-          const stepToolCalls = [];
-          const stepToolOutputs = [];
-          let warnings;
-          const activeToolCallToolNames = {};
-          let stepFinishReason = "other";
-          let stepRawFinishReason = void 0;
-          let stepUsage = createNullLanguageModelUsage();
-          let stepProviderMetadata;
-          let stepFirstChunk = true;
-          let stepResponse = {
-            id: generateId2(),
-            timestamp: currentDate(),
-            modelId: model.modelId
-          };
-          let activeText = "";
-          self.addStream(
-            streamWithToolResults.pipeThrough(
-              new TransformStream({
-                async transform(chunk, controller) {
-                  var _a152, _b222, _c2, _d2, _e2;
-                  if (chunk.type === "stream-start") {
-                    warnings = chunk.warnings;
-                    return;
-                  }
-                  if (stepFirstChunk) {
-                    const msToFirstChunk = now2() - startTimestampMs;
-                    stepFirstChunk = false;
-                    doStreamSpan.addEvent("ai.stream.firstChunk", {
-                      "ai.response.msToFirstChunk": msToFirstChunk
-                    });
-                    doStreamSpan.setAttributes({
-                      "ai.response.msToFirstChunk": msToFirstChunk
-                    });
-                    controller.enqueue({
-                      type: "start-step",
-                      request: stepRequest,
-                      warnings: warnings != null ? warnings : []
-                    });
-                  }
-                  const chunkType = chunk.type;
-                  switch (chunkType) {
-                    case "tool-approval-request":
-                    case "text-start":
-                    case "text-end": {
-                      controller.enqueue(chunk);
-                      break;
+            );
+            const streamWithToolResults = runToolsTransformation({
+              tools,
+              generatorStream: stream2,
+              tracer,
+              telemetry,
+              system,
+              messages: stepInputMessages,
+              repairToolCall,
+              abortSignal,
+              experimental_context,
+              generateId: generateId2
+            });
+            const stepRequest = ((_g = include == null ? void 0 : include.requestBody) != null ? _g : true) ? request != null ? request : {} : { ...request, body: void 0 };
+            const stepToolCalls = [];
+            const stepToolOutputs = [];
+            let warnings;
+            const activeToolCallToolNames = {};
+            let stepFinishReason = "other";
+            let stepRawFinishReason = void 0;
+            let stepUsage = createNullLanguageModelUsage();
+            let stepProviderMetadata;
+            let stepFirstChunk = true;
+            let stepResponse = {
+              id: generateId2(),
+              timestamp: /* @__PURE__ */ new Date(),
+              modelId: model.modelId
+            };
+            let activeText = "";
+            self.addStream(
+              streamWithToolResults.pipeThrough(
+                new TransformStream({
+                  async transform(chunk, controller) {
+                    var _a2222, _b222, _c2, _d2, _e2;
+                    resetChunkTimeout();
+                    if (chunk.type === "stream-start") {
+                      warnings = chunk.warnings;
+                      return;
+                    }
+                    if (stepFirstChunk) {
+                      const msToFirstChunk = now2() - startTimestampMs;
+                      stepFirstChunk = false;
+                      doStreamSpan.addEvent("ai.stream.firstChunk", {
+                        "ai.response.msToFirstChunk": msToFirstChunk
+                      });
+                      doStreamSpan.setAttributes({
+                        "ai.response.msToFirstChunk": msToFirstChunk
+                      });
+                      controller.enqueue({
+                        type: "start-step",
+                        request: stepRequest,
+                        warnings: warnings != null ? warnings : []
+                      });
                     }
-                    case "text-delta": {
-                      if (chunk.delta.length > 0) {
+                    const chunkType = chunk.type;
+                    switch (chunkType) {
+                      case "tool-approval-request":
+                      case "text-start":
+                      case "text-end": {
+                        controller.enqueue(chunk);
+                        break;
+                      }
+                      case "text-delta": {
+                        if (chunk.delta.length > 0) {
+                          controller.enqueue({
+                            type: "text-delta",
+                            id: chunk.id,
+                            text: chunk.delta,
+                            providerMetadata: chunk.providerMetadata
+                          });
+                          activeText += chunk.delta;
+                        }
+                        break;
+                      }
+                      case "reasoning-start":
+                      case "reasoning-end": {
+                        controller.enqueue(chunk);
+                        break;
+                      }
+                      case "reasoning-delta": {
                         controller.enqueue({
-                          type: "text-delta",
+                          type: "reasoning-delta",
                           id: chunk.id,
                           text: chunk.delta,
                           providerMetadata: chunk.providerMetadata
                         });
-                        activeText += chunk.delta;
+                        break;
                       }
-                      break;
-                    }
-                    case "reasoning-start":
-                    case "reasoning-end": {
-                      controller.enqueue(chunk);
-                      break;
-                    }
-                    case "reasoning-delta": {
-                      controller.enqueue({
-                        type: "reasoning-delta",
-                        id: chunk.id,
-                        text: chunk.delta,
-                        providerMetadata: chunk.providerMetadata
-                      });
-                      break;
-                    }
-                    case "tool-call": {
-                      controller.enqueue(chunk);
-                      stepToolCalls.push(chunk);
-                      break;
-                    }
-                    case "tool-result": {
-                      controller.enqueue(chunk);
-                      if (!chunk.preliminary) {
+                      case "tool-call": {
+                        controller.enqueue(chunk);
+                        stepToolCalls.push(chunk);
+                        break;
+                      }
+                      case "tool-result": {
+                        controller.enqueue(chunk);
+                        if (!chunk.preliminary) {
+                          stepToolOutputs.push(chunk);
+                        }
+                        break;
+                      }
+                      case "tool-error": {
+                        controller.enqueue(chunk);
                         stepToolOutputs.push(chunk);
+                        break;
                       }
-                      break;
-                    }
-                    case "tool-error": {
-                      controller.enqueue(chunk);
-                      stepToolOutputs.push(chunk);
-                      break;
-                    }
-                    case "response-metadata": {
-                      stepResponse = {
-                        id: (_a152 = chunk.id) != null ? _a152 : stepResponse.id,
-                        timestamp: (_b222 = chunk.timestamp) != null ? _b222 : stepResponse.timestamp,
-                        modelId: (_c2 = chunk.modelId) != null ? _c2 : stepResponse.modelId
-                      };
-                      break;
-                    }
-                    case "finish": {
-                      stepUsage = chunk.usage;
-                      stepFinishReason = chunk.finishReason;
-                      stepRawFinishReason = chunk.rawFinishReason;
-                      stepProviderMetadata = chunk.providerMetadata;
-                      const msToFinish = now2() - startTimestampMs;
-                      doStreamSpan.addEvent("ai.stream.finish");
-                      doStreamSpan.setAttributes({
-                        "ai.response.msToFinish": msToFinish,
-                        "ai.response.avgOutputTokensPerSecond": 1e3 * ((_d2 = stepUsage.outputTokens) != null ? _d2 : 0) / msToFinish
-                      });
-                      break;
-                    }
-                    case "file": {
-                      controller.enqueue(chunk);
-                      break;
-                    }
-                    case "source": {
-                      controller.enqueue(chunk);
-                      break;
-                    }
-                    case "tool-input-start": {
-                      activeToolCallToolNames[chunk.id] = chunk.toolName;
-                      const tool2 = tools == null ? void 0 : tools[chunk.toolName];
-                      if ((tool2 == null ? void 0 : tool2.onInputStart) != null) {
-                        await tool2.onInputStart({
-                          toolCallId: chunk.id,
-                          messages: stepInputMessages,
-                          abortSignal,
-                          experimental_context
+                      case "response-metadata": {
+                        stepResponse = {
+                          id: (_a2222 = chunk.id) != null ? _a2222 : stepResponse.id,
+                          timestamp: (_b222 = chunk.timestamp) != null ? _b222 : stepResponse.timestamp,
+                          modelId: (_c2 = chunk.modelId) != null ? _c2 : stepResponse.modelId
+                        };
+                        break;
+                      }
+                      case "finish": {
+                        stepUsage = chunk.usage;
+                        stepFinishReason = chunk.finishReason;
+                        stepRawFinishReason = chunk.rawFinishReason;
+                        stepProviderMetadata = chunk.providerMetadata;
+                        const msToFinish = now2() - startTimestampMs;
+                        doStreamSpan.addEvent("ai.stream.finish");
+                        doStreamSpan.setAttributes({
+                          "ai.response.msToFinish": msToFinish,
+                          "ai.response.avgOutputTokensPerSecond": 1e3 * ((_d2 = stepUsage.outputTokens) != null ? _d2 : 0) / msToFinish
                         });
+                        break;
                       }
-                      controller.enqueue({
-                        ...chunk,
-                        dynamic: (_e2 = chunk.dynamic) != null ? _e2 : (tool2 == null ? void 0 : tool2.type) === "dynamic",
-                        title: tool2 == null ? void 0 : tool2.title
-                      });
-                      break;
-                    }
-                    case "tool-input-end": {
-                      delete activeToolCallToolNames[chunk.id];
-                      controller.enqueue(chunk);
-                      break;
-                    }
-                    case "tool-input-delta": {
-                      const toolName = activeToolCallToolNames[chunk.id];
-                      const tool2 = tools == null ? void 0 : tools[toolName];
-                      if ((tool2 == null ? void 0 : tool2.onInputDelta) != null) {
-                        await tool2.onInputDelta({
-                          inputTextDelta: chunk.delta,
-                          toolCallId: chunk.id,
-                          messages: stepInputMessages,
-                          abortSignal,
-                          experimental_context
+                      case "file": {
+                        controller.enqueue(chunk);
+                        break;
+                      }
+                      case "source": {
+                        controller.enqueue(chunk);
+                        break;
+                      }
+                      case "tool-input-start": {
+                        activeToolCallToolNames[chunk.id] = chunk.toolName;
+                        const tool2 = tools == null ? void 0 : tools[chunk.toolName];
+                        if ((tool2 == null ? void 0 : tool2.onInputStart) != null) {
+                          await tool2.onInputStart({
+                            toolCallId: chunk.id,
+                            messages: stepInputMessages,
+                            abortSignal,
+                            experimental_context
+                          });
+                        }
+                        controller.enqueue({
+                          ...chunk,
+                          dynamic: (_e2 = chunk.dynamic) != null ? _e2 : (tool2 == null ? void 0 : tool2.type) === "dynamic",
+                          title: tool2 == null ? void 0 : tool2.title
                         });
+                        break;
                       }
-                      controller.enqueue(chunk);
-                      break;
-                    }
-                    case "error": {
-                      controller.enqueue(chunk);
-                      stepFinishReason = "error";
-                      break;
-                    }
-                    case "raw": {
-                      if (includeRawChunks2) {
+                      case "tool-input-end": {
+                        delete activeToolCallToolNames[chunk.id];
                         controller.enqueue(chunk);
+                        break;
                       }
-                      break;
-                    }
-                    default: {
-                      const exhaustiveCheck = chunkType;
-                      throw new Error(`Unknown chunk type: ${exhaustiveCheck}`);
-                    }
-                  }
-                },
-                // invoke onFinish callback and resolve toolResults promise when the stream is about to close:
-                async flush(controller) {
-                  const stepToolCallsJson = stepToolCalls.length > 0 ? JSON.stringify(stepToolCalls) : void 0;
-                  try {
-                    doStreamSpan.setAttributes(
-                      await selectTelemetryAttributes({
-                        telemetry,
-                        attributes: {
-                          "ai.response.finishReason": stepFinishReason,
-                          "ai.response.text": {
-                            output: () => activeText
-                          },
-                          "ai.response.toolCalls": {
-                            output: () => stepToolCallsJson
-                          },
-                          "ai.response.id": stepResponse.id,
-                          "ai.response.model": stepResponse.modelId,
-                          "ai.response.timestamp": stepResponse.timestamp.toISOString(),
-                          "ai.response.providerMetadata": JSON.stringify(stepProviderMetadata),
-                          "ai.usage.inputTokens": stepUsage.inputTokens,
-                          "ai.usage.outputTokens": stepUsage.outputTokens,
-                          "ai.usage.totalTokens": stepUsage.totalTokens,
-                          "ai.usage.reasoningTokens": stepUsage.reasoningTokens,
-                          "ai.usage.cachedInputTokens": stepUsage.cachedInputTokens,
-                          // standardized gen-ai llm span attributes:
-                          "gen_ai.response.finish_reasons": [stepFinishReason],
-                          "gen_ai.response.id": stepResponse.id,
-                          "gen_ai.response.model": stepResponse.modelId,
-                          "gen_ai.usage.input_tokens": stepUsage.inputTokens,
-                          "gen_ai.usage.output_tokens": stepUsage.outputTokens
+                      case "tool-input-delta": {
+                        const toolName = activeToolCallToolNames[chunk.id];
+                        const tool2 = tools == null ? void 0 : tools[toolName];
+                        if ((tool2 == null ? void 0 : tool2.onInputDelta) != null) {
+                          await tool2.onInputDelta({
+                            inputTextDelta: chunk.delta,
+                            toolCallId: chunk.id,
+                            messages: stepInputMessages,
+                            abortSignal,
+                            experimental_context
+                          });
                         }
-                      })
-                    );
-                  } catch (error) {
-                  } finally {
-                    doStreamSpan.end();
-                  }
-                  controller.enqueue({
-                    type: "finish-step",
-                    finishReason: stepFinishReason,
-                    rawFinishReason: stepRawFinishReason,
-                    usage: stepUsage,
-                    providerMetadata: stepProviderMetadata,
-                    response: {
-                      ...stepResponse,
-                      headers: response == null ? void 0 : response.headers
+                        controller.enqueue(chunk);
+                        break;
+                      }
+                      case "error": {
+                        controller.enqueue(chunk);
+                        stepFinishReason = "error";
+                        break;
+                      }
+                      case "raw": {
+                        if (includeRawChunks2) {
+                          controller.enqueue(chunk);
+                        }
+                        break;
+                      }
+                      default: {
+                        const exhaustiveCheck = chunkType;
+                        throw new Error(
+                          `Unknown chunk type: ${exhaustiveCheck}`
+                        );
+                      }
                     }
-                  });
-                  const combinedUsage = addLanguageModelUsage(usage, stepUsage);
-                  await stepFinish.promise;
-                  const clientToolCalls = stepToolCalls.filter(
-                    (toolCall) => toolCall.providerExecuted !== true
-                  );
-                  const clientToolOutputs = stepToolOutputs.filter(
-                    (toolOutput) => toolOutput.providerExecuted !== true
-                  );
-                  for (const toolCall of stepToolCalls) {
-                    if (toolCall.providerExecuted !== true)
-                      continue;
-                    const tool2 = tools == null ? void 0 : tools[toolCall.toolName];
-                    if ((tool2 == null ? void 0 : tool2.type) === "provider" && tool2.supportsDeferredResults) {
-                      const hasResultInStep = stepToolOutputs.some(
-                        (output2) => output2.type === "tool-result" && output2.toolCallId === toolCall.toolCallId
+                  },
+                  // invoke onFinish callback and resolve toolResults promise when the stream is about to close:
+                  async flush(controller) {
+                    const stepToolCallsJson = stepToolCalls.length > 0 ? JSON.stringify(stepToolCalls) : void 0;
+                    try {
+                      doStreamSpan.setAttributes(
+                        await selectTelemetryAttributes({
+                          telemetry,
+                          attributes: {
+                            "ai.response.finishReason": stepFinishReason,
+                            "ai.response.text": {
+                              output: () => activeText
+                            },
+                            "ai.response.toolCalls": {
+                              output: () => stepToolCallsJson
+                            },
+                            "ai.response.id": stepResponse.id,
+                            "ai.response.model": stepResponse.modelId,
+                            "ai.response.timestamp": stepResponse.timestamp.toISOString(),
+                            "ai.response.providerMetadata": JSON.stringify(stepProviderMetadata),
+                            "ai.usage.inputTokens": stepUsage.inputTokens,
+                            "ai.usage.outputTokens": stepUsage.outputTokens,
+                            "ai.usage.totalTokens": stepUsage.totalTokens,
+                            "ai.usage.reasoningTokens": stepUsage.reasoningTokens,
+                            "ai.usage.cachedInputTokens": stepUsage.cachedInputTokens,
+                            // standardized gen-ai llm span attributes:
+                            "gen_ai.response.finish_reasons": [
+                              stepFinishReason
+                            ],
+                            "gen_ai.response.id": stepResponse.id,
+                            "gen_ai.response.model": stepResponse.modelId,
+                            "gen_ai.usage.input_tokens": stepUsage.inputTokens,
+                            "gen_ai.usage.output_tokens": stepUsage.outputTokens
+                          }
+                        })
                       );
-                      if (!hasResultInStep) {
-                        pendingDeferredToolCalls.set(toolCall.toolCallId, {
-                          toolName: toolCall.toolName
-                        });
+                    } catch (error) {
+                    } finally {
+                      doStreamSpan.end();
+                    }
+                    controller.enqueue({
+                      type: "finish-step",
+                      finishReason: stepFinishReason,
+                      rawFinishReason: stepRawFinishReason,
+                      usage: stepUsage,
+                      providerMetadata: stepProviderMetadata,
+                      response: {
+                        ...stepResponse,
+                        headers: response == null ? void 0 : response.headers
+                      }
+                    });
+                    const combinedUsage = addLanguageModelUsage(
+                      usage,
+                      stepUsage
+                    );
+                    await stepFinish.promise;
+                    const clientToolCalls = stepToolCalls.filter(
+                      (toolCall) => toolCall.providerExecuted !== true
+                    );
+                    const clientToolOutputs = stepToolOutputs.filter(
+                      (toolOutput) => toolOutput.providerExecuted !== true
+                    );
+                    for (const toolCall of stepToolCalls) {
+                      if (toolCall.providerExecuted !== true)
+                        continue;
+                      const tool2 = tools == null ? void 0 : tools[toolCall.toolName];
+                      if ((tool2 == null ? void 0 : tool2.type) === "provider" && tool2.supportsDeferredResults) {
+                        const hasResultInStep = stepToolOutputs.some(
+                          (output2) => (output2.type === "tool-result" || output2.type === "tool-error") && output2.toolCallId === toolCall.toolCallId
+                        );
+                        if (!hasResultInStep) {
+                          pendingDeferredToolCalls.set(toolCall.toolCallId, {
+                            toolName: toolCall.toolName
+                          });
+                        }
                       }
                     }
-                  }
-                  for (const output2 of stepToolOutputs) {
-                    if (output2.type === "tool-result") {
-                      pendingDeferredToolCalls.delete(output2.toolCallId);
+                    for (const output2 of stepToolOutputs) {
+                      if (output2.type === "tool-result" || output2.type === "tool-error") {
+                        pendingDeferredToolCalls.delete(output2.toolCallId);
+                      }
                     }
-                  }
-                  if (
-                    // Continue if:
-                    // 1. There are client tool calls that have all been executed, OR
-                    // 2. There are pending deferred results from provider-executed tools
-                    (clientToolCalls.length > 0 && clientToolOutputs.length === clientToolCalls.length || pendingDeferredToolCalls.size > 0) && // continue until a stop condition is met:
-                    !await isStopConditionMet({
-                      stopConditions,
-                      steps: recordedSteps
-                    })
-                  ) {
-                    responseMessages.push(
-                      ...await toResponseMessages({
-                        content: (
-                          // use transformed content to create the messages for the next step:
-                          recordedSteps[recordedSteps.length - 1].content
-                        ),
-                        tools
+                    clearStepTimeout();
+                    clearChunkTimeout();
+                    if (
+                      // Continue if:
+                      // 1. There are client tool calls that have all been executed, OR
+                      // 2. There are pending deferred results from provider-executed tools
+                      (clientToolCalls.length > 0 && clientToolOutputs.length === clientToolCalls.length || pendingDeferredToolCalls.size > 0) && // continue until a stop condition is met:
+                      !await isStopConditionMet({
+                        stopConditions,
+                        steps: recordedSteps
                       })
-                    );
-                    try {
-                      await streamStep({
-                        currentStep: currentStep + 1,
-                        responseMessages,
-                        usage: combinedUsage
-                      });
-                    } catch (error) {
+                    ) {
+                      responseMessages.push(
+                        ...await toResponseMessages({
+                          content: (
+                            // use transformed content to create the messages for the next step:
+                            recordedSteps[recordedSteps.length - 1].content
+                          ),
+                          tools
+                        })
+                      );
+                      try {
+                        await streamStep({
+                          currentStep: currentStep + 1,
+                          responseMessages,
+                          usage: combinedUsage
+                        });
+                      } catch (error) {
+                        controller.enqueue({
+                          type: "error",
+                          error
+                        });
+                        self.closeStream();
+                      }
+                    } else {
                       controller.enqueue({
-                        type: "error",
-                        error
+                        type: "finish",
+                        finishReason: stepFinishReason,
+                        rawFinishReason: stepRawFinishReason,
+                        totalUsage: combinedUsage
                       });
                       self.closeStream();
                     }
-                  } else {
-                    controller.enqueue({
-                      type: "finish",
-                      finishReason: stepFinishReason,
-                      rawFinishReason: stepRawFinishReason,
-                      totalUsage: combinedUsage
-                    });
-                    self.closeStream();
                   }
-                }
-              })
-            )
-          );
+                })
+              )
+            );
+          } finally {
+            clearStepTimeout();
+            clearChunkTimeout();
+          }
         }
         await streamStep({
           currentStep: 0,
@@ -9616,13 +10469,13 @@ var DefaultStreamTextResult = class {
     return this._rawFinishReason.promise;
   }
   /**
-  Split out a new stream from the original stream.
-  The original stream is replaced to allow for further splitting,
-  since we do not know how many times the stream will be split.
-  
-  Note: this leads to buffering the stream content on the server.
-  However, the LLM results are expected to be small enough to not cause issues.
-     */
+   * Split out a new stream from the original stream.
+   * The original stream is replaced to allow for further splitting,
+   * since we do not know how many times the stream will be split.
+   *
+   * Note: this leads to buffering the stream content on the server.
+   * However, the LLM results are expected to be small enough to not cause issues.
+   */
   teeStream() {
     const [stream1, stream2] = this.baseStream.tee();
     this.baseStream = stream2;
@@ -9653,14 +10506,14 @@ var DefaultStreamTextResult = class {
     );
   }
   async consumeStream(options) {
-    var _a142;
+    var _a21;
     try {
       await consumeStream({
         stream: this.fullStream,
         onError: options == null ? void 0 : options.onError
       });
     } catch (error) {
-      (_a142 = options == null ? void 0 : options.onError) == null ? void 0 : _a142.call(options, error);
+      (_a21 = options == null ? void 0 : options.onError) == null ? void 0 : _a21.call(options, error);
     }
   }
   get experimental_partialOutputStream() {
@@ -9679,10 +10532,20 @@ var DefaultStreamTextResult = class {
       )
     );
   }
+  get elementStream() {
+    var _a21, _b82, _c;
+    const transform = (_a21 = this.outputSpecification) == null ? void 0 : _a21.createElementStreamTransform();
+    if (transform == null) {
+      throw new UnsupportedFunctionalityError({
+        functionality: `element streams in ${(_c = (_b82 = this.outputSpecification) == null ? void 0 : _b82.name) != null ? _c : "text"} mode`
+      });
+    }
+    return createAsyncIterableStream(this.teeStream().pipeThrough(transform));
+  }
   get output() {
     return this.finalStep.then((step) => {
-      var _a142;
-      const output = (_a142 = this.outputSpecification) != null ? _a142 : text();
+      var _a21;
+      const output = (_a21 = this.outputSpecification) != null ? _a21 : text();
       return output.parseCompleteOutput(
         { text: step.text },
         {
@@ -9709,8 +10572,8 @@ var DefaultStreamTextResult = class {
       responseMessageId: generateMessageId
     }) : void 0;
     const isDynamic = (part) => {
-      var _a142;
-      const tool2 = (_a142 = this.tools) == null ? void 0 : _a142[part.toolName];
+      var _a21;
+      const tool2 = (_a21 = this.tools) == null ? void 0 : _a21[part.toolName];
       if (tool2 == null) {
         return part.dynamic;
       }
@@ -9811,6 +10674,7 @@ var DefaultStreamTextResult = class {
                 toolCallId: part.id,
                 toolName: part.toolName,
                 ...part.providerExecuted != null ? { providerExecuted: part.providerExecuted } : {},
+                ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {},
                 ...dynamic != null ? { dynamic } : {},
                 ...part.title != null ? { title: part.title } : {}
               });
@@ -10046,13 +10910,17 @@ var ToolLoopAgent = class {
     return this.settings.tools;
   }
   async prepareCall(options) {
-    var _a142, _b82, _c, _d;
+    var _a21, _b82, _c, _d;
+    const { onStepFinish: _settingsOnStepFinish, ...settingsWithoutCallback } = this.settings;
     const baseCallArgs = {
-      ...this.settings,
-      stopWhen: (_a142 = this.settings.stopWhen) != null ? _a142 : stepCountIs(20),
+      ...settingsWithoutCallback,
+      stopWhen: (_a21 = this.settings.stopWhen) != null ? _a21 : stepCountIs(20),
       ...options
     };
-    const preparedCallArgs = (_d = await ((_c = (_b82 = this.settings).prepareCall) == null ? void 0 : _c.call(_b82, baseCallArgs))) != null ? _d : baseCallArgs;
+    const preparedCallArgs = (_d = await ((_c = (_b82 = this.settings).prepareCall) == null ? void 0 : _c.call(
+      _b82,
+      baseCallArgs
+    ))) != null ? _d : baseCallArgs;
     const { instructions, messages, prompt, ...callArgs } = preparedCallArgs;
     return {
       ...callArgs,
@@ -10060,16 +10928,30 @@ var ToolLoopAgent = class {
       ...{ system: instructions, messages, prompt }
     };
   }
+  mergeOnStepFinishCallbacks(methodCallback) {
+    const constructorCallback = this.settings.onStepFinish;
+    if (methodCallback && constructorCallback) {
+      return async (stepResult) => {
+        await constructorCallback(stepResult);
+        await methodCallback(stepResult);
+      };
+    }
+    return methodCallback != null ? methodCallback : constructorCallback;
+  }
   /**
    * Generates an output from the agent (non-streaming).
    */
   async generate({
     abortSignal,
+    timeout,
+    onStepFinish,
     ...options
   }) {
     return generateText({
       ...await this.prepareCall(options),
-      abortSignal
+      abortSignal,
+      timeout,
+      onStepFinish: this.mergeOnStepFinishCallbacks(onStepFinish)
     });
   }
   /**
@@ -10077,13 +10959,17 @@ var ToolLoopAgent = class {
    */
   async stream({
     abortSignal,
+    timeout,
     experimental_transform,
+    onStepFinish,
     ...options
   }) {
     return streamText({
       ...await this.prepareCall(options),
       abortSignal,
-      experimental_transform
+      timeout,
+      experimental_transform,
+      onStepFinish: this.mergeOnStepFinishCallbacks(onStepFinish)
     });
   }
 };
@@ -10143,7 +11029,7 @@ async function embed({
             }),
             tracer,
             fn: async (doEmbedSpan) => {
-              var _a142;
+              var _a21;
               const modelResponse = await model.doEmbed({
                 values: [value],
                 abortSignal,
@@ -10151,7 +11037,7 @@ async function embed({
                 providerOptions
               });
               const embedding2 = modelResponse.embeddings[0];
-              const usage2 = (_a142 = modelResponse.usage) != null ? _a142 : { tokens: NaN };
+              const usage2 = (_a21 = modelResponse.usage) != null ? _a21 : { tokens: NaN };
               doEmbedSpan.setAttributes(
                 await selectTelemetryAttributes({
                   telemetry,
@@ -10211,5 +11097,5 @@ createIdGenerator({ prefix: "aiobj", size: 24 });
 createIdGenerator({ prefix: "aiobj", size: 24 });
 
 export { ToolLoopAgent, embed };
-//# sourceMappingURL=chunk-IPXNR6RQ.js.map
-//# sourceMappingURL=chunk-IPXNR6RQ.js.map
+//# sourceMappingURL=chunk-V2MLGA7T.js.map
+//# sourceMappingURL=chunk-V2MLGA7T.js.map