ai 7.0.0-beta.111 → 7.0.0-beta.113

package/dist/index.js

@@ -8,7 +8,7 @@ var __export = (target, all) => {
 import { createGateway, gateway as gateway2 } from "@ai-sdk/gateway";
 import {
   asSchema as asSchema5,
-  createIdGenerator as createIdGenerator8,
+  createIdGenerator as createIdGenerator9,
   dynamicTool,
   generateId,
   jsonSchema,
@@ -17,6 +17,9 @@ import {
   zodSchema as zodSchema3
 } from "@ai-sdk/provider-utils";
 
+// src/agent/tool-loop-agent.ts
+import { validateTypes as validateTypes3 } from "@ai-sdk/provider-utils";
+
 // src/generate-text/generate-text.ts
 import {
   asArray as asArray5,
@@ -1263,7 +1266,7 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "7.0.0-beta.111" : "0.0.0-test";
+var VERSION = true ? "7.0.0-beta.113" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({
@@ -1942,7 +1945,7 @@ function getMediaTypeFromUrl(url, fallbackMediaType = "application/octet-stream"
   try {
     const pathname = new URL(url).pathname;
     const ext = (_a21 = pathname.split(".").pop()) == null ? void 0 : _a21.toLowerCase();
-    if (ext && ext in URL_EXTENSION_TO_MEDIA_TYPE) {
+    if (ext && Object.hasOwn(URL_EXTENSION_TO_MEDIA_TYPE, ext)) {
       return URL_EXTENSION_TO_MEDIA_TYPE[ext];
     }
   } catch (e) {
@@ -2398,35 +2401,35 @@ var modelMessageSchema = z5.union([
 ]);
 
 // src/prompt/standardize-prompt.ts
-async function standardizePrompt(prompt) {
-  if (prompt.prompt == null && prompt.messages == null) {
+async function standardizePrompt({
+  allowSystemInMessages = false,
+  system,
+  prompt,
+  messages
+}) {
+  if (prompt == null && messages == null) {
     throw new InvalidPromptError2({
       prompt,
       message: "prompt or messages must be defined"
     });
   }
-  if (prompt.prompt != null && prompt.messages != null) {
+  if (prompt != null && messages != null) {
     throw new InvalidPromptError2({
       prompt,
       message: "prompt and messages cannot be defined at the same time"
     });
   }
-  if (prompt.system != null && typeof prompt.system !== "string" && !asArray2(prompt.system).every(
-    (message) => typeof message === "object" && message !== null && "role" in message && message.role === "system"
-  )) {
+  if (typeof system !== "string" && !asArray2(system).every((message) => message.role === "system")) {
     throw new InvalidPromptError2({
       prompt,
       message: "system must be a string, SystemModelMessage, or array of SystemModelMessage"
     });
   }
-  let messages;
-  if (prompt.prompt != null && typeof prompt.prompt === "string") {
-    messages = [{ role: "user", content: prompt.prompt }];
-  } else if (prompt.prompt != null && Array.isArray(prompt.prompt)) {
-    messages = prompt.prompt;
-  } else if (prompt.messages != null) {
-    messages = prompt.messages;
-  } else {
+  if (prompt != null && typeof prompt === "string") {
+    messages = [{ role: "user", content: prompt }];
+  } else if (prompt != null && Array.isArray(prompt)) {
+    messages = prompt;
+  } else if (messages == null) {
     throw new InvalidPromptError2({
       prompt,
       message: "prompt or messages must be defined"
@@ -2438,6 +2441,12 @@ async function standardizePrompt(prompt) {
       message: "messages must not be empty"
     });
   }
+  if (!allowSystemInMessages && messages.some((message) => message.role === "system")) {
+    throw new InvalidPromptError2({
+      prompt,
+      message: "System messages are not allowed in the prompt or messages fields. Use the system option instead."
+    });
+  }
   const validationResult = await safeValidateTypes({
     value: messages,
     schema: z6.array(modelMessageSchema)
@@ -2449,10 +2458,7 @@ async function standardizePrompt(prompt) {
       cause: validationResult.error
     });
   }
-  return {
-    messages,
-    system: prompt.system
-  };
+  return { messages, system };
 }
 
 // src/prompt/wrap-gateway-error.ts
@@ -2483,79 +2489,6 @@ Learn more: \x1B[34m${moreInfoURL}\x1B[0m
   );
 }
 
-// src/telemetry/create-unified-telemetry.ts
-import { asArray as asArray3 } from "@ai-sdk/provider-utils";
-
-// src/util/merge-callbacks.ts
-function mergeCallbacks(...callbacks) {
-  return async (event) => {
-    await Promise.allSettled(
-      callbacks.map(async (callback) => {
-        await (callback == null ? void 0 : callback(event));
-      })
-    );
-  };
-}
-
-// src/telemetry/telemetry-registry.ts
-function registerTelemetry(...integrations) {
-  if (!globalThis.AI_SDK_TELEMETRY_INTEGRATIONS) {
-    globalThis.AI_SDK_TELEMETRY_INTEGRATIONS = [];
-  }
-  globalThis.AI_SDK_TELEMETRY_INTEGRATIONS.push(...integrations);
-}
-function getGlobalTelemetryIntegrations() {
-  var _a21;
-  return (_a21 = globalThis.AI_SDK_TELEMETRY_INTEGRATIONS) != null ? _a21 : [];
-}
-
-// src/telemetry/create-unified-telemetry.ts
-function createUnifiedTelemetry({
-  integrations: localIntegrations
-}) {
-  const integrations = localIntegrations != null ? asArray3(localIntegrations) : getGlobalTelemetryIntegrations();
-  const mergeTelemetryCallback = (key) => mergeCallbacks(
-    ...integrations.map((integration) => {
-      var _a21;
-      return (_a21 = integration[key]) == null ? void 0 : _a21.bind(integration);
-    }).filter(Boolean)
-  );
-  const executeWrappers = integrations.map((integration) => {
-    var _a21;
-    return (_a21 = integration.executeTool) == null ? void 0 : _a21.bind(integration);
-  }).filter(Boolean);
-  return {
-    onStart: mergeTelemetryCallback("onStart"),
-    onStepStart: mergeTelemetryCallback("onStepStart"),
-    onToolExecutionStart: mergeTelemetryCallback("onToolExecutionStart"),
-    onToolExecutionEnd: mergeTelemetryCallback("onToolExecutionEnd"),
-    onChunk: mergeTelemetryCallback("onChunk"),
-    onStepFinish: mergeTelemetryCallback("onStepFinish"),
-    onObjectStepStart: mergeTelemetryCallback("onObjectStepStart"),
-    onObjectStepFinish: mergeTelemetryCallback("onObjectStepFinish"),
-    onEmbedStart: mergeTelemetryCallback("onEmbedStart"),
-    onEmbedFinish: mergeTelemetryCallback("onEmbedFinish"),
-    onRerankStart: mergeTelemetryCallback("onRerankStart"),
-    onRerankFinish: mergeTelemetryCallback("onRerankFinish"),
-    onFinish: mergeTelemetryCallback("onFinish"),
-    onError: mergeTelemetryCallback("onError"),
-    /**
-     * Composes all `executeTool` wrappers around the original tool execution.
-     * Each wrapper receives an `execute` function that calls the next wrapper in
-     * the chain, so integrations can establish nested telemetry context before
-     * delegating to the underlying tool.
-     */
-    executeTool: executeWrappers.length > 0 ? async (args) => {
-      let execute = args.execute;
-      for (const executeWrapper of executeWrappers) {
-        const innerExecute = execute;
-        execute = () => executeWrapper({ ...args, execute: innerExecute });
-      }
-      return await execute();
-    } : void 0
-  };
-}
-
 // src/types/usage.ts
 function asLanguageModelUsage(usage) {
   return {
@@ -2669,6 +2602,9 @@ function mergeObjects(base, overrides) {
   }
   const result = { ...base };
   for (const key in overrides) {
+    if (key === "__proto__" || key === "constructor" || key === "prototype") {
+      continue;
+    }
     if (Object.prototype.hasOwnProperty.call(overrides, key)) {
       const overridesValue = overrides[key];
       if (overridesValue === void 0)
@@ -2690,10 +2626,10 @@ function mergeObjects(base, overrides) {
 }
 
 // src/util/notify.ts
-import { asArray as asArray4 } from "@ai-sdk/provider-utils";
+import { asArray as asArray3 } from "@ai-sdk/provider-utils";
 async function notify(options) {
   await Promise.all(
-    asArray4(options.callbacks).map(async (callback) => {
+    asArray3(options.callbacks).map(async (callback) => {
       try {
         await (callback == null ? void 0 : callback(options.event));
       } catch (e) {
@@ -2943,14 +2879,10 @@ async function executeToolCall({
   toolCall,
   tools,
   toolsContext,
-  telemetry,
   callId,
   messages,
   abortSignal,
   timeout,
-  stepNumber,
-  provider,
-  modelId,
   onPreliminaryToolResult,
   onToolExecutionStart,
   onToolExecutionEnd,
@@ -2968,17 +2900,15 @@ async function executeToolCall({
   });
   const baseCallbackEvent = {
     callId,
-    stepNumber,
-    provider,
-    modelId,
     toolCall,
     messages,
-    functionId: telemetry == null ? void 0 : telemetry.functionId,
-    context
-    // TODO rename to toolContext
+    toolContext: context
   };
   let output;
-  await notify({ event: baseCallbackEvent, callbacks: onToolExecutionStart });
+  await notify({
+    event: baseCallbackEvent,
+    callbacks: onToolExecutionStart
+  });
   const toolTimeoutMs = getToolTimeoutMs(timeout, toolName);
   const toolAbortSignal = mergeAbortSignals(abortSignal, toolTimeoutMs);
   let durationMs = 0;
@@ -3017,16 +2947,7 @@ async function executeToolCall({
       }
     });
   } catch (error) {
-    await notify({
-      event: {
-        ...baseCallbackEvent,
-        success: false,
-        error,
-        durationMs
-      },
-      callbacks: onToolExecutionEnd
-    });
-    return {
+    const toolError = {
       type: "tool-error",
       toolCallId,
       toolName,
@@ -3035,17 +2956,17 @@ async function executeToolCall({
       dynamic: tool2.type === "dynamic",
       ...toolCall.providerMetadata != null ? { providerMetadata: toolCall.providerMetadata } : {}
     };
+    await notify({
+      event: {
+        ...baseCallbackEvent,
+        toolOutput: toolError,
+        durationMs
+      },
+      callbacks: onToolExecutionEnd
+    });
+    return toolError;
   }
-  await notify({
-    event: {
-      ...baseCallbackEvent,
-      success: true,
-      output,
-      durationMs
-    },
-    callbacks: onToolExecutionEnd
-  });
-  return {
+  const toolResult = {
     type: "tool-result",
     toolCallId,
     toolName,
@@ -3054,23 +2975,27 @@ async function executeToolCall({
     dynamic: tool2.type === "dynamic",
     ...toolCall.providerMetadata != null ? { providerMetadata: toolCall.providerMetadata } : {}
   };
+  await notify({
+    event: {
+      ...baseCallbackEvent,
+      toolOutput: toolResult,
+      durationMs
+    },
+    callbacks: onToolExecutionEnd
+  });
+  return toolResult;
 }
 
-// src/generate-text/filter-active-tool.ts
+// src/generate-text/filter-active-tools.ts
 function filterActiveTools({
   tools,
   activeTools
 }) {
-  if (tools == null) {
-    return void 0;
-  }
-  if (activeTools == null) {
+  if (tools == null || activeTools == null) {
     return tools;
   }
   return Object.fromEntries(
-    Object.entries(tools).filter(
-      ([name21]) => activeTools.includes(name21)
-    )
+    Object.entries(tools).filter(([name21]) => activeTools.includes(name21))
   );
 }
 
@@ -3111,33 +3036,6 @@ var DefaultGeneratedFileWithType = class extends DefaultGeneratedFile {
   }
 };
 
-// src/generate-text/is-tool-approval-needed.ts
-async function isToolApprovalNeeded({
-  tools,
-  toolCall,
-  toolNeedsApproval,
-  messages,
-  toolsContext
-}) {
-  const toolName = toolCall.toolName;
-  const tool2 = tools == null ? void 0 : tools[toolName];
-  const options = {
-    toolCallId: toolCall.toolCallId,
-    messages,
-    context: await validateToolContext({
-      toolName,
-      context: toolsContext == null ? void 0 : toolsContext[toolName],
-      contextSchema: tool2 == null ? void 0 : tool2.contextSchema
-    })
-  };
-  const input = toolCall.input;
-  const userDefinedToolNeedsApproval = toolNeedsApproval == null ? void 0 : toolNeedsApproval[toolName];
-  if (userDefinedToolNeedsApproval != null) {
-    return typeof userDefinedToolNeedsApproval === "boolean" ? userDefinedToolNeedsApproval : await userDefinedToolNeedsApproval(input, options);
-  }
-  return (tool2 == null ? void 0 : tool2.needsApproval) == null ? false : typeof tool2.needsApproval === "boolean" ? tool2.needsApproval : await tool2.needsApproval(input, options);
-}
-
 // src/generate-text/output.ts
 var output_exports = {};
 __export(output_exports, {
@@ -3975,6 +3873,103 @@ function convertToReasoningOutputs(parts) {
   });
 }
 
+// src/telemetry/create-telemetry-dispatcher.ts
+import { asArray as asArray4 } from "@ai-sdk/provider-utils";
+
+// src/util/merge-callbacks.ts
+function mergeCallbacks(...callbacks) {
+  return async (event) => {
+    await Promise.allSettled(
+      callbacks.map(async (callback) => {
+        await (callback == null ? void 0 : callback(event));
+      })
+    );
+  };
+}
+
+// src/telemetry/telemetry-registry.ts
+function registerTelemetry(...integrations) {
+  if (!globalThis.AI_SDK_TELEMETRY_INTEGRATIONS) {
+    globalThis.AI_SDK_TELEMETRY_INTEGRATIONS = [];
+  }
+  globalThis.AI_SDK_TELEMETRY_INTEGRATIONS.push(...integrations);
+}
+function getGlobalTelemetryIntegrations() {
+  var _a21;
+  return (_a21 = globalThis.AI_SDK_TELEMETRY_INTEGRATIONS) != null ? _a21 : [];
+}
+
+// src/telemetry/create-telemetry-dispatcher.ts
+function augmentEvent(event, telemetry) {
+  return Object.assign(
+    Object.create(Object.getPrototypeOf(event)),
+    event,
+    telemetry
+  );
+}
+function createTelemetryDispatcher({
+  telemetry
+}) {
+  if ((telemetry == null ? void 0 : telemetry.isEnabled) === false) {
+    return {};
+  }
+  const localIntegrations = telemetry == null ? void 0 : telemetry.integrations;
+  const integrations = localIntegrations != null ? asArray4(localIntegrations) : getGlobalTelemetryIntegrations();
+  const telemetryMetadata = {
+    recordInputs: telemetry == null ? void 0 : telemetry.recordInputs,
+    recordOutputs: telemetry == null ? void 0 : telemetry.recordOutputs,
+    functionId: telemetry == null ? void 0 : telemetry.functionId
+  };
+  const mergeTelemetryCallback = (key) => {
+    return mergeCallbacks(
+      ...integrations.map((integration) => {
+        var _a21;
+        return (_a21 = integration[key]) == null ? void 0 : _a21.bind(integration);
+      }).filter(Boolean).map(
+        (callback) => (event) => callback(augmentEvent(event, telemetryMetadata))
+      )
+    );
+  };
+  const executeWrappers = integrations.map((integration) => {
+    var _a21;
+    return (_a21 = integration.executeTool) == null ? void 0 : _a21.bind(integration);
+  }).filter(Boolean);
+  return {
+    onStart: mergeTelemetryCallback("onStart"),
+    onStepStart: mergeTelemetryCallback("onStepStart"),
+    onLanguageModelCallStart: mergeTelemetryCallback(
+      "onLanguageModelCallStart"
+    ),
+    onLanguageModelCallEnd: mergeTelemetryCallback("onLanguageModelCallEnd"),
+    onToolExecutionStart: mergeTelemetryCallback("onToolExecutionStart"),
+    onToolExecutionEnd: mergeTelemetryCallback("onToolExecutionEnd"),
+    onChunk: mergeTelemetryCallback("onChunk"),
+    onStepFinish: mergeTelemetryCallback("onStepFinish"),
+    onObjectStepStart: mergeTelemetryCallback("onObjectStepStart"),
+    onObjectStepFinish: mergeTelemetryCallback("onObjectStepFinish"),
+    onEmbedStart: mergeTelemetryCallback("onEmbedStart"),
+    onEmbedFinish: mergeTelemetryCallback("onEmbedFinish"),
+    onRerankStart: mergeTelemetryCallback("onRerankStart"),
+    onRerankFinish: mergeTelemetryCallback("onRerankFinish"),
+    onFinish: mergeTelemetryCallback("onFinish"),
+    onError: mergeTelemetryCallback("onError"),
+    /**
+     * Composes all `executeTool` wrappers around the original tool execution.
+     * Each wrapper receives an `execute` function that calls the next wrapper in
+     * the chain, so integrations can establish nested telemetry context before
+     * delegating to the underlying tool.
+     */
+    executeTool: executeWrappers.length > 0 ? async (args) => {
+      let execute = args.execute;
+      for (const executeWrapper of executeWrappers) {
+        const innerExecute = execute;
+        execute = () => executeWrapper({ ...args, execute: innerExecute });
+      }
+      return await execute();
+    } : void 0
+  };
+}
+
 // src/generate-text/reasoning.ts
 function asReasoningText(reasoningParts) {
   const reasoningText = reasoningParts.map((part) => "text" in part ? part.text : "").join("");
@@ -3988,7 +3983,6 @@ var DefaultStepResult = class {
     stepNumber,
     provider,
     modelId,
-    functionId,
     runtimeContext,
     toolsContext,
     content,
@@ -4003,7 +3997,6 @@ var DefaultStepResult = class {
     this.callId = callId;
     this.stepNumber = stepNumber;
     this.model = { provider, modelId };
-    this.functionId = functionId;
     this.runtimeContext = runtimeContext;
     this.toolsContext = toolsContext;
     this.content = content;
@@ -4062,6 +4055,222 @@ var DefaultStepResult = class {
   }
 };
 
+// src/generate-text/restricted-telemetry-dispatcher.ts
+function filterContext({
+  context,
+  sensitiveContext
+}) {
+  return sensitiveContext == null ? context : Object.fromEntries(
+    Object.entries(context).filter(
+      ([key]) => sensitiveContext[key] !== true
+    )
+  );
+}
+function restrictStepResult({
+  step,
+  tools,
+  sensitiveRuntimeContext
+}) {
+  return new DefaultStepResult({
+    callId: step.callId,
+    stepNumber: step.stepNumber,
+    provider: step.model.provider,
+    modelId: step.model.modelId,
+    runtimeContext: filterContext({
+      context: step.runtimeContext,
+      sensitiveContext: sensitiveRuntimeContext
+    }),
+    toolsContext: filterToolsContext({
+      tools,
+      toolsContext: step.toolsContext
+    }),
+    content: step.content,
+    finishReason: step.finishReason,
+    rawFinishReason: step.rawFinishReason,
+    usage: step.usage,
+    warnings: step.warnings,
+    request: step.request,
+    response: step.response,
+    providerMetadata: step.providerMetadata
+  });
+}
+function filterToolsContext({
+  tools,
+  toolsContext
+}) {
+  if (tools == null) {
+    return toolsContext;
+  }
+  return Object.fromEntries(
+    Object.entries(toolsContext).map(([toolName, toolContext]) => [
+      toolName,
+      filterToolContext({
+        tools,
+        toolName,
+        toolContext
+      })
+    ])
+  );
+}
+function filterToolContext({
+  tools,
+  toolName,
+  toolContext
+}) {
+  var _a21;
+  const sensitiveToolContext = (_a21 = tools == null ? void 0 : tools[toolName]) == null ? void 0 : _a21.sensitiveContext;
+  return sensitiveToolContext == null ? toolContext : filterContext({
+    context: toolContext,
+    sensitiveContext: sensitiveToolContext
+  });
+}
+function createRestrictedTelemetryDispatcher({
+  telemetry,
+  tools,
+  sensitiveRuntimeContext
+}) {
+  const telemetryDispatcher = createTelemetryDispatcher({ telemetry });
+  return {
+    ...telemetryDispatcher,
+    onStart: (event) => {
+      var _a21;
+      return (_a21 = telemetryDispatcher.onStart) == null ? void 0 : _a21.call(telemetryDispatcher, {
+        ...event,
+        runtimeContext: filterContext({
+          context: event.runtimeContext,
+          sensitiveContext: sensitiveRuntimeContext
+        }),
+        toolsContext: filterToolsContext({
+          tools,
+          toolsContext: event.toolsContext
+        })
+      });
+    },
+    onStepStart: (event) => {
+      var _a21;
+      return (_a21 = telemetryDispatcher.onStepStart) == null ? void 0 : _a21.call(telemetryDispatcher, {
+        ...event,
+        runtimeContext: filterContext({
+          context: event.runtimeContext,
+          sensitiveContext: sensitiveRuntimeContext
+        }),
+        steps: event.steps.map(
+          (step) => restrictStepResult({ step, tools, sensitiveRuntimeContext })
+        ),
+        toolsContext: filterToolsContext({
+          tools,
+          toolsContext: event.toolsContext
+        })
+      });
+    },
+    onStepFinish: (event) => {
+      var _a21;
+      return (_a21 = telemetryDispatcher.onStepFinish) == null ? void 0 : _a21.call(
+        telemetryDispatcher,
+        restrictStepResult({
+          step: event,
+          tools,
+          sensitiveRuntimeContext
+        })
+      );
+    },
+    onFinish: (event) => {
+      var _a21;
+      return (_a21 = telemetryDispatcher.onFinish) == null ? void 0 : _a21.call(telemetryDispatcher, {
+        ...event,
+        runtimeContext: filterContext({
+          context: event.runtimeContext,
+          sensitiveContext: sensitiveRuntimeContext
+        }),
+        steps: event.steps.map(
+          (step) => restrictStepResult({ step, tools, sensitiveRuntimeContext })
+        ),
+        toolsContext: filterToolsContext({
+          tools,
+          toolsContext: event.toolsContext
+        })
+      });
+    },
+    onToolExecutionStart: (event) => {
+      var _a21;
+      return (_a21 = telemetryDispatcher.onToolExecutionStart) == null ? void 0 : _a21.call(telemetryDispatcher, {
+        ...event,
+        toolContext: filterToolContext({
+          tools,
+          toolName: event.toolCall.toolName,
+          toolContext: event.toolContext
+        })
+      });
+    },
+    onToolExecutionEnd: (event) => {
+      var _a21;
+      return (_a21 = telemetryDispatcher.onToolExecutionEnd) == null ? void 0 : _a21.call(telemetryDispatcher, {
+        ...event,
+        toolContext: filterToolContext({
+          tools,
+          toolName: event.toolCall.toolName,
+          toolContext: event.toolContext
+        })
+      });
+    }
+  };
+}
+
+// src/generate-text/resolve-tool-approval.ts
+async function resolveToolApproval({
+  tools,
+  toolCall,
+  toolApproval,
+  messages,
+  toolsContext,
+  runtimeContext
+}) {
+  if (toolApproval != null && typeof toolApproval === "function") {
+    return normalizeToolApprovalStatus(
+      await toolApproval({
+        toolCall,
+        tools,
+        toolsContext,
+        messages,
+        runtimeContext
+      })
+    );
+  }
+  const toolName = toolCall.toolName;
+  const tool2 = tools == null ? void 0 : tools[toolName];
+  const input = toolCall.input;
+  const userDefinedToolApprovalStatus = toolApproval == null ? void 0 : toolApproval[toolName];
+  if (userDefinedToolApprovalStatus != null) {
+    const approvalStatus = typeof userDefinedToolApprovalStatus === "function" ? await userDefinedToolApprovalStatus(input, {
+      toolCallId: toolCall.toolCallId,
+      messages,
+      toolContext: await validateToolContext({
+        toolName,
+        context: toolsContext == null ? void 0 : toolsContext[toolName],
+        contextSchema: tool2 == null ? void 0 : tool2.contextSchema
+      }),
+      runtimeContext
+    }) : userDefinedToolApprovalStatus;
+    return normalizeToolApprovalStatus(approvalStatus);
+  }
+  if ((tool2 == null ? void 0 : tool2.needsApproval) == null) {
+    return { type: "not-applicable" };
+  }
+  const needsApproval = typeof tool2.needsApproval === "function" ? await tool2.needsApproval(input, {
+    toolCallId: toolCall.toolCallId,
+    messages,
+    context: await validateToolContext({
+      toolName,
+      context: toolsContext == null ? void 0 : toolsContext[toolName],
+      contextSchema: tool2 == null ? void 0 : tool2.contextSchema
+    })
+  }) : tool2.needsApproval;
+  return needsApproval ? { type: "user-approval" } : { type: "not-applicable" };
+}
+function normalizeToolApprovalStatus(status) {
+  return status === void 0 ? { type: "not-applicable" } : typeof status === "string" ? { type: status } : status;
+}
+
 // src/generate-text/stop-condition.ts
 function isStepCount(stepCount) {
   return ({ steps }) => steps.length === stepCount;
@@ -4187,7 +4396,8 @@ async function toResponseMessages({
         content.push({
           type: "tool-approval-request",
           approvalId: part.approvalId,
-          toolCallId: part.toolCall.toolCallId
+          toolCallId: part.toolCall.toolCallId,
+          isAutomatic: part.isAutomatic
         });
         break;
     }
@@ -4200,7 +4410,31 @@ async function toResponseMessages({
   }
   const toolResultContent = [];
   for (const part of inputContent) {
-    if (!(part.type === "tool-result" || part.type === "tool-error") || part.providerExecuted) {
+    if (part.type !== "tool-approval-response" && part.type !== "tool-result" && part.type !== "tool-error") {
+      continue;
+    }
+    if (part.type === "tool-approval-response") {
+      toolResultContent.push({
+        type: "tool-approval-response",
+        approvalId: part.approvalId,
+        approved: part.approved,
+        reason: part.reason,
+        providerExecuted: part.providerExecuted
+      });
+      if (part.approved === false) {
+        toolResultContent.push({
+          type: "tool-result",
+          toolCallId: part.toolCall.toolCallId,
+          toolName: part.toolCall.toolName,
+          output: {
+            type: "execution-denied",
+            reason: part.reason
+          }
+        });
+      }
+      continue;
+    }
+    if (part.providerExecuted) {
       continue;
     }
     const output = await createToolModelOutput({
@@ -4243,13 +4477,14 @@ async function generateText({
   system,
   prompt,
   messages,
+  allowSystemInMessages,
   maxRetries: maxRetriesArg,
   abortSignal,
   timeout,
   headers,
   stopWhen = isStepCount(1),
   output,
-  toolNeedsApproval,
+  toolApproval,
   experimental_telemetry,
   telemetry = experimental_telemetry,
   providerOptions,
@@ -4258,6 +4493,7 @@ async function generateText({
   experimental_repairToolCall: repairToolCall,
   experimental_download: download2,
   runtimeContext = {},
+  sensitiveRuntimeContext,
   toolsContext = {},
   experimental_include: include,
   _internal: {
@@ -4266,13 +4502,15 @@ async function generateText({
   } = {},
   experimental_onStart: onStart,
   experimental_onStepStart: onStepStart,
+  experimental_onLanguageModelCallStart: onLanguageModelCallStart,
+  experimental_onLanguageModelCallEnd: onLanguageModelCallEnd,
   experimental_onToolExecutionStart: onToolExecutionStart,
   experimental_onToolExecutionEnd: onToolExecutionEnd,
   onStepFinish,
   onFinish,
   ...settings
 }) {
-  var _a21, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r;
+  var _a21, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q;
   const model = resolveLanguageModel(modelArg);
   const stopConditions = asArray5(stopWhen);
   const totalTimeoutMs = getTotalTimeoutMs(timeout);
@@ -4295,11 +4533,14 @@ async function generateText({
   const initialPrompt = await standardizePrompt({
     system,
     prompt,
-    messages
+    messages,
+    allowSystemInMessages
   });
   const callId = generateCallId();
-  const unifiedTelemetry = createUnifiedTelemetry({
-    integrations: telemetry == null ? void 0 : telemetry.integrations
+  const telemetryDispatcher = createRestrictedTelemetryDispatcher({
+    telemetry,
+    tools,
+    sensitiveRuntimeContext
   });
   await notify({
     event: {
@@ -4308,8 +4549,7 @@ async function generateText({
       provider: model.provider,
       modelId: model.modelId,
       system,
-      prompt,
-      messages,
+      messages: initialPrompt.messages,
       tools,
       toolChoice,
       activeTools,
@@ -4326,57 +4566,45 @@ async function generateText({
       timeout,
       headers: headersWithUserAgent,
       providerOptions,
-      stopWhen,
       output,
-      isEnabled: (_a21 = telemetry == null ? void 0 : telemetry.isEnabled) != null ? _a21 : true,
-      recordInputs: telemetry == null ? void 0 : telemetry.recordInputs,
-      recordOutputs: telemetry == null ? void 0 : telemetry.recordOutputs,
-      functionId: telemetry == null ? void 0 : telemetry.functionId,
       runtimeContext,
       toolsContext
     },
-    callbacks: [
-      onStart,
-      unifiedTelemetry.onStart
-    ]
+    callbacks: [onStart, telemetryDispatcher.onStart]
   });
   try {
     const initialMessages = initialPrompt.messages;
     const responseMessages = [];
     const { approvedToolApprovals, deniedToolApprovals } = collectToolApprovals({ messages: initialMessages });
     const localApprovedToolApprovals = approvedToolApprovals.filter(
-      (toolApproval) => !toolApproval.toolCall.providerExecuted
+      (toolApproval2) => !toolApproval2.toolCall.providerExecuted
     );
     if (deniedToolApprovals.length > 0 || localApprovedToolApprovals.length > 0) {
       const toolOutputs = await executeTools({
         toolCalls: localApprovedToolApprovals.map(
-          (toolApproval) => toolApproval.toolCall
+          (toolApproval2) => toolApproval2.toolCall
         ),
         tools,
-        telemetry,
         callId,
         messages: initialMessages,
         abortSignal: mergedAbortSignal,
         timeout,
         toolsContext,
-        stepNumber: 0,
-        provider: model.provider,
-        modelId: model.modelId,
         onToolExecutionStart: (event) => notify({
           event,
           callbacks: [
             onToolExecutionStart,
-            unifiedTelemetry.onToolExecutionStart
+            telemetryDispatcher.onToolExecutionStart
           ]
         }),
         onToolExecutionEnd: (event) => notify({
           event,
           callbacks: [
             onToolExecutionEnd,
-            unifiedTelemetry.onToolExecutionEnd
+            telemetryDispatcher.onToolExecutionEnd
           ]
         }),
-        executeToolInTelemetryContext: unifiedTelemetry.executeTool
+        executeToolInTelemetryContext: telemetryDispatcher.executeTool
       });
       const toolContent = [];
       for (const output2 of toolOutputs) {
@@ -4394,19 +4622,19 @@ async function generateText({
           output: modelOutput
         });
       }
-      for (const toolApproval of deniedToolApprovals) {
+      for (const toolApproval2 of deniedToolApprovals) {
         toolContent.push({
           type: "tool-result",
-          toolCallId: toolApproval.toolCall.toolCallId,
-          toolName: toolApproval.toolCall.toolName,
+          toolCallId: toolApproval2.toolCall.toolCallId,
+          toolName: toolApproval2.toolCall.toolName,
           output: {
             type: "execution-denied",
-            reason: toolApproval.approvalResponse.reason,
+            reason: toolApproval2.approvalResponse.reason,
             // For provider-executed tools, include approvalId so provider can correlate
-            ...toolApproval.toolCall.providerExecuted && {
+            ...toolApproval2.toolCall.providerExecuted && {
               providerOptions: {
                 openai: {
-                  approvalId: toolApproval.approvalResponse.approvalId
+                  approvalId: toolApproval2.approvalResponse.approvalId
                 }
               }
             }
@@ -4422,6 +4650,8 @@ async function generateText({
     let currentModelResponse;
     let clientToolCalls = [];
     let clientToolOutputs = [];
+    let toolApprovalResponses = [];
+    let deniedToolApprovalResponses = [];
     const steps = [];
     const pendingDeferredToolCalls = /* @__PURE__ */ new Map();
     do {
@@ -4437,62 +4667,71 @@ async function generateText({
           toolsContext
         }));
         const stepModel = resolveLanguageModel(
-          (_b = prepareStepResult == null ? void 0 : prepareStepResult.model) != null ? _b : model
+          (_a21 = prepareStepResult == null ? void 0 : prepareStepResult.model) != null ? _a21 : model
         );
         const promptMessages = await convertToLanguageModelPrompt({
           prompt: {
-            system: (_c = prepareStepResult == null ? void 0 : prepareStepResult.system) != null ? _c : initialPrompt.system,
-            messages: (_d = prepareStepResult == null ? void 0 : prepareStepResult.messages) != null ? _d : stepInputMessages
+            system: (_b = prepareStepResult == null ? void 0 : prepareStepResult.system) != null ? _b : initialPrompt.system,
+            messages: (_c = prepareStepResult == null ? void 0 : prepareStepResult.messages) != null ? _c : stepInputMessages
           },
           supportedUrls: await stepModel.supportedUrls,
           download: download2,
           provider: stepModel.provider.split(".")[0]
         });
-        runtimeContext = (_e = prepareStepResult == null ? void 0 : prepareStepResult.runtimeContext) != null ? _e : runtimeContext;
-        toolsContext = (_f = prepareStepResult == null ? void 0 : prepareStepResult.toolsContext) != null ? _f : toolsContext;
+        runtimeContext = (_d = prepareStepResult == null ? void 0 : prepareStepResult.runtimeContext) != null ? _d : runtimeContext;
+        toolsContext = (_e = prepareStepResult == null ? void 0 : prepareStepResult.toolsContext) != null ? _e : toolsContext;
         const stepActiveTools = filterActiveTools({
           tools,
-          activeTools: (_g = prepareStepResult == null ? void 0 : prepareStepResult.activeTools) != null ? _g : activeTools
+          activeTools: (_f = prepareStepResult == null ? void 0 : prepareStepResult.activeTools) != null ? _f : activeTools
         });
         const stepTools = await prepareTools({
           tools: stepActiveTools
         });
         const stepToolChoice = prepareToolChoice({
-          toolChoice: (_h = prepareStepResult == null ? void 0 : prepareStepResult.toolChoice) != null ? _h : toolChoice
+          toolChoice: (_g = prepareStepResult == null ? void 0 : prepareStepResult.toolChoice) != null ? _g : toolChoice
         });
-        const stepMessages = (_i = prepareStepResult == null ? void 0 : prepareStepResult.messages) != null ? _i : stepInputMessages;
-        const stepSystem = (_j = prepareStepResult == null ? void 0 : prepareStepResult.system) != null ? _j : initialPrompt.system;
+        const stepMessages = (_h = prepareStepResult == null ? void 0 : prepareStepResult.messages) != null ? _h : stepInputMessages;
+        const stepSystem = (_i = prepareStepResult == null ? void 0 : prepareStepResult.system) != null ? _i : initialPrompt.system;
         const stepProviderOptions = mergeObjects(
           providerOptions,
           prepareStepResult == null ? void 0 : prepareStepResult.providerOptions
         );
+        const stepNumber = steps.length;
         await notify({
           event: {
             callId,
-            stepNumber: steps.length,
             provider: stepModel.provider,
             modelId: stepModel.modelId,
+            stepNumber,
             system: stepSystem,
             messages: stepMessages,
             tools,
-            toolChoice: (_k = prepareStepResult == null ? void 0 : prepareStepResult.toolChoice) != null ? _k : toolChoice,
-            activeTools: (_l = prepareStepResult == null ? void 0 : prepareStepResult.activeTools) != null ? _l : activeTools,
+            toolChoice: (_j = prepareStepResult == null ? void 0 : prepareStepResult.toolChoice) != null ? _j : toolChoice,
+            activeTools: (_k = prepareStepResult == null ? void 0 : prepareStepResult.activeTools) != null ? _k : activeTools,
             steps: [...steps],
             providerOptions: stepProviderOptions,
-            timeout,
-            headers,
-            stopWhen,
             output,
-            functionId: telemetry == null ? void 0 : telemetry.functionId,
             runtimeContext,
             promptMessages,
             stepTools,
             stepToolChoice,
             toolsContext
           },
+          callbacks: [onStepStart, telemetryDispatcher.onStepStart]
+        });
+        await notify({
+          event: {
+            callId,
+            provider: stepModel.provider,
+            modelId: stepModel.modelId,
+            system: stepSystem,
+            messages: stepMessages,
+            tools: stepTools,
+            ...callSettings2
+          },
           callbacks: [
-            onStepStart,
-            unifiedTelemetry.onStepStart
+            onLanguageModelCallStart,
+            telemetryDispatcher.onLanguageModelCallStart
           ]
         });
         currentModelResponse = await retry(async () => {
@@ -4530,6 +4769,31 @@ async function generateText({
           )
         );
         const toolApprovalRequests = {};
+        const stepToolApprovalResponses = {};
+        const blockedToolCallIds = /* @__PURE__ */ new Set();
+        const modelCallContent = asContent({
+          content: currentModelResponse.content,
+          toolCalls: stepToolCalls,
+          toolOutputs: [],
+          toolApprovalRequests: [],
+          toolApprovalResponses: [],
+          tools
+        });
+        await notify({
+          event: {
+            callId,
+            provider: stepModel.provider,
+            modelId: stepModel.modelId,
+            finishReason: currentModelResponse.finishReason.unified,
+            usage: asLanguageModelUsage(currentModelResponse.usage),
+            content: modelCallContent,
+            responseId: currentModelResponse.response.id
+          },
+          callbacks: [
+            onLanguageModelCallEnd,
+            telemetryDispatcher.onLanguageModelCallEnd
+          ]
+        });
         for (const toolCall of stepToolCalls) {
           if (toolCall.invalid) {
             continue;
@@ -4547,18 +4811,61 @@ async function generateText({
               context: runtimeContext
             });
           }
-          if (await isToolApprovalNeeded({
+          const toolApprovalStatus = await resolveToolApproval({
             tools,
-            toolNeedsApproval,
+            toolApproval,
             toolCall,
             messages: stepInputMessages,
-            toolsContext
-          })) {
-            toolApprovalRequests[toolCall.toolCallId] = {
-              type: "tool-approval-request",
-              approvalId: generateId2(),
-              toolCall
-            };
+            toolsContext,
+            runtimeContext
+          });
+          switch (toolApprovalStatus.type) {
+            case "user-approval": {
+              toolApprovalRequests[toolCall.toolCallId] = {
+                type: "tool-approval-request",
+                approvalId: generateId2(),
+                toolCall
+              };
+              blockedToolCallIds.add(toolCall.toolCallId);
+              break;
+            }
+            case "approved": {
+              const approvalId = generateId2();
+              toolApprovalRequests[toolCall.toolCallId] = {
+                type: "tool-approval-request",
+                approvalId,
+                toolCall,
+                isAutomatic: true
+              };
+              stepToolApprovalResponses[toolCall.toolCallId] = {
+                type: "tool-approval-response",
+                approvalId,
+                toolCall,
+                approved: true,
+                reason: toolApprovalStatus.reason,
+                providerExecuted: toolCall.providerExecuted
+              };
+              break;
+            }
+            case "denied": {
+              const approvalId = generateId2();
+              toolApprovalRequests[toolCall.toolCallId] = {
+                type: "tool-approval-request",
+                approvalId,
+                toolCall,
+                isAutomatic: true
+              };
+              stepToolApprovalResponses[toolCall.toolCallId] = {
+                type: "tool-approval-response",
+                approvalId,
+                toolCall,
+                approved: false,
+                reason: toolApprovalStatus.reason,
+                providerExecuted: toolCall.providerExecuted
+              };
+              blockedToolCallIds.add(toolCall.toolCallId);
+              break;
+            }
           }
         }
         const invalidToolCalls = stepToolCalls.filter(
@@ -4578,37 +4885,37 @@ async function generateText({
         clientToolCalls = stepToolCalls.filter(
           (toolCall) => !toolCall.providerExecuted
         );
+        toolApprovalResponses = Object.values(stepToolApprovalResponses);
+        deniedToolApprovalResponses = toolApprovalResponses.filter(
+          (toolApprovalResponse) => toolApprovalResponse.approved === false
+        );
         if (tools != null) {
           clientToolOutputs.push(
             ...await executeTools({
               toolCalls: clientToolCalls.filter(
-                (toolCall) => !toolCall.invalid && toolApprovalRequests[toolCall.toolCallId] == null
+                (toolCall) => !toolCall.invalid && !blockedToolCallIds.has(toolCall.toolCallId)
               ),
               tools,
-              telemetry,
               callId,
               messages: stepInputMessages,
               abortSignal: mergedAbortSignal,
               timeout,
               toolsContext,
-              stepNumber: steps.length,
-              provider: stepModel.provider,
-              modelId: stepModel.modelId,
               onToolExecutionStart: (event) => notify({
                 event,
                 callbacks: [
                   onToolExecutionStart,
-                  unifiedTelemetry.onToolExecutionStart
+                  telemetryDispatcher.onToolExecutionStart
                 ]
               }),
               onToolExecutionEnd: (event) => notify({
                 event,
                 callbacks: [
                   onToolExecutionEnd,
-                  unifiedTelemetry.onToolExecutionEnd
+                  telemetryDispatcher.onToolExecutionEnd
                 ]
               }),
-              executeToolInTelemetryContext: unifiedTelemetry.executeTool
+              executeToolInTelemetryContext: telemetryDispatcher.executeTool
             })
           );
         }
@@ -4637,6 +4944,7 @@ async function generateText({
           toolCalls: stepToolCalls,
           toolOutputs: clientToolOutputs,
           toolApprovalRequests: Object.values(toolApprovalRequests),
+          toolApprovalResponses,
           tools
         });
         responseMessages.push(
@@ -4645,21 +4953,19 @@ async function generateText({
             tools
           })
         );
-        const stepRequest = ((_m = include == null ? void 0 : include.requestBody) != null ? _m : true) ? (_n = currentModelResponse.request) != null ? _n : {} : { ...currentModelResponse.request, body: void 0 };
+        const stepRequest = ((_l = include == null ? void 0 : include.requestBody) != null ? _l : true) ? (_m = currentModelResponse.request) != null ? _m : {} : { ...currentModelResponse.request, body: void 0 };
         const stepResponse = {
           ...currentModelResponse.response,
           // deep clone msgs to avoid mutating past messages in multi-step:
           messages: structuredClone(responseMessages),
           // Conditionally include response body:
-          body: ((_o = include == null ? void 0 : include.responseBody) != null ? _o : true) ? (_p = currentModelResponse.response) == null ? void 0 : _p.body : void 0
+          body: ((_n = include == null ? void 0 : include.responseBody) != null ? _n : true) ? (_o = currentModelResponse.response) == null ? void 0 : _o.body : void 0
         };
-        const stepNumber = steps.length;
         const currentStepResult = new DefaultStepResult({
           callId,
           stepNumber,
           provider: stepModel.provider,
           modelId: stepModel.modelId,
-          functionId: telemetry == null ? void 0 : telemetry.functionId,
           runtimeContext,
           content: stepContent,
           finishReason: currentModelResponse.finishReason.unified,
@@ -4672,17 +4978,14 @@ async function generateText({
           toolsContext
         });
         logWarnings({
-          warnings: (_q = currentModelResponse.warnings) != null ? _q : [],
+          warnings: (_p = currentModelResponse.warnings) != null ? _p : [],
           provider: stepModel.provider,
           model: stepModel.modelId
         });
         steps.push(currentStepResult);
         await notify({
           event: currentStepResult,
-          callbacks: [
-            onStepFinish,
-            unifiedTelemetry.onStepFinish
-          ]
+          callbacks: [onStepFinish, telemetryDispatcher.onStepFinish]
         });
       } finally {
         if (stepTimeoutId != null) {
@@ -4691,9 +4994,9 @@ async function generateText({
       }
     } while (
       // Continue if:
-      // 1. There are client tool calls that have all been executed, OR
+      // 1. There are client tool calls that have all been executed or denied, 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:
+      (clientToolCalls.length > 0 && clientToolOutputs.length + deniedToolApprovalResponses.length === clientToolCalls.length || pendingDeferredToolCalls.size > 0) && // continue until a stop condition is met:
       !await isStopConditionMet({ stopConditions, steps })
     );
     const lastStep = steps[steps.length - 1];
@@ -4713,7 +5016,6 @@ async function generateText({
       callId,
       stepNumber: lastStep.stepNumber,
       model: lastStep.model,
-      functionId: lastStep.functionId,
       runtimeContext: lastStep.runtimeContext,
       finishReason: lastStep.finishReason,
       rawFinishReason: lastStep.rawFinishReason,
@@ -4740,10 +5042,7 @@ async function generateText({
     };
     await notify({
       event: onFinishEvent,
-      callbacks: [
-        onFinish,
-        unifiedTelemetry.onFinish
-      ]
+      callbacks: [onFinish, telemetryDispatcher.onFinish]
     });
     let resolvedOutput;
     if (lastStep.finishReason === "stop") {
@@ -4763,22 +5062,18 @@ async function generateText({
       output: resolvedOutput
     });
   } catch (error) {
-    await ((_r = unifiedTelemetry.onError) == null ? void 0 : _r.call(unifiedTelemetry, { callId, error }));
+    await ((_q = telemetryDispatcher.onError) == null ? void 0 : _q.call(telemetryDispatcher, { callId, error }));
     throw wrapGatewayError(error);
   }
 }
 async function executeTools({
   toolCalls,
   tools,
-  telemetry,
   callId,
   messages,
   abortSignal,
   timeout,
   toolsContext,
-  stepNumber,
-  provider,
-  modelId,
   onToolExecutionStart,
   onToolExecutionEnd,
   executeToolInTelemetryContext
@@ -4788,15 +5083,11 @@ async function executeTools({
       async (toolCall) => await executeToolCall({
         toolCall,
         tools,
-        telemetry,
         callId,
         messages,
         abortSignal,
         timeout,
         toolsContext,
-        stepNumber,
-        provider,
-        modelId,
         onToolExecutionStart,
         onToolExecutionEnd,
         executeToolInTelemetryContext
@@ -4885,9 +5176,17 @@ function asContent({
   toolCalls,
   toolOutputs,
   toolApprovalRequests,
+  toolApprovalResponses,
   tools
 }) {
   const contentParts = [];
+  const toolOutputsWithApprovalResponses = [];
+  const toolOutputsWithoutApprovalResponses = [];
+  const toolCallIdsWithApprovalResponses = new Set(
+    toolApprovalResponses.map(
+      (toolApprovalResponse) => toolApprovalResponse.toolCall.toolCallId
+    )
+  );
   for (const part of content) {
     switch (part.type) {
       case "text":
@@ -4990,7 +5289,20 @@ function asContent({
       }
     }
   }
-  return [...contentParts, ...toolOutputs, ...toolApprovalRequests];
+  for (const toolOutput of toolOutputs) {
+    if (toolCallIdsWithApprovalResponses.has(toolOutput.toolCallId)) {
+      toolOutputsWithApprovalResponses.push(toolOutput);
+    } else {
+      toolOutputsWithoutApprovalResponses.push(toolOutput);
+    }
+  }
+  return [
+    ...contentParts,
+    ...toolOutputsWithoutApprovalResponses,
+    ...toolApprovalRequests,
+    ...toolApprovalResponses,
+    ...toolOutputsWithApprovalResponses
+  ];
 }
 
 // src/generate-text/stream-text.ts
@@ -5000,7 +5312,7 @@ import {
 } from "@ai-sdk/provider";
 import {
   asArray as asArray6,
-  createIdGenerator as createIdGenerator2,
+  createIdGenerator as createIdGenerator3,
   DelayedPromise,
   filterNullable as filterNullable2,
   isAbortError as isAbortError2
@@ -5217,7 +5529,16 @@ var uiMessageChunkSchema = lazySchema(
       z7.strictObject({
         type: z7.literal("tool-approval-request"),
         approvalId: z7.string(),
-        toolCallId: z7.string()
+        toolCallId: z7.string(),
+        isAutomatic: z7.boolean().optional()
+      }),
+      z7.strictObject({
+        type: z7.literal("tool-approval-response"),
+        approvalId: z7.string(),
+        approved: z7.boolean(),
+        reason: z7.string().optional(),
+        providerExecuted: z7.boolean().optional(),
+        providerMetadata: providerMetadataSchema.optional()
       }),
       z7.strictObject({
         type: z7.literal("tool-output-available"),
@@ -5416,6 +5737,23 @@ function processUIMessageStream({
             }
             return toolInvocation;
           }
+          function getToolInvocationByApprovalId(approvalId) {
+            const toolInvocations = state.message.parts.filter(isToolUIPart);
+            const toolInvocation = toolInvocations.find(
+              (invocation) => {
+                var _a22;
+                return ((_a22 = invocation.approval) == null ? void 0 : _a22.id) === approvalId;
+              }
+            );
+            if (toolInvocation == null) {
+              throw new UIMessageStreamError({
+                chunkType: "tool-approval-response",
+                chunkId: approvalId,
+                message: `No tool invocation found for approval ID "${approvalId}".`
+              });
+            }
+            return toolInvocation;
+          }
           function updateToolPart(options) {
             var _a22;
             const part = state.message.parts.find(
@@ -5775,7 +6113,28 @@ function processUIMessageStream({
             case "tool-approval-request": {
               const toolInvocation = getToolInvocation(chunk.toolCallId);
               toolInvocation.state = "approval-requested";
-              toolInvocation.approval = { id: chunk.approvalId };
+              toolInvocation.approval = chunk.isAutomatic === true ? { id: chunk.approvalId, isAutomatic: true } : { id: chunk.approvalId };
+              write();
+              break;
+            }
+            case "tool-approval-response": {
+              const toolInvocation = getToolInvocationByApprovalId(
+                chunk.approvalId
+              );
+              const approval = toolInvocation.approval == null ? { id: chunk.approvalId } : toolInvocation.approval;
+              toolInvocation.state = "approval-responded";
+              toolInvocation.approval = {
+                id: chunk.approvalId,
+                approved: chunk.approved,
+                ...chunk.reason != null ? { reason: chunk.reason } : {},
+                ...approval.isAutomatic === true ? { isAutomatic: true } : {}
+              };
+              if (chunk.providerExecuted != null) {
+                toolInvocation.providerExecuted = chunk.providerExecuted;
+              }
+              if (chunk.providerMetadata != null) {
+                toolInvocation.callProviderMetadata = chunk.providerMetadata;
+              }
               write();
               break;
             }
@@ -6235,17 +6594,14 @@ function createStitchableStream() {
 // src/generate-text/create-execute-tools-transformation.ts
 function createExecuteToolsTransformation({
   tools,
-  telemetry,
   callId,
   messages,
   abortSignal,
   timeout,
   toolsContext,
-  toolNeedsApproval,
+  toolApproval,
+  runtimeContext,
   generateId: generateId2,
-  stepNumber,
-  provider,
-  modelId,
   onToolExecutionStart,
   onToolExecutionEnd,
   executeToolInTelemetryContext
@@ -6258,30 +6614,72 @@ function createExecuteToolsTransformation({
       switch (chunkType) {
         case "tool-call": {
           if (chunk.invalid) {
-            break;
+            return;
           }
           const tool2 = tools == null ? void 0 : tools[chunk.toolName];
           if (tool2 == null) {
-            break;
+            return;
           }
-          if (await isToolApprovalNeeded({
+          const toolApprovalStatus = await resolveToolApproval({
             tools,
             toolCall: chunk,
-            toolNeedsApproval,
+            toolApproval,
             messages,
-            toolsContext
-          })) {
-            controller.enqueue({
-              type: "tool-approval-request",
-              approvalId: generateId2(),
-              toolCall: chunk
-            });
-            break;
+            toolsContext,
+            runtimeContext
+          });
+          switch (toolApprovalStatus.type) {
+            case "user-approval": {
+              controller.enqueue({
+                type: "tool-approval-request",
+                approvalId: generateId2(),
+                toolCall: chunk
+              });
+              return;
+            }
+            case "denied": {
+              const approvalId = generateId2();
+              controller.enqueue({
+                type: "tool-approval-request",
+                approvalId,
+                toolCall: chunk,
+                isAutomatic: true
+              });
+              controller.enqueue({
+                type: "tool-approval-response",
+                approvalId,
+                approved: false,
+                toolCall: chunk,
+                reason: toolApprovalStatus.reason,
+                providerExecuted: chunk.providerExecuted
+              });
+              return;
+            }
+            case "approved": {
+              const approvalId = generateId2();
+              controller.enqueue({
+                type: "tool-approval-request",
+                approvalId,
+                toolCall: chunk,
+                isAutomatic: true
+              });
+              controller.enqueue({
+                type: "tool-approval-response",
+                approvalId,
+                approved: true,
+                toolCall: chunk,
+                reason: toolApprovalStatus.reason,
+                providerExecuted: chunk.providerExecuted
+              });
+              break;
+            }
+            case "not-applicable":
+              break;
           }
           if (tool2.execute != null && chunk.providerExecuted !== true) {
             toolCallsToExecute.push(chunk);
           }
-          break;
+          return;
         }
         case "model-call-end": {
           await Promise.all(
@@ -6290,15 +6688,11 @@ function createExecuteToolsTransformation({
                 const result = await executeToolCall({
                   toolCall,
                   tools,
-                  telemetry,
                   callId,
                   messages,
                   abortSignal,
                   timeout,
                   toolsContext,
-                  stepNumber,
-                  provider,
-                  modelId,
                   onToolExecutionStart,
                   onToolExecutionEnd,
                   executeToolInTelemetryContext,
@@ -6315,7 +6709,7 @@ function createExecuteToolsTransformation({
               }
             })
           );
-          break;
+          return;
         }
       }
     }
@@ -6389,6 +6783,17 @@ function invokeToolCallbacksFromStream({
 import {
   getErrorMessage as getErrorMessage6
 } from "@ai-sdk/provider";
+import {
+  createIdGenerator as createIdGenerator2
+} from "@ai-sdk/provider-utils";
+var originalGenerateId2 = createIdGenerator2({
+  prefix: "aitxt",
+  size: 24
+});
+var originalGenerateCallId2 = createIdGenerator2({
+  prefix: "call",
+  size: 24
+});
 async function streamLanguageModelCall({
   model,
   tools,
@@ -6397,20 +6802,30 @@ async function streamLanguageModelCall({
   prompt,
   system,
   messages,
+  allowSystemInMessages,
   download: download2,
   abortSignal,
   headers,
   includeRawChunks,
   providerOptions,
   repairToolCall,
+  callId,
+  _internal: {
+    generateId: generateId2 = originalGenerateId2,
+    generateCallId = originalGenerateCallId2
+  } = {},
   onStart,
+  onLanguageModelCallStart,
+  onLanguageModelCallEnd,
   ...callSettings
 }) {
   const resolvedModel = resolveLanguageModel(model);
+  const effectiveCallId = callId != null ? callId : generateCallId();
   const standardizedPrompt = await standardizePrompt({
     system,
     prompt,
-    messages
+    messages,
+    allowSystemInMessages
   });
   const promptMessages = await convertToLanguageModelPrompt({
     prompt: {
@@ -6431,6 +6846,18 @@ async function streamLanguageModelCall({
     event: { promptMessages },
     callbacks: onStart
   });
+  await notify({
+    event: {
+      callId: effectiveCallId,
+      provider: resolvedModel.provider,
+      modelId: resolvedModel.modelId,
+      system: standardizedPrompt.system,
+      messages: standardizedPrompt.messages,
+      tools: stepTools,
+      ...callSettings
+    },
+    callbacks: onLanguageModelCallStart
+  });
   const {
     stream: languageModelStream,
     response,
@@ -6451,7 +6878,12 @@ async function streamLanguageModelCall({
       tools,
       system: standardizedPrompt.system,
       messages: standardizedPrompt.messages,
-      repairToolCall
+      repairToolCall,
+      callId: effectiveCallId,
+      provider: resolvedModel.provider,
+      modelId: resolvedModel.modelId,
+      generateId: generateId2,
+      onLanguageModelCallEnd
     })
   );
   return {
@@ -6464,14 +6896,41 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform({
   tools,
   system,
   messages,
-  repairToolCall
+  repairToolCall,
+  callId,
+  provider,
+  modelId,
+  generateId: generateId2,
+  onLanguageModelCallEnd
 }) {
   const toolCallsByToolCallId = /* @__PURE__ */ new Map();
+  const modelCallContent = [];
+  const textPartIndexes = /* @__PURE__ */ new Map();
+  const reasoningPartIndexes = /* @__PURE__ */ new Map();
+  let responseId = generateId2();
   return new TransformStream({
     async transform(chunk, controller) {
-      var _a21, _b, _c;
+      var _a21, _b, _c, _d;
       switch (chunk.type) {
+        case "text-start":
+          upsertTextContentPart({
+            content: modelCallContent,
+            partIndexes: textPartIndexes,
+            id: chunk.id,
+            type: "text",
+            providerMetadata: chunk.providerMetadata
+          });
+          controller.enqueue(chunk);
+          break;
         case "text-delta":
+          upsertTextContentPart({
+            content: modelCallContent,
+            partIndexes: textPartIndexes,
+            id: chunk.id,
+            type: "text",
+            textDelta: chunk.delta,
+            providerMetadata: chunk.providerMetadata
+          });
           controller.enqueue({
             type: "text-delta",
             id: chunk.id,
@@ -6479,7 +6938,36 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform({
             providerMetadata: chunk.providerMetadata
           });
           break;
+        case "text-end":
+          upsertTextContentPart({
+            content: modelCallContent,
+            partIndexes: textPartIndexes,
+            id: chunk.id,
+            type: "text",
+            providerMetadata: chunk.providerMetadata
+          });
+          textPartIndexes.delete(chunk.id);
+          controller.enqueue(chunk);
+          break;
+        case "reasoning-start":
+          upsertTextContentPart({
+            content: modelCallContent,
+            partIndexes: reasoningPartIndexes,
+            id: chunk.id,
+            type: "reasoning",
+            providerMetadata: chunk.providerMetadata
+          });
+          controller.enqueue(chunk);
+          break;
         case "reasoning-delta":
+          upsertTextContentPart({
+            content: modelCallContent,
+            partIndexes: reasoningPartIndexes,
+            id: chunk.id,
+            type: "reasoning",
+            textDelta: chunk.delta,
+            providerMetadata: chunk.providerMetadata
+          });
           controller.enqueue({
             type: "reasoning-delta",
             id: chunk.id,
@@ -6487,24 +6975,54 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform({
             providerMetadata: chunk.providerMetadata
           });
           break;
+        case "reasoning-end":
+          upsertTextContentPart({
+            content: modelCallContent,
+            partIndexes: reasoningPartIndexes,
+            id: chunk.id,
+            type: "reasoning",
+            providerMetadata: chunk.providerMetadata
+          });
+          reasoningPartIndexes.delete(chunk.id);
+          controller.enqueue(chunk);
+          break;
         case "file":
         case "reasoning-file": {
+          const file = new DefaultGeneratedFileWithType({
+            data: chunk.data,
+            mediaType: chunk.mediaType
+          });
+          modelCallContent.push({
+            type: chunk.type,
+            file,
+            ...chunk.providerMetadata != null ? { providerMetadata: chunk.providerMetadata } : {}
+          });
           controller.enqueue({
             type: chunk.type,
-            file: new DefaultGeneratedFileWithType({
-              data: chunk.data,
-              mediaType: chunk.mediaType
-            }),
+            file,
             providerMetadata: chunk.providerMetadata
           });
           break;
         }
         case "finish": {
+          const usage = asLanguageModelUsage(chunk.usage);
+          await notify({
+            event: {
+              callId,
+              provider,
+              modelId,
+              finishReason: chunk.finishReason.unified,
+              usage,
+              content: modelCallContent,
+              responseId
+            },
+            callbacks: onLanguageModelCallEnd
+          });
           controller.enqueue({
             type: "model-call-end",
             finishReason: chunk.finishReason.unified,
             rawFinishReason: chunk.finishReason.raw,
-            usage: asLanguageModelUsage(chunk.usage),
+            usage,
             providerMetadata: chunk.providerMetadata
           });
           break;
@@ -6520,6 +7038,7 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform({
             });
             toolCallsByToolCallId.set(toolCall.toolCallId, toolCall);
             controller.enqueue(toolCall);
+            modelCallContent.push(toolCall);
             if (toolCall.invalid) {
               controller.enqueue({
                 type: "tool-error",
@@ -6549,36 +7068,38 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform({
             });
             break;
           }
-          controller.enqueue({
+          const toolApprovalRequest = {
             type: "tool-approval-request",
             approvalId: chunk.approvalId,
             toolCall
-          });
+          };
+          controller.enqueue(toolApprovalRequest);
+          modelCallContent.push(toolApprovalRequest);
           break;
         }
         case "tool-result": {
           const toolName = chunk.toolName;
-          controller.enqueue(
-            chunk.isError ? {
-              type: "tool-error",
-              toolCallId: chunk.toolCallId,
-              toolName,
-              input: (_a21 = toolCallsByToolCallId.get(chunk.toolCallId)) == null ? void 0 : _a21.input,
-              providerExecuted: true,
-              error: chunk.result,
-              dynamic: chunk.dynamic,
-              ...chunk.providerMetadata != null ? { providerMetadata: chunk.providerMetadata } : {}
-            } : {
-              type: "tool-result",
-              toolCallId: chunk.toolCallId,
-              toolName,
-              input: (_b = toolCallsByToolCallId.get(chunk.toolCallId)) == null ? void 0 : _b.input,
-              output: chunk.result,
-              providerExecuted: true,
-              dynamic: chunk.dynamic,
-              ...chunk.providerMetadata != null ? { providerMetadata: chunk.providerMetadata } : {}
-            }
-          );
+          const toolResultPart = chunk.isError ? {
+            type: "tool-error",
+            toolCallId: chunk.toolCallId,
+            toolName,
+            input: (_a21 = toolCallsByToolCallId.get(chunk.toolCallId)) == null ? void 0 : _a21.input,
+            providerExecuted: true,
+            error: chunk.result,
+            dynamic: chunk.dynamic,
+            ...chunk.providerMetadata != null ? { providerMetadata: chunk.providerMetadata } : {}
+          } : {
+            type: "tool-result",
+            toolCallId: chunk.toolCallId,
+            toolName,
+            input: (_b = toolCallsByToolCallId.get(chunk.toolCallId)) == null ? void 0 : _b.input,
+            output: chunk.result,
+            providerExecuted: true,
+            dynamic: chunk.dynamic,
+            ...chunk.providerMetadata != null ? { providerMetadata: chunk.providerMetadata } : {}
+          };
+          controller.enqueue(toolResultPart);
+          modelCallContent.push(toolResultPart);
           break;
         }
         case "tool-input-start": {
@@ -6598,6 +7119,7 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform({
           break;
         }
         case "response-metadata": {
+          responseId = (_d = chunk.id) != null ? _d : responseId;
           controller.enqueue({
             type: "model-call-response-metadata",
             id: chunk.id,
@@ -6607,19 +7129,47 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform({
           break;
         }
         default:
+          if (chunk.type === "custom" || chunk.type === "source") {
+            modelCallContent.push(chunk);
+          }
           controller.enqueue(chunk);
           break;
       }
     }
   });
 }
+function upsertTextContentPart({
+  content,
+  partIndexes,
+  id,
+  type,
+  textDelta,
+  providerMetadata
+}) {
+  let partIndex = partIndexes.get(id);
+  if (partIndex == null) {
+    partIndex = content.push({
+      type,
+      text: "",
+      ...providerMetadata != null ? { providerMetadata } : {}
+    }) - 1;
+    partIndexes.set(id, partIndex);
+  }
+  const part = content[partIndex];
+  if (textDelta != null) {
+    part.text += textDelta;
+  }
+  if (providerMetadata != null) {
+    part.providerMetadata = providerMetadata;
+  }
+}
 
 // src/generate-text/stream-text.ts
-var originalGenerateId2 = createIdGenerator2({
+var originalGenerateId3 = createIdGenerator3({
   prefix: "aitxt",
   size: 24
 });
-var originalGenerateCallId2 = createIdGenerator2({
+var originalGenerateCallId3 = createIdGenerator3({
   prefix: "call",
   size: 24
 });
@@ -6630,13 +7180,14 @@ function streamText({
   system,
   prompt,
   messages,
+  allowSystemInMessages,
   maxRetries,
   abortSignal,
   timeout,
   headers,
   stopWhen = isStepCount(1),
   output,
-  toolNeedsApproval,
+  toolApproval,
   experimental_telemetry,
   telemetry = experimental_telemetry,
   prepareStep,
@@ -6655,15 +7206,18 @@ function streamText({
   onStepFinish,
   experimental_onStart: onStart,
   experimental_onStepStart: onStepStart,
+  experimental_onLanguageModelCallStart: onLanguageModelCallStart,
+  experimental_onLanguageModelCallEnd: onLanguageModelCallEnd,
   experimental_onToolExecutionStart: onToolExecutionStart,
   experimental_onToolExecutionEnd: onToolExecutionEnd,
   runtimeContext = {},
+  sensitiveRuntimeContext,
   toolsContext = {},
   experimental_include: include,
   _internal: {
     now: now2 = now,
-    generateId: generateId2 = originalGenerateId2,
-    generateCallId = originalGenerateCallId2
+    generateId: generateId2 = originalGenerateId3,
+    generateCallId = originalGenerateCallId3
   } = {},
   ...settings
 }) {
@@ -6691,21 +7245,22 @@ function streamText({
     system,
     prompt,
     messages,
+    allowSystemInMessages,
     tools,
     toolsContext,
     runtimeContext,
+    sensitiveRuntimeContext,
     toolChoice,
     transforms: asArray6(transform),
     activeTools,
     repairToolCall,
     stopConditions: asArray6(stopWhen),
     output,
-    toolNeedsApproval,
+    toolApproval,
     providerOptions,
     prepareStep,
     includeRawChunks,
     timeout,
-    stopWhen,
     onChunk,
     onError,
     onFinish,
@@ -6713,6 +7268,8 @@ function streamText({
     onStepFinish,
     onStart,
     onStepStart,
+    onLanguageModelCallStart,
+    onLanguageModelCallEnd,
     onToolExecutionStart,
     onToolExecutionEnd,
     now: now2,
@@ -6799,6 +7356,7 @@ var DefaultStreamTextResult = class {
     system,
     prompt,
     messages,
+    allowSystemInMessages,
     tools,
     toolChoice,
     transforms,
@@ -6806,7 +7364,7 @@ var DefaultStreamTextResult = class {
     repairToolCall,
     stopConditions,
     output,
-    toolNeedsApproval,
+    toolApproval,
     providerOptions,
     prepareStep,
     includeRawChunks,
@@ -6814,7 +7372,6 @@ var DefaultStreamTextResult = class {
     generateId: generateId2,
     generateCallId,
     timeout,
-    stopWhen,
     onChunk,
     onError,
     onFinish,
@@ -6822,9 +7379,12 @@ var DefaultStreamTextResult = class {
     onStepFinish,
     onStart,
     onStepStart,
+    onLanguageModelCallStart,
+    onLanguageModelCallEnd,
     onToolExecutionStart,
     onToolExecutionEnd,
     runtimeContext,
+    sensitiveRuntimeContext,
     toolsContext,
     download: download2,
     include
@@ -6833,12 +7393,13 @@ var DefaultStreamTextResult = class {
     this._finishReason = new DelayedPromise();
     this._rawFinishReason = new DelayedPromise();
     this._steps = new DelayedPromise();
-    var _a21;
     this.outputSpecification = output;
     this.includeRawChunks = includeRawChunks;
     this.tools = tools;
-    const unifiedTelemetry = createUnifiedTelemetry({
-      integrations: telemetry == null ? void 0 : telemetry.integrations
+    const telemetryDispatcher = createRestrictedTelemetryDispatcher({
+      telemetry,
+      tools,
+      sensitiveRuntimeContext
     });
     let stepFinish;
     let recordedContent = [];
@@ -6854,7 +7415,7 @@ var DefaultStreamTextResult = class {
     let activeReasoningContent = {};
     const eventProcessor = new TransformStream({
       async transform(chunk, controller) {
-        var _a22, _b, _c, _d;
+        var _a21, _b, _c, _d;
         controller.enqueue(chunk);
         const { part } = chunk;
         if (part.type === "text-delta" || part.type === "reasoning-delta" || part.type === "custom" || part.type === "source" || part.type === "tool-call" || part.type === "tool-result" || part.type === "tool-input-start" || part.type === "tool-input-delta" || part.type === "raw") {
@@ -6863,6 +7424,9 @@ var DefaultStreamTextResult = class {
         if (part.type === "error") {
           await onError({ error: wrapGatewayError(part.error) });
         }
+        if (part.type === "custom" || part.type === "source" || part.type === "tool-call" || part.type === "tool-approval-request" || part.type === "tool-approval-response" || part.type === "tool-error") {
+          recordedContent.push(part);
+        }
         if (part.type === "text-start") {
           activeTextContent[part.id] = {
             type: "text",
@@ -6884,7 +7448,7 @@ var DefaultStreamTextResult = class {
             return;
           }
           activeText.text += part.text;
-          activeText.providerMetadata = (_a22 = part.providerMetadata) != null ? _a22 : activeText.providerMetadata;
+          activeText.providerMetadata = (_a21 = part.providerMetadata) != null ? _a21 : activeText.providerMetadata;
         }
         if (part.type === "text-end") {
           const activeText = activeTextContent[part.id];
@@ -6946,24 +7510,9 @@ var DefaultStreamTextResult = class {
             ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
           });
         }
-        if (part.type === "custom") {
-          recordedContent.push(part);
-        }
-        if (part.type === "source") {
-          recordedContent.push(part);
-        }
-        if (part.type === "tool-call") {
-          recordedContent.push(part);
-        }
         if (part.type === "tool-result" && !part.preliminary) {
           recordedContent.push(part);
         }
-        if (part.type === "tool-approval-request") {
-          recordedContent.push(part);
-        }
-        if (part.type === "tool-error") {
-          recordedContent.push(part);
-        }
         if (part.type === "start-step") {
           recordedContent = [];
           activeReasoningContent = {};
@@ -6981,7 +7530,6 @@ var DefaultStreamTextResult = class {
             stepNumber: recordedSteps.length,
             provider: model.provider,
             modelId: model.modelId,
-            ...callbackTelemetryProps,
             runtimeContext,
             toolsContext,
             content: recordedContent,
@@ -6998,7 +7546,7 @@ var DefaultStreamTextResult = class {
           });
           await notify({
             event: currentStepResult,
-            callbacks: [onStepFinish, unifiedTelemetry.onStepFinish]
+            callbacks: [onStepFinish, telemetryDispatcher.onStepFinish]
           });
           logWarnings({
             warnings: recordedWarnings,
@@ -7040,7 +7588,6 @@ var DefaultStreamTextResult = class {
               toolsContext: finalStep.toolsContext,
               stepNumber: finalStep.stepNumber,
               model: finalStep.model,
-              functionId: finalStep.functionId,
               runtimeContext: finalStep.runtimeContext,
               finishReason: finalStep.finishReason,
               rawFinishReason: finalStep.rawFinishReason,
@@ -7064,10 +7611,7 @@ var DefaultStreamTextResult = class {
               providerMetadata: finalStep.providerMetadata,
               steps: recordedSteps
             },
-            callbacks: [
-              onFinish,
-              unifiedTelemetry.onFinish
-            ]
+            callbacks: [onFinish, telemetryDispatcher.onFinish]
           });
         } catch (error) {
           controller.error(error);
@@ -7146,20 +7690,12 @@ var DefaultStreamTextResult = class {
     const callSettings = prepareLanguageModelCallOptions(settings);
     const self = this;
     const callId = generateCallId();
-    const callbackTelemetryProps = {
-      functionId: telemetry == null ? void 0 : telemetry.functionId
-    };
-    const onStartTelemetryProps = {
-      isEnabled: (_a21 = telemetry == null ? void 0 : telemetry.isEnabled) != null ? _a21 : true,
-      recordInputs: telemetry == null ? void 0 : telemetry.recordInputs,
-      recordOutputs: telemetry == null ? void 0 : telemetry.recordOutputs,
-      functionId: telemetry == null ? void 0 : telemetry.functionId
-    };
     (async () => {
       const initialPrompt = await standardizePrompt({
         system,
         prompt,
-        messages
+        messages,
+        allowSystemInMessages
       });
       await notify({
         event: {
@@ -7168,8 +7704,7 @@ var DefaultStreamTextResult = class {
           provider: model.provider,
           modelId: model.modelId,
           system,
-          prompt,
-          messages,
+          messages: initialPrompt.messages,
           tools,
           toolChoice,
           activeTools,
@@ -7186,29 +7721,24 @@ var DefaultStreamTextResult = class {
           timeout,
           headers,
           providerOptions,
-          stopWhen,
           output,
-          ...onStartTelemetryProps,
           runtimeContext,
           toolsContext
         },
-        callbacks: [
-          onStart,
-          unifiedTelemetry.onStart
-        ]
+        callbacks: [onStart, telemetryDispatcher.onStart]
       });
       const initialMessages = initialPrompt.messages;
       const initialResponseMessages = [];
       const { approvedToolApprovals, deniedToolApprovals } = collectToolApprovals({ messages: initialMessages });
       if (deniedToolApprovals.length > 0 || approvedToolApprovals.length > 0) {
         const localApprovedToolApprovals = approvedToolApprovals.filter(
-          (toolApproval) => !toolApproval.toolCall.providerExecuted
+          (toolApproval2) => !toolApproval2.toolCall.providerExecuted
         );
         const localDeniedToolApprovals = deniedToolApprovals.filter(
-          (toolApproval) => !toolApproval.toolCall.providerExecuted
+          (toolApproval2) => !toolApproval2.toolCall.providerExecuted
         );
         const deniedProviderExecutedToolApprovals = deniedToolApprovals.filter(
-          (toolApproval) => toolApproval.toolCall.providerExecuted
+          (toolApproval2) => toolApproval2.toolCall.providerExecuted
         );
         let toolExecutionStepStreamController;
         const toolExecutionStepStream = new ReadableStream({
@@ -7218,40 +7748,36 @@ var DefaultStreamTextResult = class {
         });
         self.addStream(toolExecutionStepStream);
         try {
-          for (const toolApproval of [
+          for (const toolApproval2 of [
             ...localDeniedToolApprovals,
             ...deniedProviderExecutedToolApprovals
           ]) {
             toolExecutionStepStreamController == null ? void 0 : toolExecutionStepStreamController.enqueue({
               type: "tool-output-denied",
-              toolCallId: toolApproval.toolCall.toolCallId,
-              toolName: toolApproval.toolCall.toolName
+              toolCallId: toolApproval2.toolCall.toolCallId,
+              toolName: toolApproval2.toolCall.toolName
             });
           }
           const toolOutputs = [];
           await Promise.all(
-            localApprovedToolApprovals.map(async (toolApproval) => {
+            localApprovedToolApprovals.map(async (toolApproval2) => {
               const result = await executeToolCall({
-                toolCall: toolApproval.toolCall,
+                toolCall: toolApproval2.toolCall,
                 tools,
-                telemetry,
                 callId,
                 messages: initialMessages,
                 abortSignal,
                 timeout,
                 toolsContext,
-                stepNumber: recordedSteps.length,
-                provider: model.provider,
-                modelId: model.modelId,
                 onToolExecutionStart: filterNullable2(
                   onToolExecutionStart,
-                  unifiedTelemetry.onToolExecutionStart
+                  telemetryDispatcher.onToolExecutionStart
                 ),
                 onToolExecutionEnd: filterNullable2(
                   onToolExecutionEnd,
-                  unifiedTelemetry.onToolExecutionEnd
+                  telemetryDispatcher.onToolExecutionEnd
                 ),
-                executeToolInTelemetryContext: unifiedTelemetry.executeTool,
+                executeToolInTelemetryContext: telemetryDispatcher.executeTool,
                 onPreliminaryToolResult: (result2) => {
                   toolExecutionStepStreamController == null ? void 0 : toolExecutionStepStreamController.enqueue(result2);
                 }
@@ -7278,14 +7804,14 @@ var DefaultStreamTextResult = class {
                 })
               });
             }
-            for (const toolApproval of localDeniedToolApprovals) {
+            for (const toolApproval2 of localDeniedToolApprovals) {
               localToolContent.push({
                 type: "tool-result",
-                toolCallId: toolApproval.toolCall.toolCallId,
-                toolName: toolApproval.toolCall.toolName,
+                toolCallId: toolApproval2.toolCall.toolCallId,
+                toolName: toolApproval2.toolCall.toolName,
                 output: {
                   type: "execution-denied",
-                  reason: toolApproval.approvalResponse.reason
+                  reason: toolApproval2.approvalResponse.reason
                 }
               });
             }
@@ -7304,7 +7830,7 @@ var DefaultStreamTextResult = class {
         responseMessages,
         usage
       }) {
-        var _a22, _b, _c, _d, _e, _f, _g, _h;
+        var _a21, _b, _c, _d, _e, _f, _g, _h;
         const includeRawChunks2 = self.includeRawChunks;
         const stepTimeoutId = stepTimeoutMs != null ? setTimeout(() => stepAbortController.abort(), stepTimeoutMs) : void 0;
         let chunkTimeoutId = void 0;
@@ -7342,7 +7868,7 @@ var DefaultStreamTextResult = class {
             runtimeContext
           }));
           const stepModel = resolveLanguageModel(
-            (_a22 = prepareStepResult == null ? void 0 : prepareStepResult.model) != null ? _a22 : model
+            (_a21 = prepareStepResult == null ? void 0 : prepareStepResult.model) != null ? _a21 : model
           );
           const stepActiveTools = filterActiveTools({
             tools,
@@ -7370,9 +7896,9 @@ var DefaultStreamTextResult = class {
             response
           } = await retry(
             async () => {
-              var _a23, _b2;
+              var _a22, _b2;
               return streamLanguageModelCall({
-                model: (_a23 = prepareStepResult == null ? void 0 : prepareStepResult.model) != null ? _a23 : model,
+                model: (_a22 = prepareStepResult == null ? void 0 : prepareStepResult.model) != null ? _a22 : model,
                 tools: stepActiveTools,
                 toolChoice: (_b2 = prepareStepResult == null ? void 0 : prepareStepResult.toolChoice) != null ? _b2 : toolChoice,
                 system: stepSystem,
@@ -7384,36 +7910,38 @@ var DefaultStreamTextResult = class {
                 providerOptions: stepProviderOptions,
                 download: download2,
                 output,
+                callId,
+                onLanguageModelCallStart: filterNullable2(
+                  onLanguageModelCallStart,
+                  telemetryDispatcher.onLanguageModelCallStart
+                ),
+                onLanguageModelCallEnd: filterNullable2(
+                  onLanguageModelCallEnd,
+                  telemetryDispatcher.onLanguageModelCallEnd
+                ),
                 onStart: async ({ promptMessages }) => {
-                  var _a24, _b3;
+                  var _a23, _b3;
                   await notify({
                     event: {
                       callId,
-                      stepNumber: recordedSteps.length,
                       provider: stepModel.provider,
                       modelId: stepModel.modelId,
+                      stepNumber: recordedSteps.length,
                       system: stepSystem,
                       messages: stepMessages,
                       tools,
-                      toolChoice: (_a24 = prepareStepResult == null ? void 0 : prepareStepResult.toolChoice) != null ? _a24 : toolChoice,
+                      toolChoice: (_a23 = prepareStepResult == null ? void 0 : prepareStepResult.toolChoice) != null ? _a23 : toolChoice,
                       activeTools: (_b3 = prepareStepResult == null ? void 0 : prepareStepResult.activeTools) != null ? _b3 : activeTools,
                       steps: [...recordedSteps],
                       providerOptions: stepProviderOptions,
-                      timeout,
-                      headers,
-                      stopWhen,
-                      output,
-                      ...callbackTelemetryProps,
                       runtimeContext,
                       toolsContext,
+                      output,
                       promptMessages,
                       stepTools,
                       stepToolChoice
                     },
-                    callbacks: [
-                      onStepStart,
-                      unifiedTelemetry.onStepStart
-                    ]
+                    callbacks: [onStepStart, telemetryDispatcher.onStepStart]
                   });
                 },
                 ...callSettings
@@ -7430,31 +7958,29 @@ var DefaultStreamTextResult = class {
           const streamWithToolResults = stream2.pipeThrough(
             createExecuteToolsTransformation({
               tools,
-              telemetry,
               callId,
               messages: stepInputMessages,
               abortSignal,
               timeout,
               toolsContext,
-              toolNeedsApproval,
+              toolApproval,
+              runtimeContext,
               generateId: generateId2,
-              stepNumber: recordedSteps.length,
-              provider: stepModel.provider,
-              modelId: stepModel.modelId,
               onToolExecutionStart: filterNullable2(
                 onToolExecutionStart,
-                unifiedTelemetry.onToolExecutionStart
+                telemetryDispatcher.onToolExecutionStart
               ),
               onToolExecutionEnd: filterNullable2(
                 onToolExecutionEnd,
-                unifiedTelemetry.onToolExecutionEnd
+                telemetryDispatcher.onToolExecutionEnd
               ),
-              executeToolInTelemetryContext: unifiedTelemetry.executeTool
+              executeToolInTelemetryContext: telemetryDispatcher.executeTool
             })
           );
           const stepRequest = ((_h = include == null ? void 0 : include.requestBody) != null ? _h : true) ? request != null ? request : {} : { ...request, body: void 0 };
           const stepToolCalls = [];
           const stepToolOutputs = [];
+          const stepToolApprovalResponses = [];
           let warnings;
           let stepFinishReason = "other";
           let stepRawFinishReason = void 0;
@@ -7470,7 +7996,7 @@ var DefaultStreamTextResult = class {
             streamWithToolResults.pipeThrough(
               new TransformStream({
                 async transform(chunk, controller) {
-                  var _a23, _b2, _c2, _d2, _e2, _f2, _g2;
+                  var _a22, _b2, _c2, _d2, _e2, _f2, _g2;
                   resetChunkTimeout();
                   if (chunk.type === "model-call-start") {
                     warnings = chunk.warnings;
@@ -7484,7 +8010,7 @@ var DefaultStreamTextResult = class {
                       request: stepRequest,
                       warnings: warnings != null ? warnings : []
                     });
-                    void ((_a23 = unifiedTelemetry.onChunk) == null ? void 0 : _a23.call(unifiedTelemetry, {
+                    void ((_a22 = telemetryDispatcher.onChunk) == null ? void 0 : _a22.call(telemetryDispatcher, {
                       chunk: {
                         type: "ai.stream.firstChunk",
                         callId,
@@ -7497,9 +8023,19 @@ var DefaultStreamTextResult = class {
                   }
                   const chunkType = chunk.type;
                   switch (chunkType) {
-                    case "tool-approval-request":
+                    case "file":
+                    case "custom":
+                    case "source":
                     case "text-start":
-                    case "text-end": {
+                    case "text-end":
+                    case "reasoning-start":
+                    case "reasoning-end":
+                    case "reasoning-delta":
+                    case "reasoning-file":
+                    case "tool-input-start":
+                    case "tool-input-end":
+                    case "tool-input-delta":
+                    case "tool-approval-request": {
                       controller.enqueue(chunk);
                       break;
                     }
@@ -7509,22 +8045,14 @@ var DefaultStreamTextResult = class {
                       }
                       break;
                     }
-                    case "reasoning-start":
-                    case "reasoning-end": {
-                      controller.enqueue(chunk);
-                      break;
-                    }
-                    case "custom": {
-                      controller.enqueue(chunk);
-                      break;
-                    }
-                    case "reasoning-delta": {
+                    case "tool-call": {
                       controller.enqueue(chunk);
+                      stepToolCalls.push(chunk);
                       break;
                     }
-                    case "tool-call": {
+                    case "tool-approval-response": {
                       controller.enqueue(chunk);
-                      stepToolCalls.push(chunk);
+                      stepToolApprovalResponses.push(chunk);
                       break;
                     }
                     case "tool-result": {
@@ -7553,7 +8081,7 @@ var DefaultStreamTextResult = class {
                       stepRawFinishReason = chunk.rawFinishReason;
                       stepProviderMetadata = chunk.providerMetadata;
                       const msToFinish = now2() - stepStartTimestampMs;
-                      void ((_f2 = unifiedTelemetry.onChunk) == null ? void 0 : _f2.call(unifiedTelemetry, {
+                      void ((_f2 = telemetryDispatcher.onChunk) == null ? void 0 : _f2.call(telemetryDispatcher, {
                         chunk: {
                           type: "ai.stream.finish",
                           callId,
@@ -7566,21 +8094,6 @@ var DefaultStreamTextResult = class {
                       }));
                       break;
                     }
-                    case "file":
-                    case "reasoning-file": {
-                      controller.enqueue(chunk);
-                      break;
-                    }
-                    case "source": {
-                      controller.enqueue(chunk);
-                      break;
-                    }
-                    case "tool-input-start":
-                    case "tool-input-end":
-                    case "tool-input-delta": {
-                      controller.enqueue(chunk);
-                      break;
-                    }
                     case "error": {
                       controller.enqueue(chunk);
                       stepFinishReason = "error";
@@ -7598,7 +8111,7 @@ var DefaultStreamTextResult = class {
                     }
                   }
                   if (chunkType !== "model-call-end" && chunkType !== "model-call-response-metadata") {
-                    void ((_g2 = unifiedTelemetry.onChunk) == null ? void 0 : _g2.call(unifiedTelemetry, { chunk }));
+                    void ((_g2 = telemetryDispatcher.onChunk) == null ? void 0 : _g2.call(telemetryDispatcher, { chunk }));
                   }
                 },
                 // invoke onFinish callback and resolve toolResults promise when the stream is about to close:
@@ -7622,6 +8135,9 @@ var DefaultStreamTextResult = class {
                   const clientToolOutputs = stepToolOutputs.filter(
                     (toolOutput) => toolOutput.providerExecuted !== true
                   );
+                  const deniedToolApprovalResponses = stepToolApprovalResponses.filter(
+                    (toolApprovalResponse) => toolApprovalResponse.approved === false
+                  );
                   for (const toolCall of stepToolCalls) {
                     if (toolCall.providerExecuted !== true)
                       continue;
@@ -7646,9 +8162,9 @@ var DefaultStreamTextResult = class {
                   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:
+                    // 1. There are client tool calls that have all been executed or denied, OR
+                    // 2. There are pending deferred results from provider-executed tools, OR
+                    (clientToolCalls.length > 0 && clientToolCalls.length === clientToolOutputs.length + deniedToolApprovalResponses.length || pendingDeferredToolCalls.size > 0) && // continue until a stop condition is met:
                     !await isStopConditionMet({
                       stopConditions,
                       steps: recordedSteps
@@ -7700,8 +8216,8 @@ var DefaultStreamTextResult = class {
         usage: createNullLanguageModelUsage()
       });
     })().catch(async (error) => {
-      var _a22;
-      await ((_a22 = unifiedTelemetry.onError) == null ? void 0 : _a22.call(unifiedTelemetry, { callId, error }));
+      var _a21;
+      await ((_a21 = telemetryDispatcher.onError) == null ? void 0 : _a21.call(telemetryDispatcher, { callId, error }));
       self.addStream(
         new ReadableStream({
           start(controller) {
@@ -8044,7 +8560,18 @@ var DefaultStreamTextResult = class {
               controller.enqueue({
                 type: "tool-approval-request",
                 approvalId: part.approvalId,
-                toolCallId: part.toolCall.toolCallId
+                toolCallId: part.toolCall.toolCallId,
+                ...part.isAutomatic != null ? { isAutomatic: part.isAutomatic } : {}
+              });
+              break;
+            }
+            case "tool-approval-response": {
+              controller.enqueue({
+                type: "tool-approval-response",
+                approvalId: part.approvalId,
+                approved: part.approved,
+                ...part.reason != null ? { reason: part.reason } : {},
+                ...part.providerExecuted != null ? { providerExecuted: part.providerExecuted } : {}
               });
               break;
             }
@@ -8239,6 +8766,14 @@ var ToolLoopAgent = class {
   }
   async prepareCall(options) {
     var _a21, _b, _c, _d;
+    if (this.settings.callOptionsSchema != null && options.options !== void 0) {
+      const validatedOptions = await validateTypes3({
+        value: options.options,
+        schema: this.settings.callOptionsSchema,
+        context: { field: "options" }
+      });
+      options = { ...options, options: validatedOptions };
+    }
     const {
       experimental_onStart: _settingsOnStart,
       experimental_onStepStart: _settingsOnStepStart,
@@ -8568,7 +9103,7 @@ async function convertToModelMessages(messages, options) {
         if (message.parts != null) {
           let block = [];
           async function processBlock() {
-            var _a21, _b, _c, _d, _e, _f, _g, _h;
+            var _a21, _b, _c, _d, _e, _f, _g, _h, _i;
             if (block.length === 0) {
               return;
             }
@@ -8622,7 +9157,8 @@ async function convertToModelMessages(messages, options) {
                     content.push({
                       type: "tool-approval-request",
                       approvalId: part.approval.id,
-                      toolCallId: part.toolCallId
+                      toolCallId: part.toolCallId,
+                      isAutomatic: part.approval.isAutomatic
                     });
                   }
                   if (part.providerExecuted === true && part.state !== "approval-responded" && (part.state === "output-available" || part.state === "output-error")) {
@@ -8678,6 +9214,18 @@ async function convertToModelMessages(messages, options) {
                       providerExecuted: toolPart.providerExecuted
                     });
                   }
+                  if (toolPart.state === "approval-responded" && ((_g = toolPart.approval) == null ? void 0 : _g.approved) === false) {
+                    content2.push({
+                      type: "tool-result",
+                      toolCallId: toolPart.toolCallId,
+                      toolName: getToolName(toolPart),
+                      output: {
+                        type: "execution-denied",
+                        reason: toolPart.approval.reason
+                      },
+                      ...toolPart.callProviderMetadata != null ? { providerOptions: toolPart.callProviderMetadata } : {}
+                    });
+                  }
                   if (toolPart.providerExecuted === true) {
                     continue;
                   }
@@ -8689,7 +9237,7 @@ async function convertToModelMessages(messages, options) {
                         toolName: getToolName(toolPart),
                         output: {
                           type: "error-text",
-                          value: (_g = toolPart.approval.reason) != null ? _g : "Tool execution denied."
+                          value: (_h = toolPart.approval.reason) != null ? _h : "Tool call execution denied."
                         },
                         ...toolPart.callProviderMetadata != null ? { providerOptions: toolPart.callProviderMetadata } : {}
                       });
@@ -8706,7 +9254,7 @@ async function convertToModelMessages(messages, options) {
                           toolCallId: toolPart.toolCallId,
                           input: toolPart.input,
                           output: toolPart.state === "output-error" ? toolPart.errorText : toolPart.output,
-                          tool: (_h = options == null ? void 0 : options.tools) == null ? void 0 : _h[toolName],
+                          tool: (_i = options == null ? void 0 : options.tools) == null ? void 0 : _i[toolName],
                           errorMode: toolPart.state === "output-error" ? "text" : "none"
                         }),
                         ...toolPart.callProviderMetadata != null ? { providerOptions: toolPart.callProviderMetadata } : {}
@@ -8753,7 +9301,7 @@ async function convertToModelMessages(messages, options) {
 import { TypeValidationError as TypeValidationError3 } from "@ai-sdk/provider";
 import {
   lazySchema as lazySchema2,
-  validateTypes as validateTypes3,
+  validateTypes as validateTypes4,
   zodSchema as zodSchema2
 } from "@ai-sdk/provider-utils";
 import { z as z8 } from "zod/v4";
@@ -8856,7 +9404,8 @@ var uiMessagesSchema = lazySchema2(
               approval: z8.object({
                 id: z8.string(),
                 approved: z8.never().optional(),
-                reason: z8.never().optional()
+                reason: z8.never().optional(),
+                isAutomatic: z8.boolean().optional()
               })
             }),
             z8.object({
@@ -8872,7 +9421,8 @@ var uiMessagesSchema = lazySchema2(
               approval: z8.object({
                 id: z8.string(),
                 approved: z8.boolean(),
-                reason: z8.string().optional()
+                reason: z8.string().optional(),
+                isAutomatic: z8.boolean().optional()
               })
             }),
             z8.object({
@@ -8890,7 +9440,8 @@ var uiMessagesSchema = lazySchema2(
               approval: z8.object({
                 id: z8.string(),
                 approved: z8.literal(true),
-                reason: z8.string().optional()
+                reason: z8.string().optional(),
+                isAutomatic: z8.boolean().optional()
               }).optional()
             }),
             z8.object({
@@ -8908,7 +9459,8 @@ var uiMessagesSchema = lazySchema2(
               approval: z8.object({
                 id: z8.string(),
                 approved: z8.literal(true),
-                reason: z8.string().optional()
+                reason: z8.string().optional(),
+                isAutomatic: z8.boolean().optional()
               }).optional()
             }),
             z8.object({
@@ -8924,7 +9476,8 @@ var uiMessagesSchema = lazySchema2(
               approval: z8.object({
                 id: z8.string(),
                 approved: z8.literal(false),
-                reason: z8.string().optional()
+                reason: z8.string().optional(),
+                isAutomatic: z8.boolean().optional()
               })
             }),
             z8.object({
@@ -8961,7 +9514,8 @@ var uiMessagesSchema = lazySchema2(
               approval: z8.object({
                 id: z8.string(),
                 approved: z8.never().optional(),
-                reason: z8.never().optional()
+                reason: z8.never().optional(),
+                isAutomatic: z8.boolean().optional()
               })
             }),
             z8.object({
@@ -8976,7 +9530,8 @@ var uiMessagesSchema = lazySchema2(
               approval: z8.object({
                 id: z8.string(),
                 approved: z8.boolean(),
-                reason: z8.string().optional()
+                reason: z8.string().optional(),
+                isAutomatic: z8.boolean().optional()
               })
             }),
             z8.object({
@@ -8993,7 +9548,8 @@ var uiMessagesSchema = lazySchema2(
               approval: z8.object({
                 id: z8.string(),
                 approved: z8.literal(true),
-                reason: z8.string().optional()
+                reason: z8.string().optional(),
+                isAutomatic: z8.boolean().optional()
               }).optional()
             }),
             z8.object({
@@ -9010,7 +9566,8 @@ var uiMessagesSchema = lazySchema2(
               approval: z8.object({
                 id: z8.string(),
                 approved: z8.literal(true),
-                reason: z8.string().optional()
+                reason: z8.string().optional(),
+                isAutomatic: z8.boolean().optional()
               }).optional()
             }),
             z8.object({
@@ -9025,7 +9582,8 @@ var uiMessagesSchema = lazySchema2(
               approval: z8.object({
                 id: z8.string(),
                 approved: z8.literal(false),
-                reason: z8.string().optional()
+                reason: z8.string().optional(),
+                isAutomatic: z8.boolean().optional()
               })
             })
           ])
@@ -9051,13 +9609,13 @@ async function safeValidateUIMessages({
         })
       };
     }
-    const validatedMessages = await validateTypes3({
+    const validatedMessages = await validateTypes4({
       value: messages,
       schema: uiMessagesSchema
     });
     if (metadataSchema) {
       for (const [msgIdx, message] of validatedMessages.entries()) {
-        await validateTypes3({
+        await validateTypes4({
           value: message.metadata,
           schema: metadataSchema,
           context: {
@@ -9088,7 +9646,7 @@ async function safeValidateUIMessages({
                 })
               };
             }
-            await validateTypes3({
+            await validateTypes4({
               value: dataPart.data,
               schema: dataSchema,
               context: {
@@ -9120,7 +9678,7 @@ async function safeValidateUIMessages({
               };
             }
             if (toolPart.state === "input-available" || toolPart.state === "output-available" || toolPart.state === "output-error" && toolPart.input !== void 0) {
-              await validateTypes3({
+              await validateTypes4({
                 value: toolPart.input,
                 schema: tool2.inputSchema,
                 context: {
@@ -9131,7 +9689,7 @@ async function safeValidateUIMessages({
               });
             }
             if (toolPart.state === "output-available" && tool2.outputSchema) {
-              await validateTypes3({
+              await validateTypes4({
                 value: toolPart.output,
                 schema: tool2.outputSchema,
                 context: {
@@ -9246,10 +9804,10 @@ async function pipeAgentUIStreamToResponse({
 
 // src/embed/embed.ts
 import {
-  createIdGenerator as createIdGenerator3,
+  createIdGenerator as createIdGenerator4,
   withUserAgentSuffix as withUserAgentSuffix3
 } from "@ai-sdk/provider-utils";
-var originalGenerateCallId3 = createIdGenerator3({
+var originalGenerateCallId4 = createIdGenerator4({
   prefix: "call",
   size: 24
 });
@@ -9264,9 +9822,9 @@ async function embed({
   telemetry = experimental_telemetry,
   experimental_onStart: onStart,
   experimental_onFinish: onFinish,
-  _internal: { generateCallId = originalGenerateCallId3 } = {}
+  _internal: { generateCallId = originalGenerateCallId4 } = {}
 }) {
-  var _a21, _b, _c;
+  var _a21;
   const model = resolveEmbeddingModel(modelArg);
   const { maxRetries, retry } = prepareRetries({
     maxRetries: maxRetriesArg,
@@ -9277,8 +9835,8 @@ async function embed({
     `ai/${VERSION}`
   );
   const callId = generateCallId();
-  const unifiedTelemetry = createUnifiedTelemetry({
-    integrations: telemetry == null ? void 0 : telemetry.integrations
+  const telemetryDispatcher = createTelemetryDispatcher({
+    telemetry
   });
   await notify({
     event: {
@@ -9289,17 +9847,13 @@ async function embed({
       value,
       maxRetries,
       headers: headersWithUserAgent,
-      providerOptions,
-      isEnabled: (_a21 = telemetry == null ? void 0 : telemetry.isEnabled) != null ? _a21 : true,
-      recordInputs: telemetry == null ? void 0 : telemetry.recordInputs,
-      recordOutputs: telemetry == null ? void 0 : telemetry.recordOutputs,
-      functionId: telemetry == null ? void 0 : telemetry.functionId
+      providerOptions
     },
-    callbacks: [onStart, unifiedTelemetry.onStart]
+    callbacks: [onStart, telemetryDispatcher.onStart]
   });
   try {
     const { embedding, usage, warnings, response, providerMetadata } = await retry(async () => {
-      var _a22, _b2;
+      var _a22;
       const embedCallId = generateCallId();
       await notify({
         event: {
@@ -9308,13 +9862,9 @@ async function embed({
           operationId: "ai.embed.doEmbed",
           provider: model.provider,
           modelId: model.modelId,
-          values: [value],
-          isEnabled: (_a22 = telemetry == null ? void 0 : telemetry.isEnabled) != null ? _a22 : true,
-          recordInputs: telemetry == null ? void 0 : telemetry.recordInputs,
-          recordOutputs: telemetry == null ? void 0 : telemetry.recordOutputs,
-          functionId: telemetry == null ? void 0 : telemetry.functionId
+          values: [value]
         },
-        callbacks: [unifiedTelemetry.onEmbedStart]
+        callbacks: [telemetryDispatcher.onEmbedStart]
       });
       const modelResponse = await model.doEmbed({
         values: [value],
@@ -9323,7 +9873,7 @@ async function embed({
         providerOptions
       });
       const embedding2 = modelResponse.embeddings[0];
-      const usage2 = (_b2 = modelResponse.usage) != null ? _b2 : { tokens: NaN };
+      const usage2 = (_a22 = modelResponse.usage) != null ? _a22 : { tokens: NaN };
       await notify({
         event: {
           callId,
@@ -9335,7 +9885,7 @@ async function embed({
           embeddings: modelResponse.embeddings,
           usage: usage2
         },
-        callbacks: [unifiedTelemetry.onEmbedFinish]
+        callbacks: [telemetryDispatcher.onEmbedFinish]
       });
       return {
         embedding: embedding2,
@@ -9357,13 +9907,9 @@ async function embed({
         usage,
         warnings,
         providerMetadata,
-        response,
-        isEnabled: (_b = telemetry == null ? void 0 : telemetry.isEnabled) != null ? _b : true,
-        recordInputs: telemetry == null ? void 0 : telemetry.recordInputs,
-        recordOutputs: telemetry == null ? void 0 : telemetry.recordOutputs,
-        functionId: telemetry == null ? void 0 : telemetry.functionId
+        response
       },
-      callbacks: [onFinish, unifiedTelemetry.onFinish]
+      callbacks: [onFinish, telemetryDispatcher.onFinish]
     });
     return new DefaultEmbedResult({
       value,
@@ -9374,7 +9920,7 @@ async function embed({
       response
     });
   } catch (error) {
-    await ((_c = unifiedTelemetry.onError) == null ? void 0 : _c.call(unifiedTelemetry, { callId, error }));
+    await ((_a21 = telemetryDispatcher.onError) == null ? void 0 : _a21.call(telemetryDispatcher, { callId, error }));
     throw error;
   }
 }
@@ -9391,7 +9937,7 @@ var DefaultEmbedResult = class {
 
 // src/embed/embed-many.ts
 import {
-  createIdGenerator as createIdGenerator4,
+  createIdGenerator as createIdGenerator5,
   withUserAgentSuffix as withUserAgentSuffix4
 } from "@ai-sdk/provider-utils";
 
@@ -9408,7 +9954,7 @@ function splitArray(array2, chunkSize) {
 }
 
 // src/embed/embed-many.ts
-var originalGenerateCallId4 = createIdGenerator4({
+var originalGenerateCallId5 = createIdGenerator5({
   prefix: "call",
   size: 24
 });
@@ -9424,9 +9970,9 @@ async function embedMany({
   telemetry = experimental_telemetry,
   experimental_onStart: onStart,
   experimental_onFinish: onFinish,
-  _internal: { generateCallId = originalGenerateCallId4 } = {}
+  _internal: { generateCallId = originalGenerateCallId5 } = {}
 }) {
-  var _a21, _b, _c, _d, _e;
+  var _a21, _b;
   const model = resolveEmbeddingModel(modelArg);
   const { maxRetries, retry } = prepareRetries({
     maxRetries: maxRetriesArg,
@@ -9437,8 +9983,8 @@ async function embedMany({
     `ai/${VERSION}`
   );
   const callId = generateCallId();
-  const unifiedTelemetry = createUnifiedTelemetry({
-    integrations: telemetry == null ? void 0 : telemetry.integrations
+  const telemetryDispatcher = createTelemetryDispatcher({
+    telemetry
   });
   await notify({
     event: {
@@ -9449,13 +9995,9 @@ async function embedMany({
       value: values,
       maxRetries,
       headers: headersWithUserAgent,
-      providerOptions,
-      isEnabled: (_a21 = telemetry == null ? void 0 : telemetry.isEnabled) != null ? _a21 : true,
-      recordInputs: telemetry == null ? void 0 : telemetry.recordInputs,
-      recordOutputs: telemetry == null ? void 0 : telemetry.recordOutputs,
-      functionId: telemetry == null ? void 0 : telemetry.functionId
+      providerOptions
     },
-    callbacks: [onStart, unifiedTelemetry.onStart]
+    callbacks: [onStart, telemetryDispatcher.onStart]
   });
   try {
     const [maxEmbeddingsPerCall, supportsParallelCalls] = await Promise.all([
@@ -9464,7 +10006,7 @@ async function embedMany({
     ]);
     if (maxEmbeddingsPerCall == null || maxEmbeddingsPerCall === Infinity) {
       const { embeddings: embeddings2, usage, warnings: warnings2, response, providerMetadata: providerMetadata2 } = await retry(async () => {
-        var _a22, _b2;
+        var _a22;
         const embedCallId = generateCallId();
         await notify({
           event: {
@@ -9473,13 +10015,9 @@ async function embedMany({
             operationId: "ai.embedMany.doEmbed",
             provider: model.provider,
             modelId: model.modelId,
-            values,
-            isEnabled: (_a22 = telemetry == null ? void 0 : telemetry.isEnabled) != null ? _a22 : true,
-            recordInputs: telemetry == null ? void 0 : telemetry.recordInputs,
-            recordOutputs: telemetry == null ? void 0 : telemetry.recordOutputs,
-            functionId: telemetry == null ? void 0 : telemetry.functionId
+            values
           },
-          callbacks: [unifiedTelemetry.onEmbedStart]
+          callbacks: [telemetryDispatcher.onEmbedStart]
         });
         const modelResponse = await model.doEmbed({
           values,
@@ -9488,7 +10026,7 @@ async function embedMany({
           providerOptions
         });
         const embeddings3 = modelResponse.embeddings;
-        const usage2 = (_b2 = modelResponse.usage) != null ? _b2 : { tokens: NaN };
+        const usage2 = (_a22 = modelResponse.usage) != null ? _a22 : { tokens: NaN };
         await notify({
           event: {
             callId,
@@ -9500,7 +10038,7 @@ async function embedMany({
             embeddings: embeddings3,
             usage: usage2
           },
-          callbacks: [unifiedTelemetry.onEmbedFinish]
+          callbacks: [telemetryDispatcher.onEmbedFinish]
         });
         return {
           embeddings: embeddings3,
@@ -9526,13 +10064,9 @@ async function embedMany({
           usage,
           warnings: warnings2,
           providerMetadata: providerMetadata2,
-          response: [response],
-          isEnabled: (_b = telemetry == null ? void 0 : telemetry.isEnabled) != null ? _b : true,
-          recordInputs: telemetry == null ? void 0 : telemetry.recordInputs,
-          recordOutputs: telemetry == null ? void 0 : telemetry.recordOutputs,
-          functionId: telemetry == null ? void 0 : telemetry.functionId
+          response: [response]
         },
-        callbacks: [onFinish, unifiedTelemetry.onFinish]
+        callbacks: [onFinish, telemetryDispatcher.onFinish]
       });
       return new DefaultEmbedManyResult({
         values,
@@ -9557,7 +10091,7 @@ async function embedMany({
       const results = await Promise.all(
         parallelChunk.map((chunk) => {
           return retry(async () => {
-            var _a22, _b2;
+            var _a22;
             const embedCallId = generateCallId();
             await notify({
               event: {
@@ -9566,13 +10100,9 @@ async function embedMany({
                 operationId: "ai.embedMany.doEmbed",
                 provider: model.provider,
                 modelId: model.modelId,
-                values: chunk,
-                isEnabled: (_a22 = telemetry == null ? void 0 : telemetry.isEnabled) != null ? _a22 : true,
-                recordInputs: telemetry == null ? void 0 : telemetry.recordInputs,
-                recordOutputs: telemetry == null ? void 0 : telemetry.recordOutputs,
-                functionId: telemetry == null ? void 0 : telemetry.functionId
+                values: chunk
               },
-              callbacks: [unifiedTelemetry.onEmbedStart]
+              callbacks: [telemetryDispatcher.onEmbedStart]
             });
             const modelResponse = await model.doEmbed({
               values: chunk,
@@ -9581,7 +10111,7 @@ async function embedMany({
               providerOptions
             });
             const chunkEmbeddings = modelResponse.embeddings;
-            const usage = (_b2 = modelResponse.usage) != null ? _b2 : { tokens: NaN };
+            const usage = (_a22 = modelResponse.usage) != null ? _a22 : { tokens: NaN };
             await notify({
               event: {
                 callId,
@@ -9593,7 +10123,7 @@ async function embedMany({
                 embeddings: chunkEmbeddings,
                 usage
               },
-              callbacks: [unifiedTelemetry.onEmbedFinish]
+              callbacks: [telemetryDispatcher.onEmbedFinish]
             });
             return {
               embeddings: chunkEmbeddings,
@@ -9618,7 +10148,7 @@ async function embedMany({
               result.providerMetadata
             )) {
               providerMetadata[providerName] = {
-                ...(_c = providerMetadata[providerName]) != null ? _c : {},
+                ...(_a21 = providerMetadata[providerName]) != null ? _a21 : {},
                 ...metadata
               };
             }
@@ -9642,13 +10172,9 @@ async function embedMany({
         usage: { tokens },
         warnings,
         providerMetadata,
-        response: responses,
-        isEnabled: (_d = telemetry == null ? void 0 : telemetry.isEnabled) != null ? _d : true,
-        recordInputs: telemetry == null ? void 0 : telemetry.recordInputs,
-        recordOutputs: telemetry == null ? void 0 : telemetry.recordOutputs,
-        functionId: telemetry == null ? void 0 : telemetry.functionId
+        response: responses
       },
-      callbacks: [onFinish, unifiedTelemetry.onFinish]
+      callbacks: [onFinish, telemetryDispatcher.onFinish]
     });
     return new DefaultEmbedManyResult({
       values,
@@ -9659,7 +10185,7 @@ async function embedMany({
       responses
     });
   } catch (error) {
-    await ((_e = unifiedTelemetry.onError) == null ? void 0 : _e.call(unifiedTelemetry, { callId, error }));
+    await ((_b = telemetryDispatcher.onError) == null ? void 0 : _b.call(telemetryDispatcher, { callId, error }));
     throw error;
   }
 }
@@ -9864,7 +10390,7 @@ var experimental_generateImage = generateImage;
 
 // src/generate-object/generate-object.ts
 import {
-  createIdGenerator as createIdGenerator5,
+  createIdGenerator as createIdGenerator6,
   withUserAgentSuffix as withUserAgentSuffix6
 } from "@ai-sdk/provider-utils";
 
@@ -10331,15 +10857,16 @@ function validateObjectGenerationInput({
 }
 
 // src/generate-object/generate-object.ts
-var originalGenerateId3 = createIdGenerator5({ prefix: "aiobj", size: 24 });
+var originalGenerateId4 = createIdGenerator6({ prefix: "aiobj", size: 24 });
 async function generateObject(options) {
-  var _a21, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+  var _a21, _b, _c, _d, _e, _f, _g, _h, _i, _j;
   const {
     model: modelArg,
     output = "object",
     system,
     prompt,
     messages,
+    allowSystemInMessages,
     maxRetries: maxRetriesArg,
     abortSignal,
     headers,
@@ -10353,7 +10880,7 @@ async function generateObject(options) {
     onStepFinish,
     onFinish,
     _internal: {
-      generateId: generateId2 = originalGenerateId3,
+      generateId: generateId2 = originalGenerateId4,
       currentDate = () => /* @__PURE__ */ new Date()
     } = {},
     ...settings
@@ -10386,8 +10913,8 @@ async function generateObject(options) {
     headers != null ? headers : {},
     `ai/${VERSION}`
   );
-  const unifiedTelemetry = createUnifiedTelemetry({
-    integrations: telemetry == null ? void 0 : telemetry.integrations
+  const telemetryDispatcher = createTelemetryDispatcher({
+    telemetry
   });
   const jsonSchema2 = await outputStrategy.jsonSchema();
   const callId = generateId2();
@@ -10413,19 +10940,16 @@ async function generateObject(options) {
       output: outputStrategy.type,
       schema: jsonSchema2,
       schemaName,
-      schemaDescription,
-      isEnabled: (_a21 = telemetry == null ? void 0 : telemetry.isEnabled) != null ? _a21 : true,
-      recordInputs: telemetry == null ? void 0 : telemetry.recordInputs,
-      recordOutputs: telemetry == null ? void 0 : telemetry.recordOutputs,
-      functionId: telemetry == null ? void 0 : telemetry.functionId
+      schemaDescription
     },
-    callbacks: [onStart, unifiedTelemetry.onStart]
+    callbacks: [onStart, telemetryDispatcher.onStart]
   });
   try {
     const standardizedPrompt = await standardizePrompt({
       system,
       prompt,
-      messages
+      messages,
+      allowSystemInMessages
     });
     const promptMessages = await convertToLanguageModelPrompt({
       prompt: standardizedPrompt,
@@ -10441,10 +10965,9 @@ async function generateObject(options) {
         modelId: model.modelId,
         providerOptions,
         headers: headersWithUserAgent,
-        functionId: telemetry == null ? void 0 : telemetry.functionId,
         promptMessages
       },
-      callbacks: [onStepStart, unifiedTelemetry.onObjectStepStart]
+      callbacks: [onStepStart, telemetryDispatcher.onObjectStepStart]
     });
     const generateResult = await retry(
       () => model.doGenerate({
@@ -10462,11 +10985,11 @@ async function generateObject(options) {
       })
     );
     const responseData = {
-      id: (_c = (_b = generateResult.response) == null ? void 0 : _b.id) != null ? _c : generateId2(),
-      timestamp: (_e = (_d = generateResult.response) == null ? void 0 : _d.timestamp) != null ? _e : currentDate(),
-      modelId: (_g = (_f = generateResult.response) == null ? void 0 : _f.modelId) != null ? _g : model.modelId,
-      headers: (_h = generateResult.response) == null ? void 0 : _h.headers,
-      body: (_i = generateResult.response) == null ? void 0 : _i.body
+      id: (_b = (_a21 = generateResult.response) == null ? void 0 : _a21.id) != null ? _b : generateId2(),
+      timestamp: (_d = (_c = generateResult.response) == null ? void 0 : _c.timestamp) != null ? _d : currentDate(),
+      modelId: (_f = (_e = generateResult.response) == null ? void 0 : _e.modelId) != null ? _f : model.modelId,
+      headers: (_g = generateResult.response) == null ? void 0 : _g.headers,
+      body: (_h = generateResult.response) == null ? void 0 : _h.body
     };
     const text2 = extractTextContent(generateResult.content);
     const reasoning = extractReasoningContent(generateResult.content);
@@ -10482,7 +11005,7 @@ async function generateObject(options) {
     const usage = asLanguageModelUsage(generateResult.usage);
     const warnings = generateResult.warnings;
     const resultProviderMetadata = generateResult.providerMetadata;
-    const request = (_j = generateResult.request) != null ? _j : {};
+    const request = (_i = generateResult.request) != null ? _i : {};
     const response = responseData;
     logWarnings({
       warnings,
@@ -10502,12 +11025,11 @@ async function generateObject(options) {
       warnings,
       request,
       response,
-      providerMetadata: resultProviderMetadata,
-      functionId: telemetry == null ? void 0 : telemetry.functionId
+      providerMetadata: resultProviderMetadata
     };
     await notify({
       event: stepFinishEvent,
-      callbacks: [onStepFinish, unifiedTelemetry.onObjectStepFinish]
+      callbacks: [onStepFinish, telemetryDispatcher.onObjectStepFinish]
     });
     const object2 = await parseAndValidateObjectResultWithRepair(
       text2,
@@ -10530,10 +11052,9 @@ async function generateObject(options) {
         warnings,
         request,
         response,
-        providerMetadata: resultProviderMetadata,
-        functionId: telemetry == null ? void 0 : telemetry.functionId
+        providerMetadata: resultProviderMetadata
       },
-      callbacks: [onFinish, unifiedTelemetry.onFinish]
+      callbacks: [onFinish, telemetryDispatcher.onFinish]
     });
     return new DefaultGenerateObjectResult({
       object: object2,
@@ -10546,7 +11067,7 @@ async function generateObject(options) {
       providerMetadata: resultProviderMetadata
     });
   } catch (error) {
-    await ((_k = unifiedTelemetry.onError) == null ? void 0 : _k.call(unifiedTelemetry, { callId, error }));
+    await ((_j = telemetryDispatcher.onError) == null ? void 0 : _j.call(telemetryDispatcher, { callId, error }));
     throw wrapGatewayError(error);
   }
 }
@@ -10574,7 +11095,7 @@ var DefaultGenerateObjectResult = class {
 
 // src/generate-object/stream-object.ts
 import {
-  createIdGenerator as createIdGenerator6,
+  createIdGenerator as createIdGenerator7,
   DelayedPromise as DelayedPromise2
 } from "@ai-sdk/provider-utils";
 
@@ -10714,7 +11235,7 @@ function simulateReadableStream({
 }
 
 // src/generate-object/stream-object.ts
-var originalGenerateId4 = createIdGenerator6({ prefix: "aiobj", size: 24 });
+var originalGenerateId5 = createIdGenerator7({ prefix: "aiobj", size: 24 });
 function streamObject(options) {
   const {
     model,
@@ -10722,6 +11243,7 @@ function streamObject(options) {
     system,
     prompt,
     messages,
+    allowSystemInMessages,
     maxRetries,
     abortSignal,
     headers,
@@ -10738,7 +11260,7 @@ function streamObject(options) {
     },
     onFinish,
     _internal: {
-      generateId: generateId2 = originalGenerateId4,
+      generateId: generateId2 = originalGenerateId5,
       currentDate = () => /* @__PURE__ */ new Date(),
       now: now2 = now
     } = {},
@@ -10773,6 +11295,7 @@ function streamObject(options) {
     system,
     prompt,
     messages,
+    allowSystemInMessages,
     schemaName,
     schemaDescription,
     providerOptions,
@@ -10800,6 +11323,7 @@ var DefaultStreamObjectResult = class {
     system,
     prompt,
     messages,
+    allowSystemInMessages,
     schemaName,
     schemaDescription,
     providerOptions,
@@ -10827,8 +11351,8 @@ var DefaultStreamObjectResult = class {
       abortSignal
     });
     const callSettings = prepareLanguageModelCallOptions(settings);
-    const unifiedTelemetry = createUnifiedTelemetry({
-      integrations: telemetry == null ? void 0 : telemetry.integrations
+    const telemetryDispatcher = createTelemetryDispatcher({
+      telemetry
     });
     const self = this;
     const stitchableStream = createStitchableStream();
@@ -10843,7 +11367,6 @@ var DefaultStreamObjectResult = class {
     this.baseStream = stitchableStream.stream.pipeThrough(eventProcessor);
     const callId = generateId2();
     (async () => {
-      var _a21;
       const jsonSchema2 = await outputStrategy.jsonSchema();
       await notify({
         event: {
@@ -10867,18 +11390,15 @@ var DefaultStreamObjectResult = class {
           output: outputStrategy.type,
           schema: jsonSchema2,
           schemaName,
-          schemaDescription,
-          isEnabled: (_a21 = telemetry == null ? void 0 : telemetry.isEnabled) != null ? _a21 : true,
-          recordInputs: telemetry == null ? void 0 : telemetry.recordInputs,
-          recordOutputs: telemetry == null ? void 0 : telemetry.recordOutputs,
-          functionId: telemetry == null ? void 0 : telemetry.functionId
+          schemaDescription
         },
-        callbacks: [onStart, unifiedTelemetry.onStart]
+        callbacks: [onStart, telemetryDispatcher.onStart]
       });
       const standardizedPrompt = await standardizePrompt({
         system,
         prompt,
-        messages
+        messages,
+        allowSystemInMessages
       });
       const callOptions = {
         responseFormat: {
@@ -10907,10 +11427,9 @@ var DefaultStreamObjectResult = class {
           modelId: model.modelId,
           providerOptions,
           headers,
-          functionId: telemetry == null ? void 0 : telemetry.functionId,
           promptMessages: callOptions.prompt
         },
-        callbacks: [onStepStart, unifiedTelemetry.onObjectStepStart]
+        callbacks: [onStepStart, telemetryDispatcher.onObjectStepStart]
       });
       const transformer = {
         transform: (chunk, controller) => {
@@ -10953,7 +11472,7 @@ var DefaultStreamObjectResult = class {
       const transformedStream = stream.pipeThrough(new TransformStream(transformer)).pipeThrough(
         new TransformStream({
           async transform(chunk, controller) {
-            var _a22, _b, _c;
+            var _a21, _b, _c;
             if (typeof chunk === "object" && chunk.type === "stream-start") {
               warnings = chunk.warnings;
               return;
@@ -10997,7 +11516,7 @@ var DefaultStreamObjectResult = class {
             switch (chunk.type) {
               case "response-metadata": {
                 fullResponse = {
-                  id: (_a22 = chunk.id) != null ? _a22 : fullResponse.id,
+                  id: (_a21 = chunk.id) != null ? _a21 : fullResponse.id,
                   timestamp: (_b = chunk.timestamp) != null ? _b : fullResponse.timestamp,
                   modelId: (_c = chunk.modelId) != null ? _c : fullResponse.modelId
                 };
@@ -11077,12 +11596,11 @@ var DefaultStreamObjectResult = class {
                     ...fullResponse,
                     headers: response == null ? void 0 : response.headers
                   },
-                  providerMetadata,
-                  functionId: telemetry == null ? void 0 : telemetry.functionId
+                  providerMetadata
                 },
                 callbacks: [
                   onStepFinish,
-                  unifiedTelemetry.onObjectStepFinish
+                  telemetryDispatcher.onObjectStepFinish
                 ]
               });
               await notify({
@@ -11099,10 +11617,9 @@ var DefaultStreamObjectResult = class {
                     ...fullResponse,
                     headers: response == null ? void 0 : response.headers
                   },
-                  providerMetadata,
-                  functionId: telemetry == null ? void 0 : telemetry.functionId
+                  providerMetadata
                 },
-                callbacks: [onFinish, unifiedTelemetry.onFinish]
+                callbacks: [onFinish, telemetryDispatcher.onFinish]
               });
             } catch (error2) {
               controller.enqueue({ type: "error", error: error2 });
@@ -11113,7 +11630,7 @@ var DefaultStreamObjectResult = class {
       stitchableStream.addStream(transformedStream);
     })().catch(async (error) => {
       var _a21;
-      await ((_a21 = unifiedTelemetry.onError) == null ? void 0 : _a21.call(unifiedTelemetry, { callId, error }));
+      await ((_a21 = telemetryDispatcher.onError) == null ? void 0 : _a21.call(telemetryDispatcher, { callId, error }));
       stitchableStream.addStream(
         new ReadableStream({
           start(controller) {
@@ -12634,8 +13151,8 @@ var DefaultProviderRegistry = class {
 };
 
 // src/rerank/rerank.ts
-import { createIdGenerator as createIdGenerator7 } from "@ai-sdk/provider-utils";
-var originalGenerateCallId5 = createIdGenerator7({
+import { createIdGenerator as createIdGenerator8 } from "@ai-sdk/provider-utils";
+var originalGenerateCallId6 = createIdGenerator8({
   prefix: "call",
   size: 24
 });
@@ -12652,13 +13169,13 @@ async function rerank({
   telemetry = experimental_telemetry,
   experimental_onStart: onStart,
   experimental_onFinish: onFinish,
-  _internal: { generateCallId = originalGenerateCallId5 } = {}
+  _internal: { generateCallId = originalGenerateCallId6 } = {}
 }) {
-  var _a21, _b, _c, _d, _e, _f, _g, _h, _i;
+  var _a21, _b, _c, _d, _e;
   const model = resolveRerankingModel(modelArg);
   const callId = generateCallId();
-  const unifiedTelemetry = createUnifiedTelemetry({
-    integrations: telemetry == null ? void 0 : telemetry.integrations
+  const telemetryDispatcher = createTelemetryDispatcher({
+    telemetry
   });
   if (documents.length === 0) {
     await notify({
@@ -12672,13 +13189,9 @@ async function rerank({
         topN,
         maxRetries: maxRetriesArg != null ? maxRetriesArg : 2,
         headers,
-        providerOptions,
-        isEnabled: (_a21 = telemetry == null ? void 0 : telemetry.isEnabled) != null ? _a21 : true,
-        recordInputs: telemetry == null ? void 0 : telemetry.recordInputs,
-        recordOutputs: telemetry == null ? void 0 : telemetry.recordOutputs,
-        functionId: telemetry == null ? void 0 : telemetry.functionId
+        providerOptions
       },
-      callbacks: [onStart, unifiedTelemetry.onStart]
+      callbacks: [onStart, telemetryDispatcher.onStart]
     });
     await notify({
       event: {
@@ -12694,13 +13207,9 @@ async function rerank({
         response: {
           timestamp: /* @__PURE__ */ new Date(),
           modelId: model.modelId
-        },
-        isEnabled: (_b = telemetry == null ? void 0 : telemetry.isEnabled) != null ? _b : true,
-        recordInputs: telemetry == null ? void 0 : telemetry.recordInputs,
-        recordOutputs: telemetry == null ? void 0 : telemetry.recordOutputs,
-        functionId: telemetry == null ? void 0 : telemetry.functionId
+        }
       },
-      callbacks: [onFinish, unifiedTelemetry.onFinish]
+      callbacks: [onFinish, telemetryDispatcher.onFinish]
     });
     return new DefaultRerankResult({
       originalDocuments: [],
@@ -12728,18 +13237,13 @@ async function rerank({
       topN,
       maxRetries,
       headers,
-      providerOptions,
-      isEnabled: (_c = telemetry == null ? void 0 : telemetry.isEnabled) != null ? _c : true,
-      recordInputs: telemetry == null ? void 0 : telemetry.recordInputs,
-      recordOutputs: telemetry == null ? void 0 : telemetry.recordOutputs,
-      functionId: telemetry == null ? void 0 : telemetry.functionId
+      providerOptions
     },
-    callbacks: [onStart, unifiedTelemetry.onStart]
+    callbacks: [onStart, telemetryDispatcher.onStart]
   });
   try {
     const { ranking, response, providerMetadata, warnings } = await retry(
       async () => {
-        var _a22;
         await notify({
           event: {
             callId,
@@ -12749,13 +13253,9 @@ async function rerank({
             documents,
             documentsType: documentsToSend.type,
             query,
-            topN,
-            isEnabled: (_a22 = telemetry == null ? void 0 : telemetry.isEnabled) != null ? _a22 : true,
-            recordInputs: telemetry == null ? void 0 : telemetry.recordInputs,
-            recordOutputs: telemetry == null ? void 0 : telemetry.recordOutputs,
-            functionId: telemetry == null ? void 0 : telemetry.functionId
+            topN
           },
-          callbacks: [unifiedTelemetry.onRerankStart]
+          callbacks: [telemetryDispatcher.onRerankStart]
         });
         const modelResponse = await model.doRerank({
           documents: documentsToSend,
@@ -12775,7 +13275,7 @@ async function rerank({
             documentsType: documentsToSend.type,
             ranking: ranking2
           },
-          callbacks: [unifiedTelemetry.onRerankFinish]
+          callbacks: [telemetryDispatcher.onRerankFinish]
         });
         return {
           ranking: ranking2,
@@ -12807,17 +13307,13 @@ async function rerank({
         providerMetadata,
         response: {
           id: response == null ? void 0 : response.id,
-          timestamp: (_d = response == null ? void 0 : response.timestamp) != null ? _d : /* @__PURE__ */ new Date(),
-          modelId: (_e = response == null ? void 0 : response.modelId) != null ? _e : model.modelId,
+          timestamp: (_a21 = response == null ? void 0 : response.timestamp) != null ? _a21 : /* @__PURE__ */ new Date(),
+          modelId: (_b = response == null ? void 0 : response.modelId) != null ? _b : model.modelId,
           headers: response == null ? void 0 : response.headers,
           body: response == null ? void 0 : response.body
-        },
-        isEnabled: (_f = telemetry == null ? void 0 : telemetry.isEnabled) != null ? _f : true,
-        recordInputs: telemetry == null ? void 0 : telemetry.recordInputs,
-        recordOutputs: telemetry == null ? void 0 : telemetry.recordOutputs,
-        functionId: telemetry == null ? void 0 : telemetry.functionId
+        }
       },
-      callbacks: [onFinish, unifiedTelemetry.onFinish]
+      callbacks: [onFinish, telemetryDispatcher.onFinish]
     });
     return new DefaultRerankResult({
       originalDocuments: documents,
@@ -12829,14 +13325,14 @@ async function rerank({
       providerMetadata,
       response: {
         id: response == null ? void 0 : response.id,
-        timestamp: (_g = response == null ? void 0 : response.timestamp) != null ? _g : /* @__PURE__ */ new Date(),
-        modelId: (_h = response == null ? void 0 : response.modelId) != null ? _h : model.modelId,
+        timestamp: (_c = response == null ? void 0 : response.timestamp) != null ? _c : /* @__PURE__ */ new Date(),
+        modelId: (_d = response == null ? void 0 : response.modelId) != null ? _d : model.modelId,
         headers: response == null ? void 0 : response.headers,
         body: response == null ? void 0 : response.body
       }
     });
   } catch (error) {
-    await ((_i = unifiedTelemetry.onError) == null ? void 0 : _i.call(unifiedTelemetry, { callId, error }));
+    await ((_e = telemetryDispatcher.onError) == null ? void 0 : _e.call(telemetryDispatcher, { callId, error }));
     throw error;
   }
 }
@@ -13900,7 +14396,7 @@ export {
   createAgentUIStreamResponse,
   createDownload,
   createGateway,
-  createIdGenerator8 as createIdGenerator,
+  createIdGenerator9 as createIdGenerator,
   createProviderRegistry,
   createTextStreamResponse,
   createUIMessageStream,